goscript 0.0.45 → 0.0.48

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,8 +250,13 @@ func (c *GoToTSCompiler) WriteFuncDeclAsMethod(decl *ast.FuncDecl) error {
 	}
 
 	c.tsw.WriteLiterally(" ")
+	return isAsync, nil
+}
 
-	// Bind receiver name to this conditionally
+// 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 != "_" {
@@ -225,7 +272,7 @@ func (c *GoToTSCompiler) WriteFuncDeclAsMethod(decl *ast.FuncDecl) error {
 			if needsReceiverBinding {
 				// Sanitize the receiver name to avoid conflicts with TypeScript reserved words
 				sanitizedRecvName := c.sanitizeIdentifier(recvName)
-				c.tsw.WriteLinef("const %s = this", sanitizedRecvName)
+				c.tsw.WriteLinef("const %s = %s", sanitizedRecvName, receiverTarget)
 			}
 
 			// Add using statement if needed
@@ -233,7 +280,7 @@ func (c *GoToTSCompiler) WriteFuncDeclAsMethod(decl *ast.FuncDecl) error {
 				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();")
 				}
 			}
 
@@ -261,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
+}

package/compiler/expr-call-helpers.go

@@ -0,0 +1,138 @@
+package compiler
+
+import (
+	"go/ast"
+	"go/types"
+
+	"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)
+}
+
+// writeSliceCreationForType handles slice creation with special handling for byte slices
+func (c *GoToTSCompiler) writeSliceCreationForType(lengthArg, capacityArg interface{}, isByteSlice bool) error {
+	hasCapacity := capacityArg != nil
+
+	if isByteSlice && !hasCapacity {
+		// make([]byte, len) - capacity equals length, use Uint8Array
+		c.tsw.WriteLiterally("new Uint8Array(")
+		if err := c.writeExprOrDefault(lengthArg, "0"); err != nil {
+			return err
+		}
+		c.tsw.WriteLiterally(")")
+		return nil
+	}
+
+	// Use $.makeSlice for all other cases
+	if isByteSlice {
+		c.tsw.WriteLiterally("$.makeSlice<number>(")
+	} else {
+		return errors.New("writeSliceCreationForType called for non-byte slice without element type")
+	}
+
+	if err := c.writeExprOrDefault(lengthArg, "0"); err != nil {
+		return err
+	}
+
+	if hasCapacity {
+		c.tsw.WriteLiterally(", ")
+		if err := c.writeExprOrDefault(capacityArg, "0"); err != nil {
+			return err
+		}
+	}
+
+	if isByteSlice {
+		c.tsw.WriteLiterally(", 'byte')")
+	}
+
+	return nil
+}
+
+// writeGenericSliceCreation handles the creation of generic slices with proper type hints
+func (c *GoToTSCompiler) writeGenericSliceCreation(elemType types.Type, lengthArg, capacityArg interface{}) error {
+	hasCapacity := capacityArg != nil
+
+	c.tsw.WriteLiterally("$.makeSlice<")
+	c.WriteGoType(elemType, GoTypeContextGeneral)
+	c.tsw.WriteLiterally(">(")
+
+	if err := c.writeExprOrDefault(lengthArg, "0"); err != nil {
+		return err
+	}
+
+	if hasCapacity {
+		c.tsw.WriteLiterally(", ")
+		if err := c.writeExprOrDefault(capacityArg, "0"); err != nil {
+			return err
+		}
+	}
+
+	// Add type hint for proper zero value initialization
+	c.writeSliceTypeHint(elemType, hasCapacity)
+	c.tsw.WriteLiterally(")")
+	return nil
+}
+
+// writeSliceTypeHint writes the type hint parameter for makeSlice calls
+func (c *GoToTSCompiler) writeSliceTypeHint(elemType types.Type, hasCapacity bool) {
+	typeHint := c.getTypeHintForSliceElement(elemType)
+	if typeHint != "" {
+		if !hasCapacity {
+			c.tsw.WriteLiterally(", undefined")
+		}
+		c.tsw.WriteLiterally(", '")
+		c.tsw.WriteLiterally(typeHint)
+		c.tsw.WriteLiterally("'")
+	}
+}
+
+// writeExprOrDefault writes an expression if it's not nil, otherwise writes a default value
+func (c *GoToTSCompiler) writeExprOrDefault(expr interface{}, defaultValue string) error {
+	if expr == nil {
+		c.tsw.WriteLiterally(defaultValue)
+		return nil
+	}
+
+	switch e := expr.(type) {
+	case string:
+		c.tsw.WriteLiterally(e)
+		return nil
+	case ast.Expr:
+		// If it's an ast.Expr, call WriteValueExpr directly
+		return c.WriteValueExpr(e)
+	default:
+		// If we can't handle the type, return an error
+		return errors.Errorf("unsupported expression type in writeExprOrDefault: %T", e)
+	}
+}