fix(goctl): recurse into inline struct in IsTagMember (#5671)

Co-authored-by: kevin <wanjunfeng@gmail.com>

tools/goctl/api/parser/inline_tag_test.go

@@ -0,0 +1,69 @@
+package parser
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/zeromicro/go-zero/tools/goctl/api/spec"
+)
+
+const inlineTagAPI = `
+syntax = "v1"
+
+type (
+	Auth {
+		Token string ` + "`header:\"Authorization\"`" + `
+	}
+	Middle {
+		Auth
+	}
+	PointerRequest {
+		*Auth
+	}
+	NestedRequest {
+		Middle
+	}
+	RecursiveRequest {
+		Token string ` + "`header:\"X-Token\"`" + `
+		*RecursiveRequest
+	}
+)
+
+service test-api {
+	@handler Pointer
+	get /pointer (PointerRequest)
+
+	@handler Nested
+	get /nested (NestedRequest)
+
+	@handler Recursive
+	get /recursive (RecursiveRequest)
+}
+`
+
+func TestParseContentResolvesInlineTypesForTagLookup(t *testing.T) {
+	apiSpec, err := ParseContent(inlineTagAPI)
+	require.NoError(t, err)
+
+	for _, name := range []string{"PointerRequest", "NestedRequest", "RecursiveRequest"} {
+		t.Run(name, func(t *testing.T) {
+			tp := findStructByName(t, apiSpec.Types, name)
+			require.NotEmpty(t, tp.GetTagMembers("header"))
+			require.Empty(t, tp.GetTagMembers("path"))
+		})
+	}
+}
+
+func findStructByName(t *testing.T, types []spec.Type, name string) spec.DefineStruct {
+	t.Helper()
+	for _, tp := range types {
+		if tp.Name() == name {
+			defined, ok := tp.(spec.DefineStruct)
+			require.True(t, ok)
+			return defined
+		}
+	}
+
+	t.Fatalf("type %s not found", name)
+	return spec.DefineStruct{}
+}

tools/goctl/api/parser/parser.go

@@ -145,6 +145,17 @@ func (p parser) fillTypes() error {
 		case spec.DefineStruct:
 			var members []spec.Member
 			for _, member := range v.Members {
+				if member.IsInline {
+					tp, err := p.resolveInlineType(member.Type, map[string]bool{v.RawName: true})
+					if err != nil {
+						return err
+					}
+
+					member.Type = tp
+					members = append(members, member)
+					continue
+				}
+
 				switch v := member.Type.(type) {
 				case spec.DefineStruct:
 					tp, err := p.findDefinedType(v.RawName)
@@ -167,6 +178,62 @@ func (p parser) fillTypes() error {
 	return nil
 }
 
+func (p parser) resolveInlineType(tp spec.Type, resolving map[string]bool) (spec.Type, error) {
+	switch v := tp.(type) {
+	case spec.DefineStruct:
+		if resolving[v.RawName] {
+			return v, nil
+		}
+
+		tp, err := p.findDefinedType(v.RawName)
+		if err != nil {
+			return nil, err
+		}
+
+		defined, ok := (*tp).(spec.DefineStruct)
+		if !ok {
+			return nil, fmt.Errorf("type %s is not a struct", v.RawName)
+		}
+
+		resolving[v.RawName] = true
+		defer delete(resolving, v.RawName)
+		for i := range defined.Members {
+			if !defined.Members[i].IsInline {
+				continue
+			}
+
+			resolved, err := p.resolveInlineType(defined.Members[i].Type, resolving)
+			if err != nil {
+				return nil, err
+			}
+			defined.Members[i].Type = resolved
+		}
+		return defined, nil
+	case spec.NestedStruct:
+		for i := range v.Members {
+			if !v.Members[i].IsInline {
+				continue
+			}
+
+			resolved, err := p.resolveInlineType(v.Members[i].Type, resolving)
+			if err != nil {
+				return nil, err
+			}
+			v.Members[i].Type = resolved
+		}
+		return v, nil
+	case spec.PointerType:
+		resolved, err := p.resolveInlineType(v.Type, resolving)
+		if err != nil {
+			return nil, err
+		}
+		v.Type = resolved
+		return v, nil
+	default:
+		return tp, nil
+	}
+}
+
 func (p parser) findDefinedType(name string) (*spec.Type, error) {
 	for _, item := range p.spec.Types {
 		if _, ok := item.(spec.DefineStruct); ok {