feat: support nested enum (#528)

* fix: detect unname record

* test: do tests in non Cpp mode

* test: remove function symbols test in non Cpp mode

* chore: update comments

* revert test

* chore: add comments

* feat: handle nested struct in enum

* feat: support nested enum

* test: revert struct test in parser

* test: disable gen for convert test

* fix: four enum cases

* fix: use builtin type directly for anonymous enum

* chore: add FIXME

* chore: remove newline

* fix: merge error

* revert temp.h

* test: update testdata

* test: fix parser test

* fix: check hasParent for non-cpp mode

* chore: add disscussion commets

* test: revert unexpected change

* test: fix fallback

* test: fix cpp mode test

* fix: remove unused logic

* Update _xtool/internal/parser/parser.go

Co-authored-by: 张之阳 <51194195+luoliwoshang@users.noreply.github.com>

---------

Co-authored-by: 张之阳 <51194195+luoliwoshang@users.noreply.github.com>

Author: MeteorsLiu

_xtool/internal/clang/clang.go

@@ -101,6 +101,25 @@ func BuildScopingParts(cursor clang.Cursor) []string {
 	return parts
 }
 
+func HasParent(cursor clang.Cursor) bool {
+	semanticParentsNum := 0
+	node := cursor
+	for node.IsNull() != 1 && node.Kind != clang.CursorTranslationUnit {
+		semanticParentsNum++
+		node = node.SemanticParent()
+	}
+	if semanticParentsNum > 1 {
+		return true
+	}
+	node = cursor
+	lexicalParentsNum := 0
+	for node.IsNull() != 1 && node.Kind != clang.CursorTranslationUnit {
+		lexicalParentsNum++
+		node = node.LexicalParent()
+	}
+	return lexicalParentsNum > 1
+}
+
 func VisitChildren(cursor clang.Cursor, fn Visitor) c.Uint {
 	return clang.VisitChildren(cursor, func(cursor, parent clang.Cursor, clientData unsafe.Pointer) clang.ChildVisitResult {
 		cfn := *(*Visitor)(clientData)

_xtool/internal/parser/parser.go

@@ -646,7 +646,7 @@ func (ct *Converter) ProcessEnumDecl(cursor clang.Cursor) *ast.EnumTypeDecl {
 		decl.Name = &ast.Ident{Name: cursorName}
 		ct.logln("ProcessEnumDecl: has name", cursorName)
 	} else {
-		ct.logln("ProcessRecordDecl: is anonymous")
+		ct.logln("ProcessEnumDecl: is anonymous")
 	}
 
 	return decl
@@ -679,6 +679,7 @@ func (ct *Converter) createBaseField(cursor clang.Cursor) *ast.Field {
 	fieldName := toStr(cursor.String())
 
 	typ := cursor.Type()
+
 	typeName, typeKind := getTypeDesc(typ)
 
 	ct.logf("createBaseField: ProcessType %s TypeKind: %s", typeName, typeKind)
@@ -760,23 +761,41 @@ func (ct *Converter) ProcessRecordDecl(cursor clang.Cursor) []ast.Decl {
 	ct.logln("ProcessRecordDecl: CursorName:", cursorName, "CursorKind:", cursorKind)
 
 	childs := PostOrderVisitChildren(cursor, func(child, parent clang.Cursor) bool {
+		// if we found a nested enum, handle it like nested struct
+		if child.Kind == clang.CursorEnumDecl {
+			return true
+		}
 		return (child.Kind == clang.CursorStructDecl || child.Kind == clang.CursorUnionDecl) && child.IsAnonymous() == 0
 	})
 
 	for _, child := range childs {
-		// Check if this is a named nested struct/union
-		typ := ct.ProcessRecordType(child)
-		// note(zzy):use len(typ.Fields.List) to ensure it has fields not a forward declaration
-		// but maybe make the forward decl in to AST is also good.
-		if child.IsAnonymous() == 0 && typ.Fields != nil {
+		switch child.Kind {
+		case clang.CursorStructDecl, clang.CursorUnionDecl:
+			// note(zzy):use len(typ.Fields.List) to ensure it has fields not a forward declaration
+			// but maybe make the forward decl in to AST is also good.
 			childName := clang.GoString(child.String())
 			ct.logln("ProcessRecordDecl: Found named nested struct:", childName)
-			decls = append(decls, &ast.TypeDecl{
-				Object: ct.CreateObject(child, &ast.Ident{Name: childName}),
-				Type:   ct.ProcessRecordType(child),
-			})
+			// Check if this is a named nested struct/union
+			typ := ct.ProcessRecordType(child)
+			// note(zzy):use len(typ.Fields.List) to ensure it has fields not a forward declaration
+			// but maybe make the forward decl in to AST is also good.
+			if child.IsAnonymous() == 0 && typ.Fields != nil {
+				decls = append(decls, &ast.TypeDecl{
+					Object: ct.CreateObject(child, &ast.Ident{Name: childName}),
+					Type:   ct.ProcessRecordType(child),
+				})
+			}
+		case clang.CursorEnumDecl:
+			childName := clang.GoString(child.String())
+
+			ct.logln("ProcessRecordDecl: Found named nested enum:", childName)
+
+			ct.incIndent()
+			decls = append(decls, ct.ProcessEnumDecl(child))
+			ct.decIndent()
 		}
 	}
+	ct.logln("ProcessRecordDecl: process record: ", cursorName)
 
 	decl := &ast.TypeDecl{
 		Object: ct.CreateObject(cursor, nil),
@@ -864,28 +883,44 @@ func (ct *Converter) ProcessElaboratedType(t clang.Type) ast.Expr {
 	ct.logln("ProcessElaboratedType: TypeName:", typeName, "TypeKind:", typeKind)
 
 	decl := t.TypeDeclaration()
+	isAnonymousDecl := decl.IsAnonymous() > 0
 
-	if decl.IsAnonymous() != 0 {
-		// anonymous type refer (except anonymous RecordType&EnumType in TypedefDecl)
-		if decl.Kind == clang.CursorEnumDecl {
+	if isAnonymousDecl && decl.Kind != clang.CursorEnumDecl {
+		return ct.ProcessRecordType(decl)
+	}
+	parts := clangutils.BuildScopingParts(decl)
+	hasParent := clangutils.HasParent(decl)
+	// NOTE(MeteorsLiu): nested enum behaves different from nested struct, for example, we can find its semantic parent
+	// however, it will cause we misidentified it as a class method expr, so take it out
+	if isAnonymousDecl && decl.Kind == clang.CursorEnumDecl {
+		// case 1: anonymous enum, but not nested (anonymous enum decl variable case)
+		if !hasParent {
+			// this is not a nested enum, handle it normally
 			return ct.ProcessEnumType(decl)
 		}
-		return ct.ProcessRecordType(decl)
+		// case 2: anonymous enum, nested (normal nested struct reference)
+		// by default, the type of an anonymous enum is int
+		// NOTE(MeteorsLiu): see disscussion https://github.com/goplus/llcppg/pull/530
+		return &ast.BuiltinType{Kind: ast.Int}
+
+		// case 3: named enum, nested, fallback to process as a ElaboratedType (nornaml nested struct)
+		// case 4: named enum, non-nested, fallback to process as a ElaboratedType normally. (typedef enum case)
 	}
 
 	// for elaborated type, it could have a tag description
 	// like struct A, union B, class C, enum D
-	parts := strings.SplitN(typeName, " ", 2)
-	if len(parts) == 2 {
-		if tagValue, ok := tagMap[parts[0]]; ok {
+	typeParts := strings.SplitN(typeName, " ", 2)
+
+	if len(typeParts) == 2 {
+		if tagValue, ok := tagMap[typeParts[0]]; ok {
 			return &ast.TagExpr{
 				Tag:  tagValue,
-				Name: ct.BuildScopingExpr(decl),
+				Name: buildScopingFromParts(parts),
 			}
 		}
 	}
 
-	return ct.BuildScopingExpr(decl)
+	return buildScopingFromParts(parts)
 }
 
 func (ct *Converter) ProcessTypeDefType(t clang.Type) ast.Expr {
@@ -1031,7 +1066,6 @@ func buildScopingFromParts(parts []string) ast.Expr {
 	if len(parts) == 0 {
 		return nil
 	}
-
 	var expr ast.Expr = &ast.Ident{Name: parts[0]}
 	for _, part := range parts[1:] {
 		expr = &ast.ScopingExpr{

_xtool/internal/parser/parser_test.go

@@ -20,7 +20,7 @@ import (
 )
 
 func TestParserCppMode(t *testing.T) {
-	cases := []string{"class", "comment", "enum", "func", "scope", "struct", "typedef", "union", "macro", "forwarddecl1", "forwarddecl2", "include", "typeof", "forward_vs_empty"}
+	cases := []string{"class", "comment", "enum", "func", "scope", "struct", "typedef", "union", "macro", "forwarddecl1", "forwarddecl2", "include", "typeof", "forward_vs_empty", "nestedenum_cpp"}
 	// https://github.com/goplus/llgo/issues/1114
 	// todo(zzy):use os.ReadDir
 	for _, folder := range cases {
@@ -31,7 +31,7 @@ func TestParserCppMode(t *testing.T) {
 }
 
 func TestParserCMode(t *testing.T) {
-	cases := []string{"enum", "struct", "union", "macro", "include", "typeof", "named_nested_struct", "forward_vs_empty"}
+	cases := []string{"enum", "struct", "union", "macro", "include", "typeof", "named_nested_struct", "forward_vs_empty", "nestedenum"}
 	for _, folder := range cases {
 		t.Run(folder, func(t *testing.T) {
 			testFrom(t, filepath.Join("testdata", folder), "temp.h", false, false)
@@ -250,6 +250,15 @@ func TestNonBuiltinTypes(t *testing.T) {
 				},
 			},
 		},
+		{
+			TypeCode: `struct Foo { enum Bar {} k; };
+						enum Bar`,
+			ExpectTypeStr: "enum Bar",
+			expr: &ast.TagExpr{
+				Tag:  ast.Enum,
+				Name: &ast.Ident{Name: "Bar"},
+			},
+		},
 		{
 			TypeCode:      `enum { x = 42 }`,
 			ExpectTypeStr: "enum (unnamed enum at temp.h:1:1)",