goscript 0.0.83 → 0.1.0

package/compiler/expr-call-type-conversion.go

@@ -1,520 +0,0 @@
-package compiler
-
-import (
-	"fmt"
-	"go/ast"
-	"go/token"
-	"go/types"
-)
-
-// writeNilConversion handles type conversions with nil argument
-func (c *GoToTSCompiler) writeNilConversion(exp *ast.CallExpr) (handled bool, err error) {
-	if len(exp.Args) != 1 {
-		return false, nil
-	}
-
-	nilIdent, isIdent := exp.Args[0].(*ast.Ident)
-	if !isIdent || nilIdent.Name != "nil" {
-		return false, nil
-	}
-
-	// Check if this is actually a type conversion, not a method/function call
-	// For type conversions, exp.Fun is a type expression (IsType() is true)
-	// For method calls like s.ptr.Swap(nil), exp.Fun is a selector expression (IsType() is false)
-	if tv, ok := c.pkg.TypesInfo.Types[exp.Fun]; !ok || !tv.IsType() {
-		// This is not a type conversion, let the normal call handling proceed
-		return false, nil
-	}
-
-	// Get the type being converted to
-	if typ := c.pkg.TypesInfo.TypeOf(exp.Fun); typ != nil {
-		// For pointer types, create a typed nil that preserves type information
-		if ptrType, ok := typ.(*types.Pointer); ok {
-			// Use a qualifier that returns the package name for local types
-			// This matches Go's reflect output format (e.g., "main.Stringer")
-			qualifier := func(pkg *types.Package) string {
-				if pkg == nil {
-					return ""
-				}
-				return pkg.Name()
-			}
-			typeName := types.TypeString(ptrType, qualifier)
-			c.tsw.WriteLiterallyf("$.typedNil(%q)", typeName)
-			return true, nil
-		}
-	}
-
-	// For non-pointer types (or if type info is unavailable), use plain null
-	c.tsw.WriteLiterally("null")
-	return true, nil
-}
-
-// writeArrayTypeConversion handles array type conversions like []rune(string)
-func (c *GoToTSCompiler) writeArrayTypeConversion(exp *ast.CallExpr) (handled bool, err error) {
-	arrayType, isArrayType := exp.Fun.(*ast.ArrayType)
-	if !isArrayType {
-		return false, nil
-	}
-
-	// Check if it's a []rune type
-	if ident, isIdent := arrayType.Elt.(*ast.Ident); isIdent && ident.Name == "rune" {
-		// Check if the argument is a string
-		if len(exp.Args) == 1 {
-			arg := exp.Args[0]
-			if tv, ok := c.pkg.TypesInfo.Types[arg]; ok && tv.Type != nil {
-				if c.isStringType(tv.Type) {
-					// Translate []rune(stringValue) to $.stringToRunes(stringValue)
-					c.tsw.WriteLiterally("$.stringToRunes(")
-					if err := c.WriteValueExpr(arg); err != nil {
-						return true, fmt.Errorf("failed to write argument for []rune(string) conversion: %w", err)
-					}
-					c.tsw.WriteLiterally(")")
-					return true, nil
-				}
-			}
-		}
-	}
-
-	// Check if it's a []byte type and the argument is a string
-	if eltIdent, ok := arrayType.Elt.(*ast.Ident); ok && eltIdent.Name == "byte" && arrayType.Len == nil {
-		if len(exp.Args) == 1 {
-			arg := exp.Args[0]
-			// Ensure TypesInfo is available and the argument type can be determined
-			if tv, typeOk := c.pkg.TypesInfo.Types[arg]; typeOk && tv.Type != nil {
-				if c.isStringType(tv.Type) {
-					c.tsw.WriteLiterally("$.stringToBytes(")
-					if err := c.WriteValueExpr(arg); err != nil {
-						return true, fmt.Errorf("failed to write argument for []byte(string) conversion: %w", err)
-					}
-					c.tsw.WriteLiterally(")")
-					return true, nil
-				}
-			}
-		}
-	}
-
-	// Handle general slice type conversions like []T(namedType) where namedType has underlying type []T
-	if arrayType.Len == nil && len(exp.Args) == 1 {
-		arg := exp.Args[0]
-		if argType := c.pkg.TypesInfo.TypeOf(arg); argType != nil {
-			// Check if the argument is a named type with a slice underlying type
-			if namedArgType, isNamed := argType.(*types.Named); isNamed {
-				// Check if the named type has receiver methods (is a wrapper type)
-				if c.isWrapperType(namedArgType) {
-					// Check if the underlying type matches the target slice type
-					if sliceUnderlying, isSlice := namedArgType.Underlying().(*types.Slice); isSlice {
-						// Get the target slice type
-						targetType := c.pkg.TypesInfo.TypeOf(arrayType)
-						if targetSliceType, isTargetSlice := targetType.Underlying().(*types.Slice); isTargetSlice {
-							// Check if element types are compatible
-							if types.Identical(sliceUnderlying.Elem(), targetSliceType.Elem()) {
-								// This is a conversion from wrapper slice type to []T
-								// Since wrapper types are now type aliases, just write the value directly
-								if err := c.WriteValueExpr(arg); err != nil {
-									return true, fmt.Errorf("failed to write argument for slice type conversion: %w", err)
-								}
-								return true, nil
-							}
-						}
-					}
-				}
-			}
-		}
-	}
-
-	return false, nil
-}
-
-// writeStringConversion handles string() conversion
-func (c *GoToTSCompiler) writeStringConversion(exp *ast.CallExpr) error {
-	if len(exp.Args) != 1 {
-		return fmt.Errorf("string() conversion expects exactly 1 argument, got %d", len(exp.Args))
-	}
-
-	arg := exp.Args[0]
-
-	// Case 1: Argument is a string literal string("...")
-	if basicLit, isBasicLit := arg.(*ast.BasicLit); isBasicLit && basicLit.Kind == token.STRING {
-		// Translate string("...") to "..." (no-op)
-		c.WriteBasicLit(basicLit)
-		return nil
-	}
-
-	// Case 2: Argument is a rune (int32) or a call to rune()
-	innerCall, isCallExpr := arg.(*ast.CallExpr)
-
-	if isCallExpr {
-		// Check if it's a call to rune()
-		if innerFunIdent, innerFunIsIdent := innerCall.Fun.(*ast.Ident); innerFunIsIdent && innerFunIdent.String() == "rune" {
-			// Translate string(rune(val)) to $.runeOrStringToString(val)
-			if len(innerCall.Args) == 1 {
-				c.tsw.WriteLiterally("$.runeOrStringToString(")
-				if err := c.WriteValueExpr(innerCall.Args[0]); err != nil {
-					return fmt.Errorf("failed to write argument for string(rune) conversion: %w", err)
-				}
-				c.tsw.WriteLiterally(")")
-				return nil
-			}
-		}
-	}
-
-	// Handle direct string(int32) conversion
-	if tv, ok := c.pkg.TypesInfo.Types[arg]; ok {
-		// Case 3a: Argument is already a string - no-op (unless it's a named type with toString)
-		if c.isStringType(tv.Type) {
-			// Check if this is a named type from the reflect package (like StructTag)
-			// which is implemented as a class in TypeScript with a toString() method
-			if namedType, isNamed := tv.Type.(*types.Named); isNamed {
-				obj := namedType.Obj()
-				if obj != nil && obj.Pkg() != nil && obj.Pkg().Path() == "reflect" && obj.Name() == "StructTag" {
-					// Call toString() for reflect.StructTag
-					if err := c.WriteValueExpr(arg); err != nil {
-						return fmt.Errorf("failed to write argument for string(reflect.StructTag) conversion: %w", err)
-					}
-					c.tsw.WriteLiterally(".toString()")
-					return nil
-				}
-			}
-			// Translate string(stringValue) to stringValue (no-op)
-			if err := c.WriteValueExpr(arg); err != nil {
-				return fmt.Errorf("failed to write argument for string(string) no-op conversion: %w", err)
-			}
-			return nil
-		}
-
-		if basic, isBasic := tv.Type.Underlying().(*types.Basic); isBasic && (basic.Kind() == types.Int32 || basic.Kind() == types.UntypedRune) {
-			// Translate string(rune_val) to $.runeOrStringToString(rune_val)
-			c.tsw.WriteLiterally("$.runeOrStringToString(")
-			if err := c.WriteValueExpr(arg); err != nil {
-				return fmt.Errorf("failed to write argument for string(int32) conversion: %w", err)
-			}
-			c.tsw.WriteLiterally(")")
-			return nil
-		}
-
-		if basic, isBasic := tv.Type.Underlying().(*types.Basic); isBasic && basic.Kind() == types.Uint8 {
-			// Translate string(byte_val) to $.runeOrStringToString(byte_val)
-			c.tsw.WriteLiterally("$.runeOrStringToString(")
-			if err := c.WriteValueExpr(arg); err != nil {
-				return fmt.Errorf("failed to write argument for string(byte) conversion: %w", err)
-			}
-			c.tsw.WriteLiterally(")")
-			return nil
-		}
-
-		// Case 3: Argument is a slice of runes or bytes string([]rune{...}) or string([]byte{...})
-		if c.isByteSliceType(tv.Type) {
-			c.tsw.WriteLiterally("$.bytesToString(")
-			if err := c.WriteValueExpr(arg); err != nil {
-				return fmt.Errorf("failed to write argument for string([]byte) conversion: %w", err)
-			}
-			c.tsw.WriteLiterally(")")
-			return nil
-		}
-		if c.isRuneSliceType(tv.Type) {
-			c.tsw.WriteLiterally("$.runesToString(")
-			if err := c.WriteValueExpr(arg); err != nil {
-				return fmt.Errorf("failed to write argument for string([]rune) conversion: %w", err)
-			}
-			c.tsw.WriteLiterally(")")
-			return nil
-		}
-
-		// Case 4: Argument is a generic type parameter (e.g., string | []byte)
-		if typeParam, isTypeParam := tv.Type.(*types.TypeParam); isTypeParam {
-			// Check if this is a []byte | string union constraint precisely
-			constraint := typeParam.Constraint()
-			if constraint != nil {
-				hasString := constraintIncludesString(constraint)
-				hasBytes := constraintIncludesByteSlice(constraint)
-
-				if hasString && hasBytes {
-					c.tsw.WriteLiterally("$.genericBytesOrStringToString(")
-					if err := c.WriteValueExpr(arg); err != nil {
-						return fmt.Errorf("failed to write argument for string(generic union) conversion: %w", err)
-					}
-					c.tsw.WriteLiterally(")")
-					return nil
-				}
-				if hasString {
-					// string(T) where T is constrained to string: no-op
-					if err := c.WriteValueExpr(arg); err != nil {
-						return fmt.Errorf("failed to write argument for string(string-constrained) conversion: %w", err)
-					}
-					return nil
-				}
-				if hasBytes {
-					// string(T) where T is constrained to []byte
-					c.tsw.WriteLiterally("$.bytesToString(")
-					if err := c.WriteValueExpr(arg); err != nil {
-						return fmt.Errorf("failed to write argument for string([]byte-constrained) conversion: %w", err)
-					}
-					c.tsw.WriteLiterally(")")
-					return nil
-				}
-
-				// Fallback to previous behavior if we cannot determine precisely
-				c.tsw.WriteLiterally("$.genericBytesOrStringToString(")
-				if err := c.WriteValueExpr(arg); err != nil {
-					return fmt.Errorf("failed to write argument for string(generic fallback) conversion: %w", err)
-				}
-				c.tsw.WriteLiterally(")")
-				return nil
-			}
-		}
-	}
-
-	// Fallback: when type info is not available (e.g., in WASM context),
-	// use a generic conversion that handles both []byte and string
-	c.tsw.WriteLiterally("$.genericBytesOrStringToString(")
-	if err := c.WriteValueExpr(arg); err != nil {
-		return fmt.Errorf("failed to write argument for string(unknown type) conversion: %w", err)
-	}
-	c.tsw.WriteLiterally(")")
-	return nil
-}
-
-// handleTypeConversionCommon contains the shared logic for type conversions
-func (c *GoToTSCompiler) handleTypeConversionCommon(
-	typeName *types.TypeName,
-	arg ast.Expr,
-	typeNameStr string,
-	writeTypeNameFunc func() error,
-) error {
-	// Check if we're converting FROM a type with receiver methods TO its underlying type
-	if argType := c.pkg.TypesInfo.TypeOf(arg); argType != nil {
-		if namedArgType, isNamed := argType.(*types.Named); isNamed {
-			// Check if the argument type is a wrapper type
-			if c.isWrapperType(namedArgType) {
-				// Check if we're converting to the underlying type
-				targetType := typeName.Type()
-				underlyingType := namedArgType.Underlying()
-				if types.Identical(targetType, underlyingType) {
-					// This is a conversion from a wrapper type to its underlying type
-					// Since wrapper types are now type aliases, just write the value directly
-					return c.WriteValueExpr(arg)
-				}
-			}
-		}
-	}
-
-	// Check if this is a function type
-	if _, isFuncType := typeName.Type().Underlying().(*types.Signature); isFuncType {
-		// For function types, we need to add a __goTypeName property
-		c.tsw.WriteLiterally("Object.assign(")
-
-		// Write the argument first
-		if err := c.WriteValueExpr(arg); err != nil {
-			return fmt.Errorf("failed to write argument for function type cast: %w", err)
-		}
-
-		// Add the __goTypeName property with the function type name
-		c.tsw.WriteLiterallyf(", { __goTypeName: '%s' })", typeNameStr)
-		return nil
-	}
-
-	// Check if this is a wrapper type
-	if c.isWrapperType(typeName.Type()) {
-		// For wrapper types, use type casting instead of constructor calls
-		c.tsw.WriteLiterally("(")
-		if err := c.WriteValueExpr(arg); err != nil {
-			return fmt.Errorf("failed to write argument for wrapper type cast: %w", err)
-		}
-		c.tsw.WriteLiterally(" as ")
-		c.WriteGoType(typeName.Type(), GoTypeContextGeneral)
-		c.tsw.WriteLiterally(")")
-		return nil
-	}
-
-	// Check if this is a simple named type (no methods, not struct, not interface)
-	if namedType, ok := typeName.Type().(*types.Named); ok {
-		// Don't use constructors for simple named types without methods
-		if namedType.NumMethods() == 0 {
-			// Exclude struct and interface types - they should still use constructors
-			if _, isStruct := namedType.Underlying().(*types.Struct); !isStruct {
-				if _, isInterface := namedType.Underlying().(*types.Interface); !isInterface {
-					// Simple named type without methods - use type casting
-					c.tsw.WriteLiterally("(")
-					if err := c.WriteValueExpr(arg); err != nil {
-						return fmt.Errorf("failed to write argument for simple named type cast: %w", err)
-					}
-					c.tsw.WriteLiterally(" as ")
-					c.WriteGoType(typeName.Type(), GoTypeContextGeneral)
-					c.tsw.WriteLiterally(")")
-					return nil
-				}
-			}
-		}
-	}
-
-	// Check if this type has receiver methods
-	if c.hasReceiverMethods(typeNameStr) {
-		// For types with methods that are NOT wrapper types, still use class constructor
-		c.tsw.WriteLiterally("new ")
-		if err := writeTypeNameFunc(); err != nil {
-			return fmt.Errorf("failed to write type name: %w", err)
-		}
-		c.tsw.WriteLiterally("(")
-
-		// Use auto-wrapping for the constructor argument (only if writeTypeNameFunc writes a simple identifier)
-		// The constructor parameter type is the underlying type of the named type
-		// For MyMode (which is type MyMode os.FileMode), the constructor expects os.FileMode
-		constructorParamType := typeName.Type()
-		if namedType, ok := typeName.Type().(*types.Named); ok {
-			// For named types, the constructor expects the underlying type
-			constructorParamType = namedType.Underlying()
-		}
-
-		if err := c.writeAutoWrappedArgument(arg, constructorParamType); err != nil {
-			return fmt.Errorf("failed to write argument for type constructor: %w", err)
-		}
-		c.tsw.WriteLiterally(")")
-		return nil
-	}
-
-	// Determine if this type should use constructor syntax
-	shouldUseConstructor := false
-
-	// Check if it's a type alias (like os.FileMode)
-	if alias, isAlias := typeName.Type().(*types.Alias); isAlias {
-		// For type aliases, check the underlying type
-		if _, isInterface := alias.Underlying().(*types.Interface); !isInterface {
-			if _, isStruct := alias.Underlying().(*types.Struct); !isStruct {
-				// For non-struct, non-interface type aliases, use constructor
-				shouldUseConstructor = true
-			}
-		}
-	} else if namedType, isNamed := typeName.Type().(*types.Named); isNamed {
-		// For named types, check if they have receiver methods in the current package
-		// or if they follow the pattern of non-struct, non-interface named types
-		if c.hasReceiverMethods(typeNameStr) {
-			shouldUseConstructor = true
-		} else if _, isInterface := namedType.Underlying().(*types.Interface); !isInterface {
-			if _, isStruct := namedType.Underlying().(*types.Struct); !isStruct {
-				// For non-struct, non-interface named types, use constructor
-				shouldUseConstructor = true
-			}
-		}
-	}
-
-	if shouldUseConstructor {
-		// For types that should use constructors, use class constructor
-		c.tsw.WriteLiterally("new ")
-		if err := writeTypeNameFunc(); err != nil {
-			return fmt.Errorf("failed to write type name: %w", err)
-		}
-		c.tsw.WriteLiterally("(")
-		if err := c.WriteValueExpr(arg); err != nil {
-			return fmt.Errorf("failed to write argument for type constructor: %w", err)
-		}
-		c.tsw.WriteLiterally(")")
-		return nil
-	}
-
-	// For types that don't need constructors, use the TypeScript "as" operator
-	c.tsw.WriteLiterally("(")
-	if err := c.WriteValueExpr(arg); err != nil {
-		return fmt.Errorf("failed to write argument for type cast: %w", err)
-	}
-
-	// Then use the TypeScript "as" operator with the mapped type name
-	c.tsw.WriteLiterally(" as ")
-	c.WriteGoType(typeName.Type(), GoTypeContextGeneral)
-	c.tsw.WriteLiterally(")")
-	return nil
-}
-
-// writeTypeConversion handles named type conversions
-func (c *GoToTSCompiler) writeTypeConversion(exp *ast.CallExpr, funIdent *ast.Ident) (handled bool, err error) {
-	// Check if this is a type conversion to a function type
-	if funIdent == nil {
-		return false, nil
-	}
-
-	if obj := c.objectOfIdent(funIdent); obj != nil {
-		// Check if the object is a type name
-		if typeName, isType := obj.(*types.TypeName); isType {
-			// Make sure we have exactly one argument
-			if len(exp.Args) == 1 {
-				err := c.handleTypeConversionCommon(typeName, exp.Args[0], funIdent.String(), func() error {
-					c.tsw.WriteLiterally(funIdent.String())
-					return nil
-				})
-				return true, err
-			}
-		}
-	}
-
-	return false, nil
-}
-
-// writeIntConversion handles int() conversion
-func (c *GoToTSCompiler) writeIntConversion(exp *ast.CallExpr) error {
-	if len(exp.Args) != 1 {
-		return fmt.Errorf("int() conversion expects exactly 1 argument, got %d", len(exp.Args))
-	}
-
-	arg := exp.Args[0]
-
-	// Check if we're converting FROM a type with receiver methods TO int
-	if argType := c.pkg.TypesInfo.TypeOf(arg); argType != nil {
-		if namedArgType, isNamed := argType.(*types.Named); isNamed {
-			// Check if the argument type is a wrapper type
-			if c.isWrapperType(namedArgType) {
-				// Check if we're converting to int (the underlying type)
-				if types.Identical(types.Typ[types.Int], namedArgType.Underlying()) {
-					// This is a conversion from a wrapper type to int
-					// Since wrapper types are now type aliases, just write the value directly
-					if err := c.WriteValueExpr(arg); err != nil {
-						return fmt.Errorf("failed to write argument for int conversion: %w", err)
-					}
-					return nil
-				}
-			}
-		}
-	}
-
-	// Default case: Translate int(value) to $.int(value)
-	c.tsw.WriteLiterally("$.int(")
-	if err := c.WriteValueExpr(exp.Args[0]); err != nil {
-		return fmt.Errorf("failed to write argument for int() conversion: %w", err)
-	}
-	c.tsw.WriteLiterally(")")
-	return nil
-}
-
-// writeQualifiedTypeConversion handles qualified type conversions like os.FileMode(value)
-func (c *GoToTSCompiler) writeQualifiedTypeConversion(exp *ast.CallExpr, selectorExpr *ast.SelectorExpr) (handled bool, err error) {
-	// Check if this is a type conversion by looking up the selector in the type info
-	if obj := c.objectOfIdent(selectorExpr.Sel); obj != nil {
-		// Check if the object is a type name
-		if typeName, isType := obj.(*types.TypeName); isType {
-			// Make sure we have exactly one argument
-			if len(exp.Args) == 1 {
-				err := c.handleTypeConversionCommon(typeName, exp.Args[0], selectorExpr.Sel.Name, func() error {
-					return c.WriteSelectorExpr(selectorExpr)
-				})
-				return true, err
-			}
-		}
-	}
-
-	return false, nil
-}
-
-// Helper: detect if a constraint includes string or []byte
-func constraintIncludesString(t types.Type) bool {
-	iface, ok := t.Underlying().(*types.Interface)
-	if !ok {
-		return false
-	}
-	return analyzeConstraint(iface).HasString
-}
-
-func constraintIncludesByteSlice(t types.Type) bool {
-	iface, ok := t.Underlying().(*types.Interface)
-	if !ok {
-		return false
-	}
-	return analyzeConstraint(iface).HasByteSlice
-}