goscript 0.0.44 → 0.0.47

package/compiler/analysis.go

@@ -61,6 +61,7 @@ type FunctionTypeInfo struct {
 // FunctionInfo consolidates function-related tracking data.
 type FunctionInfo struct {
 	IsAsync      bool
+	ReceiverUsed bool
 	NamedReturns []string
 }
 
@@ -195,6 +196,17 @@ func (a *Analysis) IsAsyncFunc(obj types.Object) bool {
 	return funcInfo.IsAsync
 }
 
+func (a *Analysis) IsReceiverUsed(obj types.Object) bool {
+	if obj == nil {
+		return false
+	}
+	funcInfo := a.FunctionData[obj]
+	if funcInfo == nil {
+		return false
+	}
+	return funcInfo.ReceiverUsed
+}
+
 // IsFuncLitAsync checks if a function literal is async based on our analysis.
 func (a *Analysis) IsFuncLitAsync(funcLit *ast.FuncLit) bool {
 	if funcLit == nil {
@@ -488,6 +500,24 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 							// Add the receiver variable to the VariableUsage map
 							// to ensure it is properly analyzed for varRefing
 							v.getOrCreateUsageInfo(v.currentReceiver)
+
+							// Check if receiver is used in method body
+							receiverUsed := false
+							if n.Body != nil {
+								if v.isInterfaceMethod(n) {
+									receiverUsed = true
+								} else {
+									receiverUsed = v.containsReceiverUsage(n.Body, vr)
+								}
+							}
+
+							// Update function data with receiver usage info
+							if obj := v.pkg.TypesInfo.ObjectOf(n.Name); obj != nil {
+								if v.analysis.FunctionData[obj] == nil {
+									v.analysis.FunctionData[obj] = &FunctionInfo{}
+								}
+								v.analysis.FunctionData[obj].ReceiverUsed = receiverUsed
+							}
 						}
 					}
 				}
@@ -945,6 +975,74 @@ func (v *analysisVisitor) containsDefer(block *ast.BlockStmt) bool {
 	return hasDefer
 }
 
