Move golang changes to a separate branch

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

@@ -92,8 +92,8 @@ public AbstractGoCodegen() {
                         "complex128",
                         "rune",
                         "byte",
-                        "ObjectType",
-                        "AnyType"
+                        "map[string]interface{}",
+                        "interface{}"
                         )
         );
 
@@ -128,15 +128,9 @@ public AbstractGoCodegen() {
         // map[string]interface{}, whereas an arbitrary type is implemented
         // in golang as interface{}.
         // See issue #5387 for more details.
-        typeMapping.put("object", "ObjectType");
-        // A schema that does not specify the 'type' attribute. The value
-        // can be anything.
-        typeMapping.put("AnyType", "AnyType");
-        // Below is the entry to map the JSON 'null' type to golang.
-        // Note there is no built-in 'null' type in golang, and it's not possible
-        // to declare a variable whose only possible value is 'nil'.
-        // For example `a := nil` is not a valid go statement.
-        typeMapping.put("null", "NullType");
+        typeMapping.put("object", "map[string]interface{}");
+        typeMapping.put("interface{}", "interface{}");
+        typeMapping.put("AnyType", "interface{}");
 
         numberTypes = new HashSet<String>(
                 Arrays.asList(
@@ -397,7 +391,7 @@ public String getSchemaType(Schema p) {
             type = openAPIType;
         } else if ("object".equals(openAPIType) && ModelUtils.isAnyTypeSchema(p)) {
             // Arbitrary type. Note this is not the same thing as free-form object.
-            type = "AnyType";
+            type = "interface{}";
         } else if (typeMapping.containsKey(openAPIType)) {
             type = typeMapping.get(openAPIType);
             if (languageSpecificPrimitives.contains(type))
@@ -604,58 +598,14 @@ private void setExportParameterName(List<CodegenParameter> codegenParameters) {
         }
     }
 
-    /**
-     * OAS type mapping to golang implementation:
-     * 
-     * AnyType                  interface{}                        Any type, e.g. null, string, integer, number, boolean, map, array.
-     * ObjectType               map[string]interface{}             Free-form object with no constraint on additional properties.
-     * map[string]Animal        map[string]Animal                  Free-form object. The value of undeclared properties must be 'Animal'.
-     * map[string]ObjectType    map[string]map[string]interface{}  Free-form object. The value of undeclared properties must be an object (map).
-     *                          map[string][]interface{}           Free-form object. The value of undeclared properties must be an array.
-     * 
-     */
     @Override
     public void postProcessModelProperty(CodegenModel model, CodegenProperty property) {
-        // The 'go-experimental/model.mustache' template generates accessor methods.
-        // For containers (e.g. Array, Map) and non-nullable primitive types, the go struct field
-        // is the underlying type, e.g. *int32, *string, *bool...
-        // In other cases (nullable primitive types, free-form objects...), the generated code has
-        // a wrapper type and a Get() function to access the underlying type.
-        boolean hasWrapper = false;
-        if (property.isAnyType) {
-            // The wrapper type is the 'AnyType' struct and the wrapped type is 'interface{}'.
-            hasWrapper = true;
-        } else if (property.isFreeFormObject && !property.isNullable) { // && 
-            // Undeclared properties use case.
-            // The undeclared properties are implemented using a go map.
-            // The map key is always a string.
-            // The map value is interface{} when there are no constraints, but the
-            // 'additionalProperties' attribute may require a specific type.
-            if (property.items == null) {
-                // The 'additionalProperties' attribute is not set, so it is a free-form object
-                // with no constraint on the type of undeclared properties.
-                // The wrapper type is 'ObjectType'.
-                // The wrapped type is 'map[string]interface{}'.
-                hasWrapper = true;
-            } else if (property.items.isFreeFormObject && !property.items.isNullable) {
-                // The 'additionalProperties' attribute is set, and the value of the undeclared
-                // properties must be a free-form object. Hence it's a map of map.
-                // The wrapper type is map[string]ObjectType.
-                // The wrapped type is 'map[string]map[string]interface{}'.
-                hasWrapper = true;
-            } else {
-                // The 'additionalProperties' attribute is set, and the value of the undeclared
-                // properties is not free-form. For example, if the undeclared properties must
-                // be of type 'Animal', then:
-                // The wrapper type is map[string]Animal.
-                // The wrapped type is 'map[string]Animal'.
-            }
-        } else if (property.isNullable && !property.isContainer) {
-            // Primitive types.
-            hasWrapper = true;
-        }
-        if (hasWrapper) {
-            property.vendorExtensions.put("x-golang-has-wrapper", true);
+        // The 'go-experimental/model.mustache' template conditionally generates accessor methods.
+        // For primitive types and custom types (e.g. interface{}, map[string]interface{}...),
+        // the generated code has a wrapper type and a Get() function to access the underlying type.
+        // For containers (e.g. Array, Map), the generated code returns the type directly. 
+        if (property.isContainer || property.isFreeFormObject || property.isAnyType) {
+            property.vendorExtensions.put("x-golang-is-container", true);
         }
     }
 

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

@@ -177,37 +177,11 @@ public Map<String, Object> postProcessModels(Map<String, Object> objs) {
                 }
 
                 for (CodegenProperty param : model.vars) {
-                    // Two golang types are used in the generated code: the type of the
-                    // struct fields and the types of the getter and setter methods.
-                    // The struct fields may use a wrapper type (such as 'NullableBool'),
-                    // whereas the getter method returns the unwrapped type (e.g. 'bool').
-                    // param.dataType is the golang type of the generated struct field.
-                    // "x-go-base-type" is the type in the setter and getter functions.
                     param.vendorExtensions.put("x-go-base-type", param.dataType);
-                    if (!param.vendorExtensions.containsKey("x-golang-has-wrapper")) {
+                    if (!param.isNullable || param.isMapContainer || param.isListContainer ||
+                            param.isFreeFormObject || param.isAnyType) {
                         continue;
                     }
-                    if (param.isAnyType) {
-                        param.vendorExtensions.put("x-go-base-type", "interface{}");
-                        continue;
-                    } else if (param.isFreeFormObject) {
-                        switch (param.dataType) {
-                        case "ObjectType":
-                            param.vendorExtensions.put("x-go-base-type", "map[string]interface{}");
-                            continue;
-                        case "[]ObjectType":
-                            param.vendorExtensions.put("x-go-base-type", "map[string][]interface{}");
-                            continue;
-                        case "map[string]ObjectType":
-                            param.vendorExtensions.put("x-go-base-type", "map[string]map[string]interface{}");
-                            continue;
-                        }
-                    }
-                    /*
-                    if (!param.isNullable || param.isMapContainer || param.isListContainer) {
-                        continue;
-                    }
-                    */
                     if (param.isDateTime) {
                         // Note this could have been done by adding the following line in processOpts(),
                         // however, we only want to represent the DateTime object as NullableTime if