goscript 0.0.84 → 0.1.1

package/compiler/expr-call-async.go

@@ -1,188 +0,0 @@
-package compiler
-
-import (
-	"go/ast"
-	"go/types"
-	"strings"
-)
-
-// isCallExprAsync determines if a CallExpr represents an async function/method call
-func (c *GoToTSCompiler) isCallExprAsync(exp *ast.CallExpr) bool {
-	switch fun := exp.Fun.(type) {
-	case *ast.Ident:
-		// Function call (e.g., func())
-		if obj := c.objectOfIdent(fun); obj != nil {
-			// Check if this is a known async function
-			if c.analysis.IsAsyncFunc(obj) {
-				return true
-			}
-			// Check if this is a variable that returns async values
-			// (e.g., indirect := sync.OnceValue(asyncFunc))
-			if c.analysis.IsAsyncReturningVar(obj) {
-				return true
-			}
-		}
-		return false
-
-	case *ast.SelectorExpr:
-		// Method call (e.g., obj.method() or obj.field.method())
-		var obj types.Object
-		var objOk bool
-
-		// Handle different patterns of method receiver
-		switch x := fun.X.(type) {
-		case *ast.Ident:
-			// Direct identifier: obj.method()
-			obj = c.objectOfIdent(x)
-			objOk = obj != nil
-
-		case *ast.StarExpr:
-			// Pointer dereference: (*p).method() or p.method() where p is a pointer
-			if id, isIdent := x.X.(*ast.Ident); isIdent {
-				obj = c.objectOfIdent(id)
-				objOk = obj != nil
-			}
-
-		case *ast.SelectorExpr:
-			// Field access: obj.field.method()
-			// Get the type of the field access expression
-			if fieldType := c.pkg.TypesInfo.TypeOf(x); fieldType != nil {
-				objOk = true
-			}
-
-		case *ast.CallExpr:
-			// Method call on function result: funcCall().method()
-			// Get the type of the function call result
-			if callType := c.pkg.TypesInfo.TypeOf(x); callType != nil {
-				objOk = true
-			}
-
-		default:
-			objOk = false
-		}
-
-		if !objOk {
-			return false
-		}
-
-		// Handle package-level function calls (e.g., time.Sleep)
-		if obj != nil {
-			if pkgName, isPkg := obj.(*types.PkgName); isPkg {
-				methodName := fun.Sel.Name
-				pkgPath := pkgName.Imported().Path()
-				return c.analysis.IsMethodAsync(pkgPath, "", methodName)
-			}
-		}
-
-		// Get the type for method calls on objects
-		var targetType types.Type
-
-		if obj != nil {
-			// Direct variable case: obj.method()
-			if varObj, ok := obj.(*types.Var); ok {
-				targetType = varObj.Type()
-			} else {
-				return false
-			}
-		} else {
-			// Field access case: obj.field.method()
-			targetType = c.pkg.TypesInfo.TypeOf(fun.X)
-			if targetType == nil {
-				return false
-			}
-		}
-
-		methodName := fun.Sel.Name
-
-		// Check if target type is an interface
-		if interfaceType, isInterface := targetType.Underlying().(*types.Interface); isInterface {
-			return c.analysis.IsInterfaceMethodAsync(interfaceType, methodName)
-		}
-
-		// Get the named type from the target type
-		var namedType *types.Named
-		var namedTypeOk bool
-
-		// Handle both direct named types and pointer to named types
-		switch t := targetType.(type) {
-		case *types.Named:
-			namedType, namedTypeOk = t, true
-		case *types.Pointer:
-			if nt, isNamed := t.Elem().(*types.Named); isNamed {
-				namedType, namedTypeOk = nt, true
-			}
-		}
-
-		if !namedTypeOk {
-			return false
-		}
-
-		typeName := namedType.Obj().Name()
-
-		// Determine the package path for the method
-		var pkgPath string
-		typePkg := namedType.Obj().Pkg()
-		if typePkg != nil {
-			pkgPath = typePkg.Path()
-		} else {
-			pkgPath = c.pkg.Types.Path()
-		}
-
-		return c.analysis.IsMethodAsync(pkgPath, typeName, methodName)
-
-	default:
-		return false
-	}
-}
-
-// writeAsyncCallIfNeeded writes the await prefix for async function or method calls
-// Returns true if await was written, false otherwise
-func (c *GoToTSCompiler) writeAsyncCallIfNeeded(exp *ast.CallExpr) bool {
-	if c.isCallExprAsync(exp) {
-		c.tsw.WriteLiterally("await ")
-		return true
-	}
-	return false
-}
-
-// addNonNullAssertion adds ! for function calls that might return null
-func (c *GoToTSCompiler) addNonNullAssertion(expFun ast.Expr) {
-	if funType := c.pkg.TypesInfo.TypeOf(expFun); funType != nil {
-		if _, ok := funType.Underlying().(*types.Signature); ok {
-			// Check if this is a function parameter identifier that needs not-null assertion
-			if ident, isIdent := expFun.(*ast.Ident); isIdent {
-				// Check if this identifier is a function parameter
-				if obj := c.objectOfIdent(ident); obj != nil {
-					if _, isVar := obj.(*types.Var); isVar {
-						// This is a variable (including function parameters)
-						// Function parameters that are function types need ! assertion
-						c.tsw.WriteLiterally("!")
-					}
-				}
-			} else if selectorExpr, isSelectorExpr := expFun.(*ast.SelectorExpr); isSelectorExpr {
-				// Check if this is a field access that returns a function type
-				// e.g., s.step where step is a function-typed field
-				if selection := c.pkg.TypesInfo.Selections[selectorExpr]; selection != nil {
-					// This is a field or method selection
-					if selection.Kind() == types.FieldVal {
-						// It's a field - function-typed fields may be nil
-						c.tsw.WriteLiterally("!")
-					}
-				}
-			} else if _, isParenExpr := expFun.(*ast.ParenExpr); isParenExpr {
-				// Parenthesized function expressions often come from pointer dereferences
-				// like (*rel)(), which remain nullable in TypeScript.
-				c.tsw.WriteLiterally("!")
-			} else if _, isNamed := funType.(*types.Named); isNamed {
-				c.tsw.WriteLiterally("!")
-			}
-		} else {
-			// Check if the function type is nullable (e.g., func(...) | null)
-			// This handles cases where a function call returns a nullable function
-			funTypeStr := funType.String()
-			if strings.Contains(funTypeStr, "| null") || strings.Contains(funTypeStr, "null |") {
-				c.tsw.WriteLiterally("!")
-			}
-		}
-	}
-}

