Function analyzeField

go/fory/codegen/utils.go:469–528

analyzeField analyzes a struct field and creates FieldInfo

(field *types.Var, structTag string, index int)

// analyzeField analyzes a struct field and creates FieldInfo
func analyzeField(field *types.Var, structTag string, index int) (*FieldInfo, error) {
	fieldType := field.Type()
	goName := field.Name()
	snakeName := toSnakeCase(goName)

	// Check if field type is supported
	if !isSupportedFieldType(fieldType) {
		return nil, nil // Skip unsupported types
	}

	optionalElem, isOptional := getOptionalElementType(fieldType)
	if isOptional && optionalElem != nil {
		if ptr, ok := optionalElem.(*types.Pointer); ok {
			switch ptr.Elem().Underlying().(type) {
			case *types.Slice, *types.Map:
				return nil, fmt.Errorf("field %s: optional.Optional is not allowed for slice/map", goName)
			}
		} else {
			switch optionalElem.Underlying().(type) {
			case *types.Struct, *types.Slice, *types.Map:
				return nil, fmt.Errorf("field %s: optional.Optional is not allowed for struct/slice/map", goName)
			}
		}
	}

	// Analyze type information
	isPrimitive := isPrimitiveType(fieldType)
	isPointer := false
	typeID := getTypeID(fieldType)
	primitiveSize := getPrimitiveSize(fieldType)
	tagID, hasTagID, err := parseGeneratedFieldTagID(structTag)
	if err != nil {
		return nil, err
	}

	// Handle pointer types
	if ptr, ok := fieldType.(*types.Pointer); ok {
		isPointer = true
		fieldType = ptr.Elem()
		isPrimitive = isPrimitiveType(fieldType)
		typeID = getTypeID(fieldType)
		primitiveSize = getPrimitiveSize(fieldType)
	}

	return &FieldInfo{
		GoName:        goName,
		SnakeName:     snakeName,
		Type:          field.Type(),
		Index:         index,
		IsPrimitive:   isPrimitive,
		IsPointer:     isPointer,
		IsOptional:    isOptional,
		Nullable:      isPointer || isOptional, // Pointer and optional types are nullable in xlang mode
		TypeID:        typeID,
		TagID:         tagID,
		HasTagID:      hasTagID,
		PrimitiveSize: primitiveSize,
		OptionalElem:  optionalElem,