fix: support anonymous nested structure slice parsing

parser.go

@@ -886,7 +886,38 @@ func (parser *Parser) parseStruct(pkgName string, field *ast.Field) (map[string]
 					},
 				},
 			}
-		} else { // standard type in array
+		} else if structField.arrayType == "object" {
+			// Anonymous struct
+			if astTypeArray, ok := field.Type.(*ast.ArrayType); ok { // if array
+				props := make(map[string]spec.Schema)
+				if expr, ok := astTypeArray.Elt.(*ast.StructType); ok {
+					for _, field := range expr.Fields.List {
+						var fieldProps map[string]spec.Schema
+						fieldProps, err = parser.parseStruct(pkgName, field)
+						if err != nil {
+							return properties, err
+						}
+						for k, v := range fieldProps {
+							props[k] = v
+						}
+					}
+					properties[structField.name] = spec.Schema{
+						SchemaProps: spec.SchemaProps{
+							Type:        []string{structField.schemaType},
+							Description: desc,
+							Items: &spec.SchemaOrArray{
+								Schema: &spec.Schema{
+									SchemaProps: spec.SchemaProps{
+										Type:       []string{"object"},
+										Properties: props,
+									},
+								},
+							},
+						}}
+				}
+			}
+		} else {
+			// standard type in array
 			required := make([]string, 0)
 			if structField.isRequired {
 				required = append(required, structField.name)

parser_test.go

@@ -2250,6 +2250,65 @@ func TestParseComposition(t *testing.T) {
 	assert.Equal(t, string(expected), string(b))
 }
 
+func TestParser_ParseStuctArrayObject(t *testing.T) {
+	src := `
+package api
+
+type Response struct {
+	Code int
+	Data []struct{
+		Field1 uint 
+		Field2 string 
+	} 
+}
+
+// @Success 200 {object} Response
+// @Router /api/{id} [get]
+func Test(){
+}
+`
+	expected := `{
+   "api.Response": {
+      "type": "object",
+      "properties": {
+         "code": {
+            "type": "integer"
+         },
+         "data": {
+            "type": "array",
+            "items": {
+               "type": "object",
+               "properties": {
+                  "field1": {
+                     "type": "integer"
+                  },
+                  "field2": {
+                     "type": "string"
+                  }
+               }
+            }
+         }
+      }
+   }
+}`
+	f, err := goparser.ParseFile(token.NewFileSet(), "", src, goparser.ParseComments)
+	assert.NoError(t, err)
+
+	p := New()
+	p.ParseType(f)
+	err = p.ParseRouterAPIInfo("", f)
+	assert.NoError(t, err)
+
+	typeSpec := p.TypeDefinitions["api"]["Response"]
+	err = p.ParseDefinition("api", typeSpec.Name.Name, typeSpec)
+	assert.NoError(t, err)
+
+	out, err := json.MarshalIndent(p.swagger.Definitions, "", "   ")
+	assert.NoError(t, err)
+	assert.Equal(t, expected, string(out))
+
+}
+
 func TestParser_ParseRouterApiInfoErr(t *testing.T) {
 	src := `
 package test

property.go

@@ -91,6 +91,9 @@ func getPropertyName(expr ast.Expr, parser *Parser) (propertyName, error) {
 	}
 
 	if astTypeArray, ok := expr.(*ast.ArrayType); ok { // if array
+		if _, ok := astTypeArray.Elt.(*ast.StructType); ok {
+			return propertyName{SchemaType: "array", ArrayType: "object"}, nil
+		}
 		return getArrayPropertyName(astTypeArray, parser), nil
 	}
 
@@ -105,7 +108,6 @@ func getPropertyName(expr ast.Expr, parser *Parser) (propertyName, error) {
 	if _, ok := expr.(*ast.InterfaceType); ok { // if interface{}
 		return propertyName{SchemaType: "object", ArrayType: "object"}, nil
 	}
-
 	return propertyName{}, errors.New("not supported" + fmt.Sprint(expr))
 }
 

property_test.go

@@ -225,6 +225,23 @@ func TestGetPropertyNameArrayStarExprSelector(t *testing.T) {
 	assert.Equal(t, expected, propertyName)
 }
 
+func TestGetPropertyNameArrayStructType(t *testing.T) {
+	input := &ast.ArrayType{
+		Lbrack: 1111,
+		Len:    nil,
+		Elt:    &ast.StructType{},
+	}
+	expected := propertyName{
+		"array",
+		"object",
+		"",
+	}
+
+	propertyName, err := getPropertyName(input, New())
+	assert.NoError(t, err)
+	assert.Equal(t, expected, propertyName)
+}
+
 func TestGetPropertyNameMap(t *testing.T) {
 	input := &ast.MapType{
 		Key: &ast.Ident{