+// containsReceiverUsage checks if a method body contains any references to the receiver variable.
+func (v *analysisVisitor) containsReceiverUsage(node ast.Node, receiver *types.Var) bool {
+	if receiver == nil {
+		return false
+	}
+
+	var hasReceiverUsage bool
+
+	ast.Inspect(node, func(n ast.Node) bool {
+		if n == nil {
+			return true
+		}
+
+		switch expr := n.(type) {
+		case *ast.Ident:
+			// Check if this identifier refers to the receiver variable
+			if obj := v.pkg.TypesInfo.Uses[expr]; obj != nil && obj == receiver {
+				hasReceiverUsage = true
+				return false
+			}
+		case *ast.SelectorExpr:
+			// Check if selector expression uses the receiver (e.g., m.Field, m.Method())
+			if ident, ok := expr.X.(*ast.Ident); ok {
+				if obj := v.pkg.TypesInfo.Uses[ident]; obj != nil && obj == receiver {
+					hasReceiverUsage = true
+					return false
+				}
+			}
+		}
+
+		return true
+	})
+
+	return hasReceiverUsage
+}
+
+func (v *analysisVisitor) isInterfaceMethod(decl *ast.FuncDecl) bool {
+	if decl.Recv == nil {
+		return false
+	}
+
+	// Get the method name
+	methodName := decl.Name.Name
+
+	// Get the receiver variable
+	var receiver *types.Var
+	if len(decl.Recv.List) > 0 && len(decl.Recv.List[0].Names) > 0 {
+		if ident := decl.Recv.List[0].Names[0]; ident != nil && ident.Name != "_" {
+			if def := v.pkg.TypesInfo.Defs[ident]; def != nil {
+				if vr, ok := def.(*types.Var); ok {
+					receiver = vr
+				}
+			}
+		}
+	}
+
+	return v.couldImplementInterfaceMethod(methodName, receiver)
+}
+
+func (v *analysisVisitor) couldImplementInterfaceMethod(methodName string, receiver *types.Var) bool {
+	// Check if method is exported (interface methods must be exported)
+	if !ast.IsExported(methodName) {
+		return false
+	}
+
+	return false
+}
+
 // AnalyzeFile analyzes a Go source file AST and populates the Analysis struct with information
 // that will be used during code generation to properly handle pointers, variables that need varRefing, etc.
 func AnalyzeFile(file *ast.File, pkg *packages.Package, analysis *Analysis, cmap ast.CommentMap) {

package/compiler/compiler.go

@@ -374,68 +374,6 @@ func (c *PackageCompiler) generateIndexFile(compiledFiles []string) error {
 	}
 	defer indexFile.Close() //nolint:errcheck
 
-	// Collect exported symbols from all files in the package
-	var exportedSymbols []string
-
-	// Iterate through all syntax files to find exported symbols
-	for i, syntax := range c.pkg.Syntax {
-		fileName := c.pkg.CompiledGoFiles[i]
-		baseFileName := filepath.Base(fileName)
-		gsFileName := strings.TrimSuffix(baseFileName, ".go") + ".gs"
-
-		// Only include this file if it was compiled (in our compiledFiles list)
-		fileWasCompiled := false
-		for _, compiledFile := range compiledFiles {
-			if compiledFile == gsFileName {
-				fileWasCompiled = true
-				break
-			}
-		}
-		if !fileWasCompiled {
-			continue
-		}
-
-		// Analyze declarations in this file to find exported symbols
-		for _, decl := range syntax.Decls {
-			switch d := decl.(type) {
-			case *ast.FuncDecl:
-				// Only include top-level functions (not methods)
-				if d.Recv == nil && d.Name.IsExported() {
-					exportedSymbols = append(exportedSymbols, d.Name.Name)
-				}
-			case *ast.GenDecl:
-				for _, spec := range d.Specs {
-					switch s := spec.(type) {
-					case *ast.TypeSpec:
-						if s.Name.IsExported() {
-							exportedSymbols = append(exportedSymbols, s.Name.Name)
-						}
-					case *ast.ValueSpec:
-						for _, name := range s.Names {
-							if name.IsExported() {
-								exportedSymbols = append(exportedSymbols, name.Name)
-							}
-						}
-					}
-				}
-			}
-		}
-	}
-
-	// Remove duplicates and sort
-	symbolMap := make(map[string]bool)
-	for _, symbol := range exportedSymbols {
-		symbolMap[symbol] = true
-	}
-
-	var uniqueSymbols []string
-	for symbol := range symbolMap {
-		uniqueSymbols = append(uniqueSymbols, symbol)
-	}
-
-	// Sort for consistent output
-	sort.Strings(uniqueSymbols)
-
 	// Write selective re-exports for each compiled file
 	for _, fileName := range compiledFiles {
 		// Check if this is a protobuf file
@@ -452,7 +390,8 @@ func (c *PackageCompiler) generateIndexFile(compiledFiles []string) error {
 		}
 
 		// Find which symbols this file exports
-		var fileSymbols []string
+		var valueSymbols []string
+		var typeSymbols []string
 
 		// Find the corresponding syntax file
 		for i, syntax := range c.pkg.Syntax {
@@ -469,19 +408,21 @@ func (c *PackageCompiler) generateIndexFile(compiledFiles []string) error {
 				switch d := decl.(type) {
 				case *ast.FuncDecl:
 					if d.Recv == nil && d.Name.IsExported() {
-						fileSymbols = append(fileSymbols, d.Name.Name)
+						valueSymbols = append(valueSymbols, d.Name.Name)
 					}
 				case *ast.GenDecl:
 					for _, spec := range d.Specs {
 						switch s := spec.(type) {
 						case *ast.TypeSpec:
 							if s.Name.IsExported() {
-								fileSymbols = append(fileSymbols, s.Name.Name)
+								// All type declarations (interfaces, structs, type definitions, type aliases)
+								// become TypeScript types and must be exported with "export type"
+								typeSymbols = append(typeSymbols, s.Name.Name)
 							}
 						case *ast.ValueSpec:
 							for _, name := range s.Names {
 								if name.IsExported() {
-									fileSymbols = append(fileSymbols, name.Name)
+									valueSymbols = append(valueSymbols, name.Name)
 								}
 							}
 						}
@@ -491,11 +432,20 @@ func (c *PackageCompiler) generateIndexFile(compiledFiles []string) error {
 			break
 		}
 
-		// Write selective export if this file has exported symbols
-		if len(fileSymbols) > 0 {
-			sort.Strings(fileSymbols)
+		// Write exports if this file has exported symbols
+		if len(valueSymbols) > 0 {
+			sort.Strings(valueSymbols)
 			exportLine := fmt.Sprintf("export { %s } from \"./%s.js\"\n",
-				strings.Join(fileSymbols, ", "), fileName)
+				strings.Join(valueSymbols, ", "), fileName)
+			if _, err := indexFile.WriteString(exportLine); err != nil {
+				return err
+			}
+		}
+
+		if len(typeSymbols) > 0 {
+			sort.Strings(typeSymbols)
+			exportLine := fmt.Sprintf("export type { %s } from \"./%s.js\"\n",
+				strings.Join(typeSymbols, ", "), fileName)
 			if _, err := indexFile.WriteString(exportLine); err != nil {
 				return err
 			}

package/compiler/decl.go

@@ -142,6 +142,49 @@ func (c *GoToTSCompiler) WriteFuncDeclAsFunction(decl *ast.FuncDecl) error {
 //
 // This function assumes it is called only for `FuncDecl` nodes that are methods.
 func (c *GoToTSCompiler) WriteFuncDeclAsMethod(decl *ast.FuncDecl) error {
+	_, err := c.writeMethodSignature(decl)
+	if err != nil {
+		return err
+	}
+
+	return c.writeMethodBodyWithReceiverBinding(decl, "this")
+}
+
+// writeNamedReturnDeclarations generates TypeScript variable declarations for named return parameters.
+// It declares each named return variable with its appropriate type and zero value.
+func (c *GoToTSCompiler) writeNamedReturnDeclarations(results *ast.FieldList) error {
+	if results == nil {
+		return nil
+	}
+
+	for _, field := range results.List {
+		for _, name := range field.Names {
+			c.tsw.WriteLiterallyf("let %s: ", c.sanitizeIdentifier(name.Name))
+			c.WriteTypeExpr(field.Type)
+			c.tsw.WriteLiterally(" = ")
+			c.WriteZeroValueForType(c.pkg.TypesInfo.TypeOf(field.Type))
+			c.tsw.WriteLine("")
+		}
+	}
+	return nil
+}
+
+// hasNamedReturns checks if a function type has any named return parameters.
+func (c *GoToTSCompiler) hasNamedReturns(results *ast.FieldList) bool {
+	if results == nil {
+		return false
+	}
+
+	for _, field := range results.List {
+		if len(field.Names) > 0 {
+			return true
+		}
+	}
+	return false
+}
+
+// writeMethodSignature writes the TypeScript method signature including async, public modifiers, name, parameters, and return type
+func (c *GoToTSCompiler) writeMethodSignature(decl *ast.FuncDecl) (bool, error) {
 	if decl.Doc != nil {
 		c.WriteDoc(decl.Doc)
 	}
@@ -162,11 +205,10 @@ func (c *GoToTSCompiler) WriteFuncDeclAsMethod(decl *ast.FuncDecl) error {
 
 	// Keep original Go casing for method names
 	if err := c.WriteValueExpr(decl.Name); err != nil { // Method name is a value identifier
-		return err
+		return isAsync, err
 	}
 
 	// Write signature (parameters and return type)
-	// We adapt the logic from WriteFuncType here, but without the 'function' keyword
 	funcType := decl.Type
 	c.tsw.WriteLiterally("(")
 	if funcType.Params != nil {
@@ -208,23 +250,37 @@ func (c *GoToTSCompiler) WriteFuncDeclAsMethod(decl *ast.FuncDecl) error {
 	}
 
 	c.tsw.WriteLiterally(" ")
+	return isAsync, nil
+}
 
-	// Bind receiver name to this
+// writeMethodBodyWithReceiverBinding writes the method body with optional receiver binding
+// receiverTarget should be "this" for struct methods or "this._value" for named type methods
+func (c *GoToTSCompiler) writeMethodBodyWithReceiverBinding(decl *ast.FuncDecl, receiverTarget string) error {
+	// Bind receiver name conditionally
 	if recvField := decl.Recv.List[0]; len(recvField.Names) > 0 {
 		recvName := recvField.Names[0].Name
 		if recvName != "_" {
+			// Check if receiver is actually used
+			var needsReceiverBinding bool
+			if obj := c.pkg.TypesInfo.Defs[decl.Name]; obj != nil {
+				needsReceiverBinding = c.analysis.IsReceiverUsed(obj)
+			}
+
 			c.tsw.WriteLine("{")
 			c.tsw.Indent(1)
-			// Sanitize the receiver name to avoid conflicts with TypeScript reserved words
-			sanitizedRecvName := c.sanitizeIdentifier(recvName)
-			c.tsw.WriteLinef("const %s = this", sanitizedRecvName)
+
+			if needsReceiverBinding {
+				// Sanitize the receiver name to avoid conflicts with TypeScript reserved words
+				sanitizedRecvName := c.sanitizeIdentifier(recvName)
+				c.tsw.WriteLinef("const %s = %s", sanitizedRecvName, receiverTarget)
+			}
 
 			// Add using statement if needed
 			if c.analysis.NeedsDefer(decl.Body) {
 				if c.analysis.IsInAsyncFunction(decl) {
 					c.tsw.WriteLine("await using __defer = new $.AsyncDisposableStack();")
 				} else {
-					c.tsw.WriteLine("using cleanup = new $.DisposableStack();")
+					c.tsw.WriteLine("using __defer = new $.DisposableStack();")
 				}
 			}
 
@@ -252,36 +308,3 @@ func (c *GoToTSCompiler) WriteFuncDeclAsMethod(decl *ast.FuncDecl) error {
 
 	return nil
 }
-
-// writeNamedReturnDeclarations generates TypeScript variable declarations for named return parameters.
-// It declares each named return variable with its appropriate type and zero value.
-func (c *GoToTSCompiler) writeNamedReturnDeclarations(results *ast.FieldList) error {
-	if results == nil {
-		return nil
-	}
-
-	for _, field := range results.List {
-		for _, name := range field.Names {
-			c.tsw.WriteLiterallyf("let %s: ", c.sanitizeIdentifier(name.Name))
-			c.WriteTypeExpr(field.Type)
-			c.tsw.WriteLiterally(" = ")
-			c.WriteZeroValueForType(c.pkg.TypesInfo.TypeOf(field.Type))
-			c.tsw.WriteLine("")
-		}
-	}
-	return nil
-}
-
-// hasNamedReturns checks if a function type has any named return parameters.
-func (c *GoToTSCompiler) hasNamedReturns(results *ast.FieldList) bool {
-	if results == nil {
-		return false
-	}
-
-	for _, field := range results.List {
-		if len(field.Names) > 0 {
-			return true
-		}
-	}
-	return false
-}

package/compiler/expr-call-async.go

@@ -0,0 +1,101 @@
+package compiler
+
+import (
+	"go/ast"
+	"go/types"
+	"strings"
+)
+
+// writeAsyncCall writes the await prefix for async function calls
+func (c *GoToTSCompiler) writeAsyncCall(exp *ast.CallExpr, funIdent *ast.Ident) bool {
+	if funIdent == nil {
+		return false
+	}
+
+	// Check if this is an async function call
+	if obj := c.pkg.TypesInfo.Uses[funIdent]; obj != nil && c.analysis.IsAsyncFunc(obj) {
+		c.tsw.WriteLiterally("await ")
+		return true
+	}
+
+	return false
+}
+
+// writeAsyncMethodCall writes the await prefix for async method calls
+func (c *GoToTSCompiler) writeAsyncMethodCall(exp *ast.CallExpr) bool {
+	selExpr, ok := exp.Fun.(*ast.SelectorExpr)
+	if !ok {
+		return false
+	}
+
+	// Check if this is a method call on a variable (e.g., mu.Lock())
+	ident, ok := selExpr.X.(*ast.Ident)
+	if !ok {
+		return false
+	}
+
+	// Get the type of the receiver
+	obj := c.pkg.TypesInfo.Uses[ident]
+	if obj == nil {
+		return false
+	}
+
+	varObj, ok := obj.(*types.Var)
+	if !ok {
+		return false
+	}
+
+	// Get the type name and package
+	namedType, ok := varObj.Type().(*types.Named)
+	if !ok {
+		return false
+	}
+
+	typeName := namedType.Obj().Name()
+	methodName := selExpr.Sel.Name
+
+	// Check if the type is from an imported package
+	typePkg := namedType.Obj().Pkg()
+	if typePkg == nil || typePkg == c.pkg.Types {
+		return false
+	}
+
+	// Use the actual package name from the type information
+	pkgName := typePkg.Name()
+
+	// Check if this method is async based on metadata
+	if c.analysis.IsMethodAsync(pkgName, typeName, methodName) {
+		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.pkg.TypesInfo.Uses[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 _, 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

@@ -0,0 +1,133 @@
+package compiler
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+
+	"github.com/pkg/errors"
+)
+
+// 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("console.log")
+		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 "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
+	for i, arg := range exp.Args[1:] {
+		if i > 0 || len(exp.Args) > 1 {
+			c.tsw.WriteLiterally(", ")
+		}
+
+		// Special case: append([]byte, string...) should convert string to bytes
+		if exp.Ellipsis != token.NoPos && i == 0 { // This is the first element after slice and has ellipsis
+			// 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
+				}
+			}
+		}
+
+		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
+}