111

Author: lvan100

gen/generator/golang/type.go

@@ -323,12 +323,6 @@ type Type struct {
 	Comment string
 }
 
-// Binding represents a field binding from headers, path, or query
-type Binding struct {
-	From string // Source: header/path/query
-	Name string // Field name in the source
-}
-
 // TypeField represents a field in a Go struct
 type TypeField struct {
 	Type     string
@@ -340,6 +334,12 @@ type TypeField struct {
 	Comment  string
 }
 
+// Binding represents a field binding from headers, path, or query
+type Binding struct {
+	From string // Source: header/path/query
+	Name string // Field name in the source
+}
+
 // BindingCount returns the number of fields in the struct that have binding info
 func (t *Type) BindingCount() int {
 	var count int
@@ -363,7 +363,7 @@ func (t *Type) ValidateCount() int {
 }
 
 // convertTypes converts IDL struct types to Go struct types
-func convertTypes(ctx Context, doc tidl.Document) (_ []Type, err error) {
+func convertTypes(ctx Context, doc tidl.Document) ([]Type, error) {
 	var ret []Type
 
 	// Handle type keyword defined structs
@@ -372,16 +372,19 @@ func convertTypes(ctx Context, doc tidl.Document) (_ []Type, err error) {
 		if t.GenericName != nil {
 			continue
 		}
-		var r Type
+		var (
+			typ Type
+			err error
+		)
 		if t.Redefined != nil {
-			r, err = convertRedefinedType(ctx, t)
+			typ, err = convertRedefinedType(ctx, t)
 		} else {
-			r, err = convertType(ctx, t)
+			typ, err = convertType(ctx, t)
 		}
 		if err != nil {
 			return nil, err
 		}
-		ret = append(ret, r)
+		ret = append(ret, typ)
 	}
 
 	return ret, nil
@@ -396,7 +399,7 @@ func convertRedefinedType(ctx Context, r tidl.Type) (Type, error) {
 
 	var fields []tidl.TypeField
 	for _, f := range t.Fields {
-		f.FieldType = resolveGenericType(f.FieldType, *t.GenericName, r.Redefined)
+		f.FieldType = replaceGenericType(f.FieldType, *t.GenericName, r.Redefined.GenericType)
 		fields = append(fields, f)
 	}
 
@@ -408,19 +411,19 @@ func convertRedefinedType(ctx Context, r tidl.Type) (Type, error) {
 	})
 }
 
-// resolveGenericType replaces a generic type in a field with a concrete type
-func resolveGenericType(t tidl.TypeDefinition, genericName string, r *tidl.RedefinedType) tidl.TypeDefinition {
+// replaceGenericType replaces a generic type in a field with a concrete type
+func replaceGenericType(t tidl.TypeDefinition, genericName string, genericType tidl.TypeDefinition) tidl.TypeDefinition {
 	switch u := t.(type) {
 	case tidl.UserType:
 		if u.Name == genericName {
-			return r.GenericType
+			return genericType
 		}
 		return u
 	case tidl.ListType:
-		u.Item = resolveGenericType(u.Item, genericName, r)
+		u.Item = replaceGenericType(u.Item, genericName, genericType)
 		return u
 	case tidl.MapType:
-		u.Value = resolveGenericType(u.Value, genericName, r)
+		u.Value = replaceGenericType(u.Value, genericName, genericType)
 		return u
 	default:
 		return t
@@ -433,6 +436,7 @@ func convertType(ctx Context, t tidl.Type) (Type, error) {
 		Name: t.Name,
 	}
 
+	// Handle oneof
 	if t.OneOf {
 		r.Fields = append(r.Fields, TypeField{
 			Type:     r.Name + "TypeAsString",
@@ -442,25 +446,27 @@ func convertType(ctx Context, t tidl.Type) (Type, error) {
 		})
 	}
 
+	// Handle fields
 	for _, f := range t.Fields {
 
 		// Handle embedded types (flatten their fields into the struct)
-		if ft, ok := f.FieldType.(tidl.EmbedType); ok {
-			et, ok := tidl.GetType(ctx.files, ft.Name)
+		if embedType, ok := f.FieldType.(tidl.EmbedType); ok {
+			srcType, ok := tidl.GetType(ctx.files, embedType.Name)
 			if !ok {
-				return Type{}, fmt.Errorf("embedded type %s not found for field in struct %s", ft.Name, r.Name)
+				return Type{}, fmt.Errorf("embedded type %s not found for field in struct %s", embedType.Name, r.Name)
 			}
-			rt, err := convertType(ctx, et)
+			retType, err := convertType(ctx, srcType)
 			if err != nil {
-				return Type{}, fmt.Errorf("failed to convert embedded type %s in struct %s: %w", ft.Name, r.Name, err)
+				return Type{}, fmt.Errorf("failed to convert embedded type %s in struct %s: %w", embedType.Name, r.Name, err)
 			}
 			// Append embedded type's fields
-			r.Fields = append(r.Fields, rt.Fields...)
+			r.Fields = append(r.Fields, retType.Fields...)
 			continue
 		}
 
-		// Get field name and Go type
 		fieldName := tidl.ToPascal(f.Name)
+
+		// Get field name and Go type
 		typeName, err := getTypeName(ctx, f.FieldType, f.Annotations)
 		if err != nil {
 			return Type{}, err
@@ -509,17 +515,23 @@ func convertType(ctx Context, t tidl.Type) (Type, error) {
 func getTypeName(ctx Context, t tidl.TypeDefinition, arr []tidl.Annotation) (string, error) {
 
 	// Handle go.type annotation
-	if a, ok := tidl.GetAnnotation(arr, "go.type"); ok && a.Value != nil {
+	if a, ok := tidl.GetAnnotation(arr, "go.type"); ok {
+		if a.Value == nil {
+			return "", fmt.Errorf("go.type annotation must have a value")
+		}
 		s := strings.Trim(strings.TrimSpace(*a.Value), "\"")
+		if s == "" {
+			return "", fmt.Errorf("go.type annotation must not empty")
+		}
 		return s, nil
 	}
 
-	switch ft := t.(type) {
+	switch typ := t.(type) {
 	case tidl.AnyType:
 		return "", fmt.Errorf("any type must have go.type annotation")
 	case tidl.BaseType:
 		var typeName string
-		switch ft.Name {
+		switch typ.Name {
 		case "string":
 			typeName = "string"
 		case "int":
@@ -529,56 +541,51 @@ func getTypeName(ctx Context, t tidl.TypeDefinition, arr []tidl.Annotation) (str
 		case "bool":
 			typeName = "bool"
 		default:
-			return "", fmt.Errorf("unknown base type: %s", ft.Name)
+			return "", fmt.Errorf("unknown base type: %s", typ.Name)
 		}
-		if ft.Optional {
+		if typ.Optional {
 			typeName = "*" + typeName
 		}
 		return typeName, nil
 	case tidl.UserType:
-		typeName := ft.Name
-		if ft.Optional {
-			typeName = "*" + typeName
-		}
-
+		typeName := typ.Name
 		// Handle enum_as_string annotation
 		if _, ok := tidl.GetAnnotation(arr, "enum_as_string"); ok {
-			if _, ok := tidl.GetEnum(ctx.files, ft.Name); !ok {
-				return "", fmt.Errorf("enum %s not found", ft.Name)
+			if _, ok := tidl.GetEnum(ctx.files, typ.Name); !ok {
+				return "", fmt.Errorf("enum %s not found", typ.Name)
 			}
 			typeName += "AsString"
 		}
+		if typ.Optional {
+			typeName = "*" + typeName
+		}
 		return typeName, nil
 	case tidl.ListType:
-		itemType, err := getTypeName(ctx, ft.Item, nil)
+		itemType, err := getTypeName(ctx, typ.Item, nil)
 		if err != nil {
 			return "", err
 		}
 		return "[]" + itemType, nil
 	case tidl.MapType:
 		keyType := "string"
-		if ft.Key == "int" {
+		if typ.Key == "int" {
 			keyType = "int64"
 		}
-		valueType, err := getTypeName(ctx, ft.Value, nil)
+		valueType, err := getTypeName(ctx, typ.Value, nil)
 		if err != nil {
 			return "", err
 		}
 		return fmt.Sprintf("map[%s]%s", keyType, valueType), nil
 	case tidl.BinaryType:
-		// todo (lvan100) handle file
-		return "[]byte", nil
+		return "[]byte", nil // todo (lvan100) handle file
 	default:
 		return "", fmt.Errorf("unknown type: %s", t.Text())
 	}
 }
 
 // getTypeKind returns the category of a Go type (base, optional base, enum, struct, etc.)
 func getTypeKind(ctx Context, typeName string) (TypeKind, error) {
-	optional := strings.HasPrefix(typeName, "*")
-	if optional {
-		typeName = strings.TrimPrefix(typeName, "*")
-	}
+	typeName, optional := strings.CutPrefix(typeName, "*")
 
 	switch typeName {
 	case "int", "int8", "int16", "int32", "int64",
@@ -630,7 +637,10 @@ func parseBinding(arr []tidl.Annotation) (*Binding, error) {
 		return nil, fmt.Errorf("annotation %s value is nil", a.Key)
 	}
 	val := strings.Trim(*a.Value, "\"")
-	return &Binding{From: a.Key, Name: val}, nil
+	return &Binding{
+		From: a.Key,
+		Name: val,
+	}, nil
 }
 
 // genFieldTag generates the struct tag for a field.
@@ -705,7 +715,6 @@ var builtinFuncs = map[string]struct{}{
 // genValidate generates validation code for a field based on annotations.
 // It returns a Go code snippet for validating the field.
 func genValidate(receiverType, fieldName, fieldType string, arr []tidl.Annotation, funcs map[string]ValidateFunc) (*string, error) {
-	optional := strings.HasPrefix(fieldType, "*")
 	a, ok := tidl.GetAnnotation(arr, "validate")
 	if !ok {
 		return nil, nil
@@ -729,6 +738,7 @@ func genValidate(receiverType, fieldName, fieldType string, arr []tidl.Annotatio
 		return nil, err
 	}
 
+	optional := strings.HasPrefix(fieldType, "*")
 	dollar := "x." + fieldName
 	if optional {
 		dollar = "*" + dollar