[codegen][Go] Fix compilation error of generated go code when schema is free form object

modules/openapi-generator/src/main/java/org/openapitools/codegen/CodegenProperty.java

@@ -76,7 +76,15 @@ public class CodegenProperty implements Cloneable, IJsonSchemaValidationProperti
     public boolean isUuid;
     public boolean isUri;
     public boolean isEmail;
+    /**
+     * The type is a free-form object, i.e. it is a map of string to values with no declared properties
+     */
     public boolean isFreeFormObject;
+    /**
+     * The 'type' in the OAS schema is unspecified (i.e. not set). The value can be number, integer, string, object or array.
+     * If the nullable attribute is set to true, the 'null' value is valid.
+     */
+    public boolean isAnyType;
     public boolean isListContainer;
     public boolean isMapContainer;
     public boolean isEnum;

modules/openapi-generator/src/main/java/org/openapitools/codegen/DefaultCodegen.java

@@ -1884,14 +1884,19 @@ private String getPrimitiveType(Schema schema) {
             }
             return "string";
         } else if (ModelUtils.isFreeFormObject(schema)) {
+            // Note: the value of a free-form object cannot be an arbitrary type. Per OAS specification,
+            // it must be a map of string to values.
             return "object";
         } else if (schema.getProperties() != null && !schema.getProperties().isEmpty()) { // having property implies it's a model
             return "object";
         } else if (StringUtils.isNotEmpty(schema.getType())) {
             LOGGER.warn("Unknown type found in the schema: " + schema.getType());
             return schema.getType();
         }
-
+        // The 'type' attribute has not been set in the OAS schema, which means the value
+        // can be an arbitrary type, e.g. integer, string, object, array, number...
+        // TODO: we should return a different value to distinguish between free-form object
+        // and arbitrary type.
         return "object";
     }
 
@@ -2647,6 +2652,9 @@ public CodegenProperty fromProperty(String name, Schema p) {
             setNonArrayMapProperty(property, type);
             Schema refOrCurrent = ModelUtils.getReferencedSchema(this.openAPI, p);
             property.isModel = (ModelUtils.isComposedSchema(refOrCurrent) || ModelUtils.isObjectSchema(refOrCurrent)) && ModelUtils.isModel(refOrCurrent);
+            if (ModelUtils.isAnyTypeSchema(p)) {
+                property.isAnyType = true;
+            }
         }
 
         LOGGER.debug("debugging from property return: " + property);

modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/AbstractGoCodegen.java

@@ -91,7 +91,10 @@ public AbstractGoCodegen() {
                         "complex64",
                         "complex128",
                         "rune",
-                        "byte")
+                        "byte",
+                        "map[string]interface{}",
+                        "interface{}"
+                        )
         );
 
         instantiationTypes.clear();
