goscript 0.0.58 → 0.0.59

package/compiler/expr-call-async.go

@@ -6,17 +6,13 @@ import (
 	"strings"
 )
 
-// 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 {
+// 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.pkg.TypesInfo.Uses[fun]; obj != nil {
-			if c.analysis.IsAsyncFunc(obj) {
-				c.tsw.WriteLiterally("await ")
-				return true
-			}
+		if obj := c.objectOfIdent(fun); obj != nil {
+			return c.analysis.IsAsyncFunc(obj)
 		}
 		return false
 
@@ -29,13 +25,13 @@ func (c *GoToTSCompiler) writeAsyncCallIfNeeded(exp *ast.CallExpr) bool {
 		switch x := fun.X.(type) {
 		case *ast.Ident:
 			// Direct identifier: obj.method()
-			obj = c.pkg.TypesInfo.Uses[x]
+			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.pkg.TypesInfo.Uses[id]
+				obj = c.objectOfIdent(id)
 				objOk = obj != nil
 			}
 
@@ -43,8 +39,6 @@ func (c *GoToTSCompiler) writeAsyncCallIfNeeded(exp *ast.CallExpr) bool {
 			// Field access: obj.field.method()
 			// Get the type of the field access expression
 			if fieldType := c.pkg.TypesInfo.TypeOf(x); fieldType != nil {
-				// For field access, we create a synthetic object representing the field type
-				// We'll handle this case below when we determine the method's type
 				objOk = true
 			}
 
@@ -61,13 +55,7 @@ func (c *GoToTSCompiler) writeAsyncCallIfNeeded(exp *ast.CallExpr) bool {
 			if pkgName, isPkg := obj.(*types.PkgName); isPkg {
 				methodName := fun.Sel.Name
 				pkgPath := pkgName.Imported().Path()
-
-				// Check if this package-level function is async (empty TypeName)
-				if c.analysis.IsMethodAsync(pkgPath, "", methodName) {
-					c.tsw.WriteLiterally("await ")
-					return true
-				}
-				return false
+				return c.analysis.IsMethodAsync(pkgPath, "", methodName)
 			}
 		}
 
@@ -83,7 +71,6 @@ func (c *GoToTSCompiler) writeAsyncCallIfNeeded(exp *ast.CallExpr) bool {
 			}
 		} else {
 			// Field access case: obj.field.method()
-			// Get the type of the field access expression
 			targetType = c.pkg.TypesInfo.TypeOf(fun.X)
 			if targetType == nil {
 				return false
@@ -94,12 +81,7 @@ func (c *GoToTSCompiler) writeAsyncCallIfNeeded(exp *ast.CallExpr) bool {
 
 		// Check if target type is an interface
 		if interfaceType, isInterface := targetType.Underlying().(*types.Interface); isInterface {
-			// Interface method call: use interface method async analysis
-			if c.analysis.IsInterfaceMethodAsync(interfaceType, methodName) {
-				c.tsw.WriteLiterally("await ")
-				return true
-			}
-			return false
+			return c.analysis.IsInterfaceMethodAsync(interfaceType, methodName)
 		}
 
 		// Get the named type from the target type
@@ -128,22 +110,26 @@ func (c *GoToTSCompiler) writeAsyncCallIfNeeded(exp *ast.CallExpr) bool {
 		if typePkg != nil {
 			pkgPath = typePkg.Path()
 		} else {
-			// Fallback to current package
 			pkgPath = c.pkg.Types.Path()
 		}
 
-		// Check if this method is async using unified analysis
-		if c.analysis.IsMethodAsync(pkgPath, typeName, methodName) {
-			c.tsw.WriteLiterally("await ")
-			return true
-		}
-		return false
+		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 {
@@ -151,7 +137,7 @@ func (c *GoToTSCompiler) addNonNullAssertion(expFun ast.Expr) {
 			// 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.pkg.TypesInfo.Uses[ident]; obj != nil {
+				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

package/compiler/expr-call-builtins.go

@@ -8,6 +8,25 @@ import (
 	"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,
+}
+
 // writeBuiltinFunction handles built-in Go functions
 func (c *GoToTSCompiler) writeBuiltinFunction(exp *ast.CallExpr, funName string) (handled bool, err error) {
 	switch funName {

package/compiler/expr-call-helpers.go

@@ -7,34 +7,6 @@ import (
 	"github.com/pkg/errors"
 )
 
-// isByteSliceType checks if a type is []byte (slice of uint8)
-func (c *GoToTSCompiler) isByteSliceType(t types.Type) bool {
-	if sliceType, isSlice := t.Underlying().(*types.Slice); isSlice {
-		if basicElem, isBasic := sliceType.Elem().(*types.Basic); isBasic && basicElem.Kind() == types.Uint8 {
-			return true
-		}
-	}
-	return false
-}
-
-// isRuneSliceType checks if a type is []rune (slice of int32)
-func (c *GoToTSCompiler) isRuneSliceType(t types.Type) bool {
-	if sliceType, isSlice := t.Underlying().(*types.Slice); isSlice {
-		if basicElem, isBasic := sliceType.Elem().(*types.Basic); isBasic && basicElem.Kind() == types.Int32 {
-			return true
-		}
-	}
-	return false
-}
-
-// isStringType checks if a type is string
-func (c *GoToTSCompiler) isStringType(t types.Type) bool {
-	if basic, isBasic := t.Underlying().(*types.Basic); isBasic {
-		return basic.Kind() == types.String || basic.Kind() == types.UntypedString
-	}
-	return false
-}
-
 // writeByteSliceCreation handles the creation of []byte slices with proper Uint8Array handling
 func (c *GoToTSCompiler) writeByteSliceCreation(lengthArg, capacityArg interface{}) error {
 	return c.writeSliceCreationForType(lengthArg, capacityArg, true)