gogensig:panic when convert fail (#271)

* gogensig:panic when convert func fail

* gogensig:panic when type complete fail

* gogensig:panic when typedef fail

* gogensig:panic when enum item fail

* gogensig:remove unuse comment

Author: luoliwoshang

cmd/gogensig/convert/package.go

@@ -181,7 +181,7 @@ func (p *Package) newReceiver(typ *ast.FuncType) *types.Var {
 	recvField := typ.Params.List[0]
 	recvType, err := p.ToType(recvField.Type)
 	if err != nil {
-		log.Println(err)
+		log.Panicf("newReceiver:failed to convert type: %s", err.Error())
 	}
 	return p.p.NewParam(token.NoPos, "recv_", recvType)
 }
@@ -292,7 +292,7 @@ func (p *Package) NewFuncDecl(funcDecl *ast.FuncDecl) error {
 		log.Printf("NewFuncDecl: %v\n", funcDecl.Name)
 	}
 	if anony {
-		return errs.NewAnonymousFuncNotSupportError()
+		log.Panicln("NewFuncDecl: fail convert anonymous function") // Unreachable
 	}
 
 	fnSpec, err := p.LookupSymbol(funcDecl.MangledName)
@@ -312,7 +312,7 @@ func (p *Package) NewFuncDecl(funcDecl *ast.FuncDecl) error {
 
 	sig, err := p.ToSigSignature(recv, funcDecl)
 	if err != nil {
-		return err
+		log.Panicf("NewFuncDecl: fail convert signature : %s\n", err.Error())
 	}
 	return p.handleFuncDecl(fnSpec, sig, funcDecl)
 }
@@ -353,10 +353,7 @@ func (p *Package) NewTypeDecl(typeDecl *ast.TypeDecl) error {
 		log.Printf("NewTypeDecl: %v\n", typeDecl.Name)
 	}
 	if anony {
-		if dbg.GetDebugLog() {
-			log.Println("NewTypeDecl:Skip a anonymous type")
-		}
-		return nil
+		log.Panicln("NewFuncDecl: fail convert anonymous type") // Unreachable
 	}
 
 	cname := typeDecl.Name.Name
@@ -378,7 +375,7 @@ func (p *Package) NewTypeDecl(typeDecl *ast.TypeDecl) error {
 
 	if !isForward {
 		if err := p.handleCompleteType(incom, typeDecl.Type, cname); err != nil {
-			return err
+			log.Panicf("NewTypeDecl: fail to complete type : %s\n", err.Error())
 		}
 	}
 	return nil
@@ -410,7 +407,6 @@ func (p *Package) handleCompleteType(incom *Incomplete, typ *ast.RecordType, nam
 	structType, err := p.cvt.RecordTypeToStruct(typ)
 	if err != nil {
 		// For incomplete type's conerter error, we use default struct type
-		incom.decl.InitType(p.p, types.NewStruct(p.cvt.defaultRecordField(), nil))
 		return err
 	}
 	incom.decl.InitType(p.p, structType)
@@ -480,8 +476,7 @@ func (p *Package) NewTypedefDecl(typedefDecl *ast.TypedefDecl) error {
 
 	typ, err := p.ToType(typedefDecl.Type)
 	if err != nil {
-		typeSpecdecl.InitType(p.p, types.NewStruct(p.cvt.defaultRecordField(), nil))
-		return err
+		log.Panicf("NewTypedefDecl:fail to convert type : %s\n", err.Error())
 	}
 
 	typeSpecdecl.InitType(p.p, typ)
@@ -593,7 +588,7 @@ func (p *Package) createEnumItems(items []*ast.EnumItem, enumType types.Type) er
 		}
 		val, err := Expr(item.Value).ToInt()
 		if err != nil {
-			return err
+			log.Panicf("createEnumItems:fail to convert %T to int:%s", item.Value, err.Error())
 		}
 		defs.New(val, enumType, name)
 		if changed {

cmd/gogensig/convert/package_test.go

@@ -419,7 +419,7 @@ func Foo(__llgo_va_list ...interface{})`,
 					GoName:     "InvalidFunc",
 				},
 			},
-			expectedErr: "not found in type map",
+			expectedPanic: "NewFuncDecl: fail convert signature : not found in type map",
 		},
 		{
 			name: "explict void return",
@@ -747,7 +747,7 @@ func Foo(a *c.Uint, b *c.Double) **c.Char
 					GoName:     "Foo",
 				},
 			},
-			expectedErr: "error convert elem type",
+			expectedPanic: "NewFuncDecl: fail convert signature : error convert elem type: not found in type map",
 		},
 		{
 			name: "error return type",
@@ -766,7 +766,7 @@ func Foo(a *c.Uint, b *c.Double) **c.Char
 					GoName:     "Foo",
 				},
 			},
-			expectedErr: "error convert return type",
+			expectedPanic: "NewFuncDecl: fail convert signature : error convert return type: not found in type map",
 		},
 		{
 			name: "error nil param",
@@ -789,7 +789,53 @@ func Foo(a *c.Uint, b *c.Double) **c.Char
 					GoName:     "Foo",
 				},
 			},
-			expectedErr: "unexpected nil field",
+			expectedPanic: "NewFuncDecl: fail convert signature : error convert type: unexpected nil field",
+		},
+		{
+			name: "error receiver",
+			decl: &ast.FuncDecl{
+				DeclBase: ast.DeclBase{
+					Loc: &ast.Location{File: tempFile.File},
+				},
+				Name:        &ast.Ident{Name: "foo"},
+				MangledName: "foo",
+				Type: &ast.FuncType{
+					Params: &ast.FieldList{
+						List: []*ast.Field{
+							{
+								Type: &ast.BuiltinType{Kind: ast.Int, Flags: ast.Double},
+							},
+						},
+					},
+				},
+			},
+			symbs: []config.SymbolEntry{
+				{
+					CppName:    "foo",
+					MangleName: "foo",
+					GoName:     "(*Foo).foo",
+				},
+			},
+			expectedPanic: "newReceiver:failed to convert type",
+		},
+		{
+			name: "anony func",
+			decl: &ast.FuncDecl{
+				Name:        nil,
+				MangledName: "foo",
+				Type: &ast.FuncType{
+					Params: nil,
+					Ret:    &ast.BuiltinType{Kind: ast.Void},
+				},
+			},
+			symbs: []config.SymbolEntry{
+				{
+					CppName:    "foo",
+					MangleName: "foo",
+					GoName:     "Foo",
+				},
+			},
+			expectedPanic: "NewFuncDecl: fail convert anonymous function",
 		},
 	}
 	for _, tc := range testCases {
@@ -836,7 +882,7 @@ type Foo struct {
 					},
 				},
 			},
-			expectedErr: "not found in type map",
+			expectedPanic: "NewTypeDecl: fail to complete type : not found in type map",
 		},
 		// struct Foo { int a; double b; bool c; }
 		{
@@ -1051,10 +1097,8 @@ type Foo struct {
 					Fields: &ast.FieldList{},
 				},
 			},
-			expected: `
-package testpkg
-import _ "unsafe"
-			`},
+			expectedPanic: "NewFuncDecl: fail convert anonymous type",
+		},
 		{
 			name: "struct array field without len",
 			decl: &ast.TypeDecl{
@@ -1076,7 +1120,7 @@ import _ "unsafe"
 					},
 				},
 			},
-			expectedErr: "unsupport field with array without length",
+			expectedPanic: "NewTypeDecl: fail to complete type : unsupport field with array without length",
 		},
 		{
 			name: "struct array field without len",
@@ -1100,7 +1144,7 @@ import _ "unsafe"
 					},
 				},
 			},
-			expectedErr: "can't determine the array length",
+			expectedPanic: "NewTypeDecl: fail to complete type : can't determine the array length",
 		},
 	}
 
@@ -1303,7 +1347,7 @@ type DOUBLE c.Double`,
 					Flags: ast.Double,
 				},
 			},
-			expectedErr: "not found in type map",
+			expectedPanic: "NewTypedefDecl:fail to convert type : not found in type map",
 		},
 		// typedef int INT;
 		{
@@ -1400,7 +1444,7 @@ type Name *c.Char`,
 					},
 				},
 			},
-			expectedErr: "error convert baseType",
+			expectedPanic: "NewTypedefDecl:fail to convert type : error convert baseType: not found in type map",
 		},
 	}
 
@@ -1466,6 +1510,18 @@ const (
 	Blue  c.Int = 2
 )`,
 		},
+		{
+			name: "invalid enum item",
+			decl: &ast.EnumTypeDecl{
+				Name: nil,
+				Type: &ast.EnumType{
+					Items: []*ast.EnumItem{
+						{Name: &ast.Ident{Name: "red"}, Value: &ast.ArrayType{Elt: &ast.BuiltinType{Kind: ast.Bool}}},
+					},
+				},
+			},
+			expectedPanic: "createEnumItems:fail to convert *ast.ArrayType to int",
+		},
 	}
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
@@ -1662,16 +1718,28 @@ type Foo struct {
 }
 
 type genDeclTestCase struct {
-	name        string
-	decl        ast.Decl
-	symbs       []config.SymbolEntry
-	cppgconf    *llcppg.Config
-	expected    string
-	expectedErr string
+	name          string
+	decl          ast.Decl
+	symbs         []config.SymbolEntry
+	cppgconf      *llcppg.Config
+	expected      string
+	expectedErr   string
+	expectedPanic string
 }
 
 func testGenDecl(t *testing.T, tc genDeclTestCase) {
 	t.Helper()
+	defer func() {
+		if r := recover(); r != nil {
+			if tc.expectedPanic != "" {
+				if !strings.HasPrefix(r.(string), tc.expectedPanic) {
+					t.Errorf("Expected panic %s, but got: %v", tc.expectedPanic, r)
+				}
+			} else {
+				t.Fatal("unexpect panic", r)
+			}
+		}
+	}()
 	pkg := createTestPkg(t, &convert.PackageConfig{
 		SymbolTable: config.CreateSymbolTable(tc.symbs),
 		PkgBase: convert.PkgBase{