@@ -116,7 +119,17 @@ public AbstractGoCodegen() {
         typeMapping.put("file", "*os.File");
         typeMapping.put("binary", "*os.File");
         typeMapping.put("ByteArray", "string");
+        // A 'type: object' OAS schema without any declared property is
+        // (per JSON schema specification) "an unordered set of properties
+        // mapping a string to an instance".
+        // Hence map[string]interface{} is the proper implementation in golang.
+        // Note: OpenAPITools uses the same token 'object' for free-form objects
+        // and arbitrary types. A free form object is implemented in golang as
+        // map[string]interface{}, whereas an arbitrary type is implemented
+        // in golang as interface{}.
+        // See issue #5387 for more details.
         typeMapping.put("object", "map[string]interface{}");
+        typeMapping.put("interface{}", "interface{}");
 
         numberTypes = new HashSet<String>(
                 Arrays.asList(
@@ -286,6 +299,12 @@ public String toApiFilename(String name) {
         return name;
     }
 
+    /**
+     * Return the golang implementation type for the specified property.
+     * 
+     * @param the OAS property.
+     * @return the golang implementation type.
+     */
     @Override
     public String getTypeDeclaration(Schema p) {
         if (ModelUtils.isArraySchema(p)) {
@@ -325,6 +344,12 @@ public String getTypeDeclaration(Schema p) {
         return toModelName(openAPIType);
     }
 
+    /**
+     * Return the OpenAPI type for the property.
+     * 
+     * @param p the OAS property.
+     * @return the OpenAPI type.
+     */
     @Override
     public String getSchemaType(Schema p) {
         String openAPIType = super.getSchemaType(p);
@@ -333,6 +358,9 @@ public String getSchemaType(Schema p) {
 
         if (ref != null && !ref.isEmpty()) {
             type = openAPIType;
+        } else if (openAPIType == "object" && ModelUtils.isAnyTypeSchema(p)) {
+            // Arbitrary type. Note this is not the same thing as free-form object.
+            type = "interface{}";
         } else if (typeMapping.containsKey(openAPIType)) {
             type = typeMapping.get(openAPIType);
             if (languageSpecificPrimitives.contains(type))

modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GoClientExperimentalCodegen.java

@@ -162,7 +162,8 @@ public Map<String, Object> postProcessModels(Map<String, Object> objs) {
                 }
 
                 for (CodegenProperty param : model.vars) {
-                    if (!param.isNullable || param.isMapContainer || param.isListContainer) {
+                    if (!param.isNullable || param.isMapContainer || param.isListContainer ||
+                            param.isFreeFormObject || param.isAnyType) {
                         continue;
                     }
                     if (param.isDateTime) {

modules/openapi-generator/src/main/java/org/openapitools/codegen/utils/ModelUtils.java

@@ -636,7 +636,7 @@ public static boolean isEmailSchema(Schema schema) {
     }
 
     /**
-     * Check to see if the schema is a model with at least one properties
+     * Check to see if the schema is a model with at least one property.
      *
      * @param schema potentially containing a '$ref'
      * @return true if it's a model with at least one properties
@@ -658,13 +658,68 @@ public static boolean isModel(Schema schema) {
     }
 
     /**
-     * Check to see if the schema is a free form object.
+     * Return true if the schema value can be any type, i.e. it can be
+     * the null value, integer, number, string, object or array.
+     * One use case is when the "type" attribute in the OAS schema is unspecified.
+     * 
+     * Examples:
+     *
+     *     arbitraryTypeValue:
+     *       description: This is an arbitrary type schema.
+     *         It is not a free-form object.
+     *         The value can be any type except the 'null' value.
+     *     arbitraryTypeNullableValue:
+     *       description: This is an arbitrary type schema.
+     *         It is not a free-form object.
+     *         The value can be any type, including the 'null' value.
+     *       nullable: true
+     *
+     * @param schema the OAS schema.
+     * @return true if the schema value can be an arbitrary type. 
+     */
+    public static boolean isAnyTypeSchema(Schema schema) {
+        if (schema == null) {
+            once(LOGGER).error("Schema cannot be null in isAnyTypeSchema check");
+            return false;
+        }
+        if (schema.getClass().equals(Schema.class) && schema.get$ref() == null && schema.getType() == null &&
+                (schema.getProperties() == null || schema.getProperties().isEmpty()) &&
+                schema.getAdditionalProperties() == null && schema.getNot() == null &&
+                schema.getEnum() == null) {
+            return true;
+            // If and when type arrays are supported in a future OAS specification,
+            // we could return true if the type array includes all possible JSON schema types.
+        }
+        return false;
+    }
+
+    /**
+     * Check to see if the schema is a free-form object.
      * 
      * A free form object is an object (i.e. 'type: object' in a OAS document) that:
      * 1) Does not define properties, and
      * 2) Is not a composed schema (no anyOf, oneOf, allOf), and
      * 3) additionalproperties is not defined, or additionalproperties: true, or additionalproperties: {}.
      *
+     * Examples:
+     * 
+     * components:
+     *   schemas:
+     *     arbitraryObject:
+     *       type: object
+     *       description: This is a free-form object.
+     *         The value must be a map of strings to values. The value cannot be 'null'.
+     *         It cannot be array, string, integer, number.
+     *     arbitraryNullableObject:
+     *       type: object
+     *       description: This is a free-form object.
+     *         The value must be a map of strings to values. The value can be 'null',
+     *         It cannot be array, string, integer, number.
+     *       nullable: true
+     *     arbitraryTypeValue:
+     *       description: This is NOT a free-form object.
+     *         The value can be any type except the 'null' value.
+     * 
      * @param schema potentially containing a '$ref'
      * @return true if it's a free-form object
      */

modules/openapi-generator/src/test/resources/3_0/petstore-with-fake-endpoints-models-for-testing-with-http-signature.yaml

@@ -1250,6 +1250,23 @@ components:
           type: integer
           format: int32
           description: User Status
+        arbitraryObject:
+          type: object
+          description: test code generation for objects
+            Value must be a map of strings to values. It cannot be the 'null' value.
+        arbitraryNullableObject:
+          type: object
+          description: test code generation for nullable objects.
+            Value must be a map of strings to values or the 'null' value.
+          nullable: true
+        arbitraryTypeValue:
+          description: test code generation for any type
+            Value can be any type - string, number, boolean, array or object.
+        arbitraryNullableTypeValue:
+          description: test code generation for any type
+            Value can be any type - string, number, boolean, array, object or
+            the 'null' value.
+          nullable: true
       xml:
         name: User
     Tag:

samples/openapi3/client/petstore/go-experimental/go-petstore/api/openapi.yaml

@@ -1299,9 +1299,13 @@ components:
         lastName: lastName
         password: password
         userStatus: 6
+        arbitraryTypeValue: ""
+        arbitraryNullableTypeValue: ""
         phone: phone
         id: 0
+        arbitraryObject: '{}'
         email: email
+        arbitraryNullableObject: '{}'
         username: username
       properties:
         id:
@@ -1324,6 +1328,22 @@ components:
           description: User Status
           format: int32
           type: integer
+        arbitraryObject:
+          description: test code generation for objects Value must be a map of strings
+            to values. It cannot be the 'null' value.
+          type: object
+        arbitraryNullableObject:
+          description: test code generation for nullable objects. Value must be a
+            map of strings to values or the 'null' value.
+          nullable: true
+          type: object
+        arbitraryTypeValue:
+          description: test code generation for any type Value can be any type - string,
+            number, boolean, array or object.
+        arbitraryNullableTypeValue:
+          description: test code generation for any type Value can be any type - string,
+            number, boolean, array, object or the 'null' value.
+          nullable: true
       type: object
       xml:
         name: User

samples/openapi3/client/petstore/go-experimental/go-petstore/docs/NullableClass.md

@@ -10,12 +10,12 @@ Name | Type | Description | Notes
 **StringProp** | Pointer to **NullableString** |  | [optional] 
 **DateProp** | Pointer to **NullableString** |  | [optional] 
 **DatetimeProp** | Pointer to [**NullableTime**](time.Time.md) |  | [optional] 
-**ArrayNullableProp** | Pointer to [**[]map[string]interface{}**](map[string]interface{}.md) |  | [optional] 
-**ArrayAndItemsNullableProp** | Pointer to [**[]map[string]interface{}**](map[string]interface{}.md) |  | [optional] 
-**ArrayItemsNullable** | Pointer to [**[]map[string]interface{}**](map[string]interface{}.md) |  | [optional] 
-**ObjectNullableProp** | Pointer to [**map[string]map[string]interface{}**](map[string]interface{}.md) |  | [optional] 
-**ObjectAndItemsNullableProp** | Pointer to [**map[string]map[string]interface{}**](map[string]interface{}.md) |  | [optional] 
-**ObjectItemsNullable** | Pointer to [**map[string]map[string]interface{}**](map[string]interface{}.md) |  | [optional] 
+**ArrayNullableProp** | Pointer to **[]map[string]interface{}** |  | [optional] 
+**ArrayAndItemsNullableProp** | Pointer to **[]map[string]interface{}** |  | [optional] 
+**ArrayItemsNullable** | Pointer to **[]map[string]interface{}** |  | [optional] 
+**ObjectNullableProp** | Pointer to **map[string]map[string]interface{}** |  | [optional] 
+**ObjectAndItemsNullableProp** | Pointer to **map[string]map[string]interface{}** |  | [optional] 
+**ObjectItemsNullable** | Pointer to **map[string]map[string]interface{}** |  | [optional] 
 
 ## Methods