goscript 0.0.49 → 0.0.51

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

@@ -81,7 +81,7 @@ func (c *GoToTSCompiler) writeArrayTypeConversion(exp *ast.CallExpr) (handled bo
 			// 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.analysis.IsWrapperType(namedArgType) {
+				if c.analysis.IsNamedBasicType(namedArgType) {
 					// Check if the underlying type matches the target slice type
 					if sliceUnderlying, isSlice := namedArgType.Underlying().(*types.Slice); isSlice {
 						// Get the target slice type
@@ -216,7 +216,7 @@ func (c *GoToTSCompiler) writeTypeConversion(exp *ast.CallExpr, funIdent *ast.Id
 				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.analysis.IsWrapperType(namedArgType) {
+						if c.analysis.IsNamedBasicType(namedArgType) {
 							// Check if we're converting to the underlying type
 							targetType := typeName.Type()
 							underlyingType := namedArgType.Underlying()
@@ -247,7 +247,7 @@ func (c *GoToTSCompiler) writeTypeConversion(exp *ast.CallExpr, funIdent *ast.Id
 					return true, nil
 				} else {
 					// Check if this is a wrapper type
-					isWrapperType := c.analysis.IsWrapperType(typeName.Type())
+					isWrapperType := c.analysis.IsNamedBasicType(typeName.Type())
 					if isWrapperType {
 						// For wrapper types, use type casting instead of constructor calls
 						c.tsw.WriteLiterally("(")
@@ -288,8 +288,6 @@ func (c *GoToTSCompiler) writeTypeConversion(exp *ast.CallExpr, funIdent *ast.Id
 						c.tsw.WriteLiterally(funIdent.String())
 						c.tsw.WriteLiterally("(")
 
-						fmt.Printf("DEBUG: Type conversion constructor for %s\n", funIdent.String())
-
 						// Use auto-wrapping for the constructor argument
 						// 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
@@ -299,8 +297,6 @@ func (c *GoToTSCompiler) writeTypeConversion(exp *ast.CallExpr, funIdent *ast.Id
 							constructorParamType = namedType.Underlying()
 						}
 
-						fmt.Printf("DEBUG: Constructor param type: %v\n", constructorParamType)
-
 						if err := c.writeAutoWrappedArgument(exp.Args[0], constructorParamType); err != nil {
 							return true, fmt.Errorf("failed to write argument for type constructor: %w", err)
 						}
@@ -376,7 +372,7 @@ func (c *GoToTSCompiler) writeIntConversion(exp *ast.CallExpr) error {
 	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.analysis.IsWrapperType(namedArgType) {
+			if c.analysis.IsNamedBasicType(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
@@ -413,7 +409,7 @@ func (c *GoToTSCompiler) writeQualifiedTypeConversion(exp *ast.CallExpr, selecto
 				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.analysis.IsWrapperType(namedArgType) {
+						if c.analysis.IsNamedBasicType(namedArgType) {
 							// Check if we're converting to the underlying type
 							targetType := typeName.Type()
 							underlyingType := namedArgType.Underlying()
@@ -444,7 +440,7 @@ func (c *GoToTSCompiler) writeQualifiedTypeConversion(exp *ast.CallExpr, selecto
 					return true, nil
 				} else {
 					// Check if this is a wrapper type
-					isWrapperType := c.analysis.IsWrapperType(typeName.Type())
+					isWrapperType := c.analysis.IsNamedBasicType(typeName.Type())
 					if isWrapperType {
 						// For wrapper types, use type casting instead of constructor calls
 						c.tsw.WriteLiterally("(")

package/compiler/expr-call.go

@@ -74,7 +74,7 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 		}
 
 		// Check if this is an async function call
-		_ = c.writeAsyncCall(exp, funIdent)
+		c.writeAsyncCallIfNeeded(exp)
 
 		// Not a special built-in, treat as a regular function call
 		if err := c.WriteValueExpr(expFun); err != nil {
@@ -99,7 +99,7 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 
 	// Handle non-identifier function expressions (method calls, function literals, etc.)
 	// Check if this is an async method call (e.g., mu.Lock())
-	_ = c.writeAsyncMethodCall(exp)
+	c.writeAsyncCallIfNeeded(exp)
 
 	// If expFun is a function literal, it needs to be wrapped in parentheses for IIFE syntax
 	if _, isFuncLit := expFun.(*ast.FuncLit); isFuncLit {
@@ -169,7 +169,7 @@ func (c *GoToTSCompiler) writeCallArguments(exp *ast.CallExpr) error {
 func (c *GoToTSCompiler) writeArgumentWithTypeHandling(arg ast.Expr, funcSig *types.Signature, argIndex int) error {
 	if funcSig != nil && argIndex < funcSig.Params().Len() {
 		paramType := funcSig.Params().At(argIndex).Type()
-		isWrapper := c.analysis.IsWrapperType(paramType)
+		isWrapper := c.analysis.IsNamedBasicType(paramType)
 
 		if isWrapper {
 			// For wrapper types (now type aliases), no auto-wrapping is needed
@@ -234,7 +234,7 @@ func (c *GoToTSCompiler) getImportAlias(pkgPath string) string {
 func (c *GoToTSCompiler) writeAutoWrappedArgument(arg ast.Expr, expectedType types.Type) error {
 	// For wrapper types (now type aliases), no auto-wrapping is needed
 	// Just use type casting if the types don't match exactly
-	if c.analysis.IsWrapperType(expectedType) {
+	if c.analysis.IsNamedBasicType(expectedType) {
 		argType := c.pkg.TypesInfo.TypeOf(arg)
 
 		// Only add type casting if needed
@@ -271,39 +271,70 @@ func (c *GoToTSCompiler) writeWrapperTypeMethodCall(exp *ast.CallExpr, selectorE
 		return false, nil
 	}
 
-	// Check if this is a wrapper type
-	if !c.analysis.IsWrapperType(baseType) {
+	// Check if this is a wrapper type using the analysis
+	isWrapperType := c.analysis.IsNamedBasicType(baseType)
+
+	// Special handling for type aliases to basic types that might have wrapper functions
+	// Even if IsNamedBasicType returns false, we should check for known wrapper type patterns
+	var typeName string
+	if !isWrapperType {
+		// Check if this is a type alias to a basic type that might have wrapper methods
+		if aliasType, ok := baseType.(*types.Alias); ok {
+			if aliasType.Obj() != nil && aliasType.Obj().Pkg() != nil {
+				// Check if the underlying type is a basic type
+				underlying := aliasType.Underlying()
+				if _, isBasic := underlying.(*types.Basic); isBasic {
+					// This is a type alias to a basic type - treat it as a potential wrapper type
+					isWrapperType = true
+					if aliasType.Obj().Pkg() != c.pkg.Types {
+						// Imported type alias like os.FileMode
+						if importAlias := c.getImportAlias(aliasType.Obj().Pkg().Path()); importAlias != "" {
+							typeName = importAlias + "." + aliasType.Obj().Name()
+						} else {
+							typeName = aliasType.Obj().Name()
+						}
+					} else {
+						// Local type alias
+						typeName = aliasType.Obj().Name()
+					}
+				}
+			}
+		}
+	}
+
+	if !isWrapperType {
 		return false, nil
 	}
 
-	// Get the type name for the function call
-	var typeName string
-	if namedType, ok := baseType.(*types.Named); ok {
-		if obj := namedType.Obj(); obj != nil {
-			if obj.Pkg() != nil && obj.Pkg() != c.pkg.Types {
-				// Imported type like os.FileMode
-				if importAlias := c.getImportAlias(obj.Pkg().Path()); importAlias != "" {
-					typeName = importAlias + "." + obj.Name()
+	// Get the type name for the function call if not already set
+	if typeName == "" {
+		if namedType, ok := baseType.(*types.Named); ok {
+			if obj := namedType.Obj(); obj != nil {
+				if obj.Pkg() != nil && obj.Pkg() != c.pkg.Types {
+					// Imported type like os.FileMode
+					if importAlias := c.getImportAlias(obj.Pkg().Path()); importAlias != "" {
+						typeName = importAlias + "." + obj.Name()
+					} else {
+						typeName = obj.Name()
+					}
 				} else {
+					// Local type
 					typeName = obj.Name()
 				}
-			} else {
-				// Local type
-				typeName = obj.Name()
 			}
-		}
-	} else if aliasType, ok := baseType.(*types.Alias); ok {
-		if obj := aliasType.Obj(); obj != nil {
-			if obj.Pkg() != nil && obj.Pkg() != c.pkg.Types {
-				// Imported type alias
-				if importAlias := c.getImportAlias(obj.Pkg().Path()); importAlias != "" {
-					typeName = importAlias + "." + obj.Name()
+		} else if aliasType, ok := baseType.(*types.Alias); ok {
+			if obj := aliasType.Obj(); obj != nil {
+				if obj.Pkg() != nil && obj.Pkg() != c.pkg.Types {
+					// Imported type alias
+					if importAlias := c.getImportAlias(obj.Pkg().Path()); importAlias != "" {
+						typeName = importAlias + "." + obj.Name()
+					} else {
+						typeName = obj.Name()
+					}
 				} else {
+					// Local type alias
 					typeName = obj.Name()
 				}
-			} else {
-				// Local type alias
-				typeName = obj.Name()
 			}
 		}
 	}

package/compiler/sanitize.go

@@ -11,8 +11,7 @@ func sanitizeIdentifier(name string) string {
 
 	// Handle TypeScript built-in types that conflict with Go type parameter names
 	builtinTypes := map[string]string{
-		"Map": "MapType",
-		// Add other built-in types as needed
+		"Promise": "PromiseType",
 	}
 
 	if replacement, exists := builtinTypes[name]; exists {

package/compiler/spec-struct.go

@@ -37,7 +37,7 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 	c.tsw.WriteLine("{")
 	c.tsw.Indent(1)
 
-	className := a.Name.Name
+	className := sanitizeIdentifier(a.Name.Name)
 
 	goStructType, ok := c.pkg.TypesInfo.Defs[a.Name].Type().(*types.Named)
 	if !ok {
@@ -231,10 +231,10 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 			// Check for both simple identifiers (Pair) and generic types (Pair[T])
 			var recvTypeName string
 			if ident, ok := recvType.(*ast.Ident); ok {
-				recvTypeName = ident.Name
+				recvTypeName = sanitizeIdentifier(ident.Name)
 			} else if indexExpr, ok := recvType.(*ast.IndexExpr); ok {
 				if ident, ok := indexExpr.X.(*ast.Ident); ok {
-					recvTypeName = ident.Name
+					recvTypeName = sanitizeIdentifier(ident.Name)
 				}
 			}
 

package/compiler/spec-value.go

@@ -237,7 +237,7 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 					// Check if this is a named type with methods and the initializer is a basic value
 					if namedType, isNamed := goType.(*types.Named); isNamed {
 						// Check if this is a wrapper type first
-						isWrapperType := c.analysis.IsWrapperType(namedType)
+						isWrapperType := c.analysis.IsNamedBasicType(namedType)
 						if isWrapperType {
 							// For wrapper types, no constructor wrapping needed
 							if shouldApplyClone(c.pkg, initializerExpr) {
@@ -334,7 +334,7 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 				// No initializer, use the zero value directly
 				// Check if this is a wrapper type first
 				if namedType, isNamed := goType.(*types.Named); isNamed {
-					isWrapperType := c.analysis.IsWrapperType(namedType)
+					isWrapperType := c.analysis.IsNamedBasicType(namedType)
 					if isWrapperType {
 						// For wrapper types, just use zero value directly
 						c.WriteZeroValueForType(goType)

package/compiler/spec.go

@@ -136,27 +136,8 @@ func (c *GoToTSCompiler) writeRegularFieldInitializer(fieldName string, fieldTyp
 
 	c.tsw.WriteLiterallyf("init?.%s ?? ", fieldName)
 
-	// Debugging: print field type info
-	if astType != nil {
-		if named, ok := fieldType.(*types.Named); ok {
-			if pkgPath := named.Obj().Pkg().Path(); pkgPath != "" {
-				c.tsw.WriteCommentLinef("DEBUG: Field %s has type %s (%T)", fieldName, fieldType, fieldType)
-			}
-		} else {
-			c.tsw.WriteCommentLinef("DEBUG: Field %s has type %s (%T)", fieldName, fieldType, fieldType)
-		}
-		if typeName, ok := c.pkg.TypesInfo.TypeOf(astType).(*types.Named); ok {
-			pkgPath := ""
-			if typeName.Obj().Pkg() != nil {
-				pkgPath = typeName.Obj().Pkg().Path()
-			}
-			c.tsw.WriteCommentLinef("DEBUG: Package=%s, TypeName=%s", pkgPath, typeName)
-		}
-	}
-
 	// Priority 1: Check if this is a wrapper type
-	if c.analysis.IsWrapperType(fieldType) {
-		c.tsw.WriteCommentLinef("DEBUG: Using wrapper type zero value")
+	if c.analysis.IsNamedBasicType(fieldType) {
 		// For wrapper types, use the zero value of the underlying type with type casting
 		if named, ok := fieldType.(*types.Named); ok {
 			c.WriteZeroValueForType(named.Underlying())
@@ -175,27 +156,22 @@ func (c *GoToTSCompiler) writeRegularFieldInitializer(fieldName string, fieldTyp
 
 	// Priority 2: Handle imported types with basic underlying types (like os.FileMode)
 	if c.isImportedBasicType(fieldType) {
-		c.tsw.WriteCommentLinef("DEBUG: Using imported basic type zero value")
 		c.writeImportedBasicTypeZeroValue(fieldType)
 		return
 	}
 
 	// Priority 3: Handle named types
 	if named, isNamed := fieldType.(*types.Named); isNamed {
-		c.tsw.WriteCommentLinef("DEBUG: Using named type zero value")
 		c.writeNamedTypeZeroValue(named)
 		return
 	}
 
 	// Priority 4: Handle type aliases
 	if alias, isAlias := fieldType.(*types.Alias); isAlias {
-		c.tsw.WriteCommentLinef("DEBUG: Using type alias zero value")
 		c.writeTypeAliasZeroValue(alias, astType)
 		return
 	}
 
-	// Default: use WriteZeroValueForType
-	c.tsw.WriteCommentLinef("DEBUG: Using default zero value")
 	c.WriteZeroValueForType(fieldType)
 }
 
@@ -209,36 +185,74 @@ func (c *GoToTSCompiler) isStructValueType(fieldType types.Type) bool {
 }
 
 func (c *GoToTSCompiler) isImportedBasicType(fieldType types.Type) bool {
-	named, isNamed := fieldType.(*types.Named)
-	if !isNamed {
-		return false
-	}
+	// Handle named types
+	if named, isNamed := fieldType.(*types.Named); isNamed {
+		obj := named.Obj()
+		if obj == nil || obj.Pkg() == nil || obj.Pkg() == c.pkg.Types {
+			return false // Not imported or is local
+		}
+
+		underlying := named.Underlying()
+		if underlying == nil {
+			return false
+		}
 
-	obj := named.Obj()
-	if obj == nil || obj.Pkg() == nil || obj.Pkg() == c.pkg.Types {
-		return false // Not imported or is local
+		_, isBasic := underlying.(*types.Basic)
+		return isBasic
 	}
 
-	underlying := named.Underlying()
-	if underlying == nil {
-		return false
+	// Handle type aliases (like os.FileMode = fs.FileMode)
+	if alias, isAlias := fieldType.(*types.Alias); isAlias {
+		obj := alias.Obj()
+		if obj == nil || obj.Pkg() == nil || obj.Pkg() == c.pkg.Types {
+			return false // Not imported or is local
+		}
+
+		underlying := alias.Underlying()
+		if underlying == nil {
+			return false
+		}
+
+		_, isBasic := underlying.(*types.Basic)
+		return isBasic
 	}
 
-	_, isBasic := underlying.(*types.Basic)
-	return isBasic
+	return false
 }
 
 func (c *GoToTSCompiler) writeImportedBasicTypeZeroValue(fieldType types.Type) {
-	named := fieldType.(*types.Named)
-	underlying := named.Underlying()
+	if named, ok := fieldType.(*types.Named); ok {
+		underlying := named.Underlying()
+		// Write zero value of underlying type with type casting
+		c.WriteZeroValueForType(underlying)
+		c.tsw.WriteLiterally(" as ")
+		c.WriteGoType(fieldType, GoTypeContextGeneral)
+		return
+	}
 
-	// Write zero value of underlying type with type casting
-	c.WriteZeroValueForType(underlying)
-	c.tsw.WriteLiterally(" as ")
-	c.WriteGoType(fieldType, GoTypeContextGeneral)
+	if alias, ok := fieldType.(*types.Alias); ok {
+		underlying := alias.Underlying()
+		// Write zero value of underlying type with type casting
+		c.WriteZeroValueForType(underlying)
+		c.tsw.WriteLiterally(" as ")
+		c.WriteGoType(fieldType, GoTypeContextGeneral)
+		return
+	}
+
+	// Fallback (should not happen if isImportedBasicType was correct)
+	c.WriteZeroValueForType(fieldType)
 }
 
 func (c *GoToTSCompiler) writeNamedTypeZeroValue(named *types.Named) {
+	// Check if this is a wrapper type first
+	if c.analysis.IsNamedBasicType(named) {
+		// For wrapper types, use the zero value of the underlying type with type casting
+		c.WriteZeroValueForType(named.Underlying())
+		c.tsw.WriteLiterally(" as ")
+		c.WriteGoType(named, GoTypeContextGeneral)
+		return
+	}
+
 	// Check if underlying type is an interface
 	if _, isInterface := named.Underlying().(*types.Interface); isInterface {
 		c.tsw.WriteLiterally("null")
@@ -260,6 +274,15 @@ func (c *GoToTSCompiler) writeNamedTypeZeroValue(named *types.Named) {
 }
 
 func (c *GoToTSCompiler) writeTypeAliasZeroValue(alias *types.Alias, astType ast.Expr) {
+	// Check if this is a wrapper type first
+	if c.analysis.IsNamedBasicType(alias) {
+		// For wrapper types, use the zero value of the underlying type with type casting
+		c.WriteZeroValueForType(alias.Underlying())
+		c.tsw.WriteLiterally(" as ")
+		c.WriteGoType(alias, GoTypeContextGeneral)
+		return
+	}
+
 	// Check if underlying type is an interface
 	if _, isInterface := alias.Underlying().(*types.Interface); isInterface {
 		c.tsw.WriteLiterally("null")

package/compiler/stmt-assign.go

@@ -117,6 +117,8 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 					}
 				}
 				c.tsw.WriteLiterally("] = ")
+				// Add await if the call is async
+				c.writeAsyncCallIfNeeded(callExpr)
 				c.WriteValueExpr(callExpr)
 				c.tsw.WriteLine("")
 				return nil
@@ -165,6 +167,8 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 
 			// Write a temporary variable to hold the function call result
 			c.tsw.WriteLiterally("  const _tmp = ")
+			// Add await if the call is async
+			c.writeAsyncCallIfNeeded(callExpr)
 			if err := c.WriteValueExpr(callExpr); err != nil {
 				return fmt.Errorf("failed to write RHS call expression in assignment: %w", err)
 			}
@@ -287,10 +291,9 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 		}
 		c.tsw.WriteLiterally("] = ")
 
-		// Write the right-hand side (the function call)
-		if err := c.WriteValueExpr(callExpr); err != nil {
-			return fmt.Errorf("failed to write RHS call expression in assignment: %w", err)
-		}
+		// Add await if the call is async
+		c.writeAsyncCallIfNeeded(callExpr)
+		c.WriteValueExpr(callExpr)
 
 		c.tsw.WriteLine("")
 		return nil

package/compiler/stmt-select.go

@@ -8,6 +8,18 @@ import (
 	"github.com/pkg/errors"
 )
 
+// caseEndsWithReturn checks if a case body ends with a return statement
+func (c *GoToTSCompiler) caseEndsWithReturn(body []ast.Stmt) bool {
+	if len(body) == 0 {
+		return false
+	}
+
+	// Check if the last statement is a return statement
+	lastStmt := body[len(body)-1]
+	_, isReturn := lastStmt.(*ast.ReturnStmt)
+	return isReturn
+}
+
 // WriteStmtSelect translates a Go `select` statement into an asynchronous
 // TypeScript operation using the `$.selectStatement` runtime helper.
 // Go's `select` provides non-deterministic choice over channel operations.
@@ -38,8 +50,29 @@ func (c *GoToTSCompiler) WriteStmtSelect(exp *ast.SelectStmt) error {
 	// Variable to track whether we have a default case
 	hasDefault := false
 
+	// Analyze if all cases end with return statements
+	allCasesReturn := true
+	for _, stmt := range exp.Body.List {
+		if commClause, ok := stmt.(*ast.CommClause); ok {
+			if commClause.Comm == nil {
+				// Default case - check if it ends with return
+				if !c.caseEndsWithReturn(commClause.Body) {
+					allCasesReturn = false
+				}
+			} else {
+				// Regular case - check if it ends with return
+				if !c.caseEndsWithReturn(commClause.Body) {
+					allCasesReturn = false
+				}
+			}
+		}
+	}
+
+	// Generate unique variable names for this select statement
+	selectID := fmt.Sprintf("%d", exp.Pos()) // Use AST position for uniqueness
+
 	// Start the selectStatement call and the array literal
-	c.tsw.WriteLiterally("await $.selectStatement(")
+	c.tsw.WriteLiterallyf("const [_selectHasReturn%s, _selectValue%s] = await $.selectStatement(", selectID, selectID)
 	c.tsw.WriteLine("[") // Put bracket on new line
 	c.tsw.Indent(1)
 
@@ -207,5 +240,23 @@ func (c *GoToTSCompiler) WriteStmtSelect(exp *ast.SelectStmt) error {
 	c.tsw.WriteLiterally(")")
 	c.tsw.WriteLine("")
 
+	// Add code to handle the return value from selectStatement
+	c.tsw.WriteLiterallyf("if (_selectHasReturn%s) {", selectID)
+	c.tsw.WriteLine("")
+	c.tsw.Indent(1)
+	c.tsw.WriteLiterallyf("return _selectValue%s!", selectID)
+	c.tsw.WriteLine("")
+	c.tsw.Indent(-1)
+	c.tsw.WriteLine("}")
+
+	// If all cases return, add a TypeScript-satisfying fallback return
+	if allCasesReturn {
+		c.tsw.WriteLine("// All cases should return, this fallback should never execute")
+		c.tsw.WriteLine("throw new Error('Unexpected: select statement did not return when all cases should return')")
+	} else {
+		c.tsw.WriteLiterallyf("// If _selectHasReturn%s is false, continue execution", selectID)
+		c.tsw.WriteLine("")
+	}
+
 	return nil
 }

package/compiler/stmt.go

@@ -451,13 +451,29 @@ func (c *GoToTSCompiler) WriteStmtIf(exp *ast.IfStmt) error {
 		if c.analysis.HasVariableShadowing(exp) {
 			shadowingInfo := c.analysis.GetShadowingInfo(exp)
 			if shadowingInfo != nil {
-				// Create temporary variables BEFORE the block to avoid temporal dead zone
+				// Handle variable shadowing by creating temporary variables
 				for varName, tempVarName := range shadowingInfo.TempVariables {
-					// Declare: const _temp_x = x (using the outer scope value)
 					c.tsw.WriteLiterally("const ")
 					c.tsw.WriteLiterally(tempVarName)
 					c.tsw.WriteLiterally(" = ")
-					c.tsw.WriteLiterally(varName)
+
+					// Check if this is a built-in function and handle it directly
+					if c.isBuiltinFunction(varName) {
+						c.tsw.WriteLiterally("$.")
+						c.tsw.WriteLiterally(varName)
+					} else {
+						// Get the original object for this shadowed variable
+						if originalObj, exists := shadowingInfo.ShadowedVariables[varName]; exists {
+							// Create an identifier with the original name and use WriteValueExpr to properly resolve it
+							originalIdent := &ast.Ident{Name: varName}
+							// Set the identifier in the Uses map so WriteValueExpr can find the object
+							c.pkg.TypesInfo.Uses[originalIdent] = originalObj
+							c.WriteValueExpr(originalIdent)
+						} else {
+							// Fallback to literal name if no object found (shouldn't happen in normal cases)
+							c.tsw.WriteLiterally(varName)
+						}
+					}
 					c.tsw.WriteLine("")
 				}
 			}
@@ -943,11 +959,27 @@ func (c *GoToTSCompiler) WriteStmtLabeled(stmt *ast.LabeledStmt) error {
 func (c *GoToTSCompiler) writeShadowedAssignment(stmt *ast.AssignStmt, shadowingInfo *ShadowingInfo) error {
 	// First, create temporary variables for the shadowed variables
 	for varName, tempVarName := range shadowingInfo.TempVariables {
-		// Declare: const _temp_x = x (using the outer scope value)
 		c.tsw.WriteLiterally("const ")
 		c.tsw.WriteLiterally(tempVarName)
 		c.tsw.WriteLiterally(" = ")
-		c.tsw.WriteLiterally(varName)
+
+		// Check if this is a built-in function and handle it directly
+		if c.isBuiltinFunction(varName) {
+			c.tsw.WriteLiterally("$.")
+			c.tsw.WriteLiterally(varName)
+		} else {
+			// Get the original object for this shadowed variable
+			if originalObj, exists := shadowingInfo.ShadowedVariables[varName]; exists {
+				// Create an identifier with the original name and use WriteValueExpr to properly resolve it
+				originalIdent := &ast.Ident{Name: varName}
+				// Set the identifier in the Uses map so WriteValueExpr can find the object
+				c.pkg.TypesInfo.Uses[originalIdent] = originalObj
+				c.WriteValueExpr(originalIdent)
+			} else {
+				// Fallback to literal name if no object found (shouldn't happen in normal cases)
+				c.tsw.WriteLiterally(varName)
+			}
+		}
 		c.tsw.WriteLine("")
 	}
 
@@ -1047,6 +1079,10 @@ func (c *GoToTSCompiler) writeShadowedRHSExpression(expr ast.Expr, shadowingInfo
 		if err := c.writeShadowedRHSExpression(e.Fun, shadowingInfo); err != nil {
 			return err
 		}
+
+		// Add non-null assertion for function calls (same logic as WriteCallExpr)
+		c.addNonNullAssertion(e.Fun)
+
 		c.tsw.WriteLiterally("(")
 		for i, arg := range e.Args {
 			if i > 0 {
@@ -1109,3 +1145,25 @@ func (c *GoToTSCompiler) writeShadowedRHSExpression(expr ast.Expr, shadowingInfo
 		return c.WriteValueExpr(expr)
 	}
 }
+
+// isBuiltinFunction checks if the given name is a Go built-in function
+func (c *GoToTSCompiler) isBuiltinFunction(name string) bool {
+	builtins := 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,
+	}
+	return builtins[name]
+}

package/compiler/type.go

@@ -278,7 +278,7 @@ func (c *GoToTSCompiler) WriteNamedType(t *types.Named) {
 				// Write the qualified name: importAlias.TypeName
 				c.tsw.WriteLiterally(importAlias)
 				c.tsw.WriteLiterally(".")
-				c.tsw.WriteLiterally(t.Obj().Name())
+				c.tsw.WriteLiterally(c.sanitizeIdentifier(t.Obj().Name()))
 
 				// For generic types, include type arguments
 				if t.TypeArgs() != nil && t.TypeArgs().Len() > 0 {
@@ -306,7 +306,7 @@ func (c *GoToTSCompiler) WriteNamedType(t *types.Named) {
 				// Write the qualified name: importAlias.TypeName
 				c.tsw.WriteLiterally(importAlias)
 				c.tsw.WriteLiterally(".")
-				c.tsw.WriteLiterally(t.Obj().Name())
+				c.tsw.WriteLiterally(c.sanitizeIdentifier(t.Obj().Name()))
 
 				// For generic types, include type arguments
 				if t.TypeArgs() != nil && t.TypeArgs().Len() > 0 {
@@ -330,7 +330,7 @@ func (c *GoToTSCompiler) WriteNamedType(t *types.Named) {
 	}
 
 	// Use Obj().Name() for the original defined name (local types or unmatched imports)
-	c.tsw.WriteLiterally(t.Obj().Name())
+	c.tsw.WriteLiterally(c.sanitizeIdentifier(t.Obj().Name()))
 
 	// For generic types, include type arguments
 	if t.TypeArgs() != nil && t.TypeArgs().Len() > 0 {
@@ -656,6 +656,14 @@ func (c *GoToTSCompiler) writeInterfaceStructure(iface *types.Interface, astNode
 			// Return type
 			c.tsw.WriteLiterally(": ")
 			results := sig.Results()
+
+			// Determine if this interface method should be async based on implementations
+			isMethodAsync := c.analysis.IsInterfaceMethodAsync(iface, method.Name())
+
+			if isMethodAsync {
+				c.tsw.WriteLiterally("Promise<")
+			}
+
 			if results.Len() == 0 {
 				c.tsw.WriteLiterally("void")
 			} else if results.Len() == 1 {
@@ -688,6 +696,11 @@ func (c *GoToTSCompiler) writeInterfaceStructure(iface *types.Interface, astNode
 				}
 				c.tsw.WriteLiterally("]")
 			}
+
+			if isMethodAsync {
+				c.tsw.WriteLiterally(">")
+			}
+
 			c.tsw.WriteLine("") // newline for each method
 		}
 		c.tsw.Indent(-1)