package/compiler/expr-call-builtins.go

@@ -1,208 +0,0 @@
-package compiler
-
-import (
-	"fmt"
-	"go/ast"
-	"go/token"
-
-	"github.com/pkg/errors"
-)
-
-// builtinFunctions is the definitive list of Go builtin functions handled by the compiler
-var builtinFunctions = map[string]bool{
-	"len":     true,
-	"cap":     true,
-	"make":    true,
-	"new":     true,
-	"append":  true,
-	"copy":    true,
-	"delete":  true,
-	"complex": true,
-	"real":    true,
-	"imag":    true,
-	"close":   true,
-	"panic":   true,
-	"recover": true,
-	"print":   true,
-	"println": true,
-	"min":     true,
-	"max":     true,
-	"clear":   true,
-}
-
-// writeBuiltinFunction handles built-in Go functions
-func (c *GoToTSCompiler) writeBuiltinFunction(exp *ast.CallExpr, funName string) (handled bool, err error) {
-	switch funName {
-	case "panic":
-		c.tsw.WriteLiterally("$.panic")
-		return true, nil
-	case "println":
-		c.tsw.WriteLiterally("$.println")
-		return true, nil
-	case "len":
-		if len(exp.Args) != 1 {
-			return true, errors.Errorf("unhandled len call with incorrect number of arguments: %d != 1", len(exp.Args))
-		}
-		c.tsw.WriteLiterally("$.len")
-		return true, nil
-	case "cap":
-		if len(exp.Args) != 1 {
-			return true, errors.Errorf("unhandled cap call with incorrect number of arguments: %d != 1", len(exp.Args))
-		}
-		c.tsw.WriteLiterally("$.cap")
-		return true, nil
-	case "new":
-		if len(exp.Args) != 1 {
-			return true, errors.Errorf("unhandled new call with incorrect number of arguments: %d != 1", len(exp.Args))
-		}
-		c.tsw.WriteLiterally("new ")
-		c.WriteTypeExpr(exp.Args[0]) // This should write the TypeScript type T_ts
-		c.tsw.WriteLiterally("()")
-		return true, nil
-	case "delete":
-		if len(exp.Args) != 2 {
-			return true, errors.Errorf("unhandled delete call with incorrect number of arguments: %d != 2", len(exp.Args))
-		}
-		c.tsw.WriteLiterally("$.deleteMapEntry")
-		return true, nil
-	case "copy":
-		if len(exp.Args) != 2 {
-			return true, errors.Errorf("unhandled copy call with incorrect number of arguments: %d != 2", len(exp.Args))
-		}
-		c.tsw.WriteLiterally("$.copy")
-		return true, nil
-	case "recover":
-		if len(exp.Args) != 0 {
-			return true, errors.Errorf("unhandled recover call with incorrect number of arguments: %d != 0", len(exp.Args))
-		}
-		c.tsw.WriteLiterally("$.recover")
-		return true, nil
-	case "make":
-		return true, c.WriteCallExprMake(exp)
-	case "string":
-		return true, c.writeStringConversion(exp)
-	case "close":
-		if len(exp.Args) != 1 {
-			return true, errors.New("unhandled close call with incorrect number of arguments")
-		}
-		if err := c.WriteValueExpr(exp.Args[0]); err != nil {
-			return true, fmt.Errorf("failed to write channel in close call: %w", err)
-		}
-		c.tsw.WriteLiterally(".close()")
-		return true, nil
-	case "append":
-		return true, c.writeAppendCall(exp)
-	case "min":
-		if len(exp.Args) < 1 {
-			return true, errors.New("unhandled min call with no arguments")
-		}
-		c.tsw.WriteLiterally("Math.min(")
-		for i, arg := range exp.Args {
-			if i > 0 {
-				c.tsw.WriteLiterally(", ")
-			}
-			if err := c.WriteValueExpr(arg); err != nil {
-				return true, fmt.Errorf("failed to write argument %d in min call: %w", i, err)
-			}
-		}
-		c.tsw.WriteLiterally(")")
-		return true, nil
-	case "max":
-		if len(exp.Args) < 1 {
-			return true, errors.New("unhandled max call with no arguments")
-		}
-		c.tsw.WriteLiterally("Math.max(")
-		for i, arg := range exp.Args {
-			if i > 0 {
-				c.tsw.WriteLiterally(", ")
-			}
-			if err := c.WriteValueExpr(arg); err != nil {
-				return true, fmt.Errorf("failed to write argument %d in max call: %w", i, err)
-			}
-		}
-		c.tsw.WriteLiterally(")")
-		return true, nil
-	case "clear":
-		if len(exp.Args) != 1 {
-			return true, errors.Errorf("unhandled clear call with incorrect number of arguments: %d != 1", len(exp.Args))
-		}
-		c.tsw.WriteLiterally("$.clear(")
-		if err := c.WriteValueExpr(exp.Args[0]); err != nil {
-			return true, fmt.Errorf("failed to write argument in clear call: %w", err)
-		}
-		c.tsw.WriteLiterally(")")
-		return true, nil
-	case "byte":
-		if len(exp.Args) != 1 {
-			return true, errors.Errorf("unhandled byte call with incorrect number of arguments: %d != 1", len(exp.Args))
-		}
-		c.tsw.WriteLiterally("$.byte(")
-		if err := c.WriteValueExpr(exp.Args[0]); err != nil {
-			return true, fmt.Errorf("failed to write argument for byte() conversion: %w", err)
-		}
-		c.tsw.WriteLiterally(")")
-		return true, nil
-	case "int":
-		return true, c.writeIntConversion(exp)
-	default:
-		return false, nil
-	}
-}
-
-// writeAppendCall handles append() function calls
-func (c *GoToTSCompiler) writeAppendCall(exp *ast.CallExpr) error {
-	if len(exp.Args) < 1 {
-		return errors.New("unhandled append call with incorrect number of arguments")
-	}
-
-	c.tsw.WriteLiterally("$.append(")
-	// The first argument is the slice
-	if err := c.WriteValueExpr(exp.Args[0]); err != nil {
-		return fmt.Errorf("failed to write slice in append call: %w", err)
-	}
-
-	// The remaining arguments are the elements to append
-	elemsToAppend := exp.Args[1:]
-	for i, arg := range elemsToAppend {
-		if i > 0 || len(exp.Args) > 1 {
-			c.tsw.WriteLiterally(", ")
-		}
-
-		// Handle ellipsis (spread) for the last argument: append(slice, elems...)
-		// The ellipsis can only appear on the last argument, so check if this is the last element
-		isLastElement := i == len(elemsToAppend)-1
-		if exp.Ellipsis != token.NoPos && isLastElement {
-			// Check if the slice is []byte and the argument is a string
-			sliceType := c.pkg.TypesInfo.TypeOf(exp.Args[0])
-			argType := c.pkg.TypesInfo.TypeOf(arg)
-
-			if sliceType != nil && argType != nil {
-				if c.isByteSliceType(sliceType) && c.isStringType(argType) {
-					// Convert string to bytes: append([]byte, string...) -> $.append(slice, ...$.stringToBytes(string))
-					c.tsw.WriteLiterally("...$.stringToBytes(")
-					if err := c.WriteValueExpr(arg); err != nil {
-						return fmt.Errorf("failed to write string argument in append call: %w", err)
-					}
-					c.tsw.WriteLiterally(")")
-					continue
-				}
-			}
-
-			// For other slice types with ellipsis, use spread operator
-			// append(slice, anotherSlice...) -> $.append(slice, ...(anotherSlice || []))
-			// The || [] handles the case where anotherSlice is null (nil in Go)
-			c.tsw.WriteLiterally("...(")
-			if err := c.WriteValueExpr(arg); err != nil {
-				return fmt.Errorf("failed to write spread argument in append call: %w", err)
-			}
-			c.tsw.WriteLiterally(" || [])")
-			continue
-		}
-
-		if err := c.WriteValueExpr(arg); err != nil {
-			return fmt.Errorf("failed to write argument %d in append call: %w", i+1, err)
-		}
-	}
-	c.tsw.WriteLiterally(")")
-	return nil
-}