goscript 0.0.32 → 0.0.34

package/compiler/analysis.go

@@ -864,8 +864,8 @@ func AnalyzeFile(file *ast.File, pkg *packages.Package, analysis *Analysis, cmap
 				importVars: make(map[string]struct{}),
 			}
 
-			// Use the import name or path as the key
-			key := path
+			// Use the import name or package name as the key
+			key := packageNameFromGoPath(path)
 			if name != "" {
 				key = name
 			}

package/compiler/assignment.go

@@ -197,6 +197,7 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 		currentIsMapIndex := false
 		if indexExpr, ok := l.(*ast.IndexExpr); ok {
 			if tv, ok := c.pkg.TypesInfo.Types[indexExpr.X]; ok {
+				// Check if it's a concrete map type
 				if _, isMap := tv.Type.Underlying().(*types.Map); isMap {
 					currentIsMapIndex = true
 					if i == 0 {
@@ -213,6 +214,31 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 					}
 					c.tsw.WriteLiterally(", ")
 					// Value will be added after operator and RHS
+				} else if typeParam, isTypeParam := tv.Type.(*types.TypeParam); isTypeParam {
+					// Check if the type parameter is constrained to be a map type
+					constraint := typeParam.Constraint()
+					if constraint != nil {
+						underlying := constraint.Underlying()
+						if iface, isInterface := underlying.(*types.Interface); isInterface {
+							if hasMapConstraint(iface) {
+								currentIsMapIndex = true
+								if i == 0 {
+									isMapIndexLHS = true
+								}
+								// Use mapSet helper for type parameter constrained to map
+								c.tsw.WriteLiterally("$.mapSet(")
+								if err := c.WriteValueExpr(indexExpr.X); err != nil { // Map
+									return err
+								}
+								c.tsw.WriteLiterally(", ")
+								if err := c.WriteValueExpr(indexExpr.Index); err != nil { // Key
+									return err
+								}
+								c.tsw.WriteLiterally(", ")
+								// Value will be added after operator and RHS
+							}
+						}
+					}
 				}
 			}
 		}

package/compiler/builtin_test.go

@@ -1,3 +1,5 @@
+//go:build test_emit_builtin
+
 package compiler
 
 import (

package/compiler/compiler.go

@@ -892,14 +892,24 @@ func (c *GoToTSCompiler) WriteDoc(doc *ast.CommentGroup) {
 }
 
 // sanitizeIdentifier checks if an identifier is a JavaScript/TypeScript reserved word
-// and prefixes it with an underscore if it is. This prevents compilation errors
-// when Go identifiers conflict with JS/TS keywords.
+// or conflicts with built-in types, and transforms it if needed. This prevents
+// compilation errors when Go identifiers conflict with JS/TS keywords or built-ins.
 func (c *GoToTSCompiler) sanitizeIdentifier(name string) string {
 	// Don't sanitize boolean literals - they are valid in both Go and JS/TS
 	if name == "true" || name == "false" {
 		return name
 	}
 
+	// 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
+	}
+
+	if replacement, exists := builtinTypes[name]; exists {
+		return replacement
+	}
+
 	// List of JavaScript/TypeScript reserved words that could conflict
 	reservedWords := map[string]bool{
 		"abstract":    true,

package/compiler/compiler_test.go

@@ -1,7 +1,6 @@
 package compiler_test
 
 import (
-	"context"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -12,9 +11,7 @@ import (
 	"sync/atomic"
 	"testing"
 
-	"github.com/aperturerobotics/goscript/compiler"
 	"github.com/aperturerobotics/goscript/compliance"
-	"github.com/sirupsen/logrus"
 )
 
 // NOTE: this is here instead of compliance/compliance_test.go so coverage ends up in this package.
@@ -140,53 +137,3 @@ func getParentGoModulePath() (string, error) {
 	}
 	return strings.TrimSpace(string(output)), nil
 }
-
-func TestUnsafePackageCompilation(t *testing.T) {
-	// Create a temporary directory for the test output
-	tempDir, err := os.MkdirTemp("", "goscript-test-unsafe")
-	if err != nil {
-		t.Fatalf("Failed to create temp dir: %v", err)
-	}
-	defer os.RemoveAll(tempDir)
-
-	// Setup logger
-	log := logrus.New()
-	log.SetLevel(logrus.DebugLevel)
-	le := logrus.NewEntry(log)
-
-	// Test with AllDependencies=true and DisableEmitBuiltin=false to ensure handwritten packages are copied
-	config := &compiler.Config{
-		OutputPath:         tempDir,
-		AllDependencies:    true,
-		DisableEmitBuiltin: false, // This ensures handwritten packages are copied to output
-	}
-
-	comp, err := compiler.NewCompiler(config, le, nil)
-	if err != nil {
-		t.Fatalf("Failed to create compiler: %v", err)
-	}
-
-	// Try to compile a package that has dependencies that import unsafe
-	// We'll use "sync/atomic" which imports unsafe but doesn't have a handwritten equivalent
-	result, err := comp.CompilePackages(context.Background(), "sync/atomic")
-	// This should now succeed since we have a handwritten unsafe package
-	if err != nil {
-		t.Fatalf("Expected compilation to succeed with handwritten unsafe package, but it failed: %v", err)
-	}
-
-	// Verify that the unsafe package was copied (not compiled) since it has a handwritten equivalent
-	if !slices.Contains(result.CopiedPackages, "unsafe") {
-		t.Errorf("Expected unsafe package to be in CopiedPackages, but it wasn't. CopiedPackages: %v", result.CopiedPackages)
-	}
-
-	// Verify that sync/atomic was compiled
-	if !slices.Contains(result.CompiledPackages, "sync/atomic") {
-		t.Errorf("Expected sync/atomic package to be in CompiledPackages, but it wasn't. CompiledPackages: %v", result.CompiledPackages)
-	}
-
-	// Check that the unsafe package directory exists in the output
-	unsafePath := filepath.Join(tempDir, "@goscript/unsafe")
-	if _, err := os.Stat(unsafePath); os.IsNotExist(err) {
-		t.Errorf("unsafe package directory was not created at %s", unsafePath)
-	}
-}

package/compiler/expr-call.go

@@ -437,6 +437,222 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 					}
 				}
 			}
+			// Handle instantiated generic types: make(GenericType[TypeArg], ...)
+			// This handles cases like: make(Ints[int64]) where Ints[T] is a generic type
+			if indexExpr, ok := exp.Args[0].(*ast.IndexExpr); ok {
+				// Get the type information for the instantiated generic type
+				if typ := c.pkg.TypesInfo.TypeOf(indexExpr); typ != nil {
+					// Check the underlying type of the instantiated generic type
+					underlying := typ.Underlying()
+
+					// Handle instantiated generic map types: make(GenericMap[K, V])
+					if mapType, isMap := underlying.(*types.Map); isMap {
+						c.tsw.WriteLiterally("$.makeMap<")
+						c.WriteGoType(mapType.Key(), GoTypeContextGeneral) // Write the key type
+						c.tsw.WriteLiterally(", ")
+						c.WriteGoType(mapType.Elem(), GoTypeContextGeneral) // Write the value type
+						c.tsw.WriteLiterally(">()")
+						return nil // Handled make for instantiated generic map type
+					}
+
+					// Handle instantiated generic slice types: make(GenericSlice[T], len, cap)
+					if sliceType, isSlice := underlying.(*types.Slice); isSlice {
+						goElemType := sliceType.Elem()
+
+						// Check if it's an instantiated generic type with []byte underlying type
+						if basicElem, isBasic := goElemType.(*types.Basic); isBasic && basicElem.Kind() == types.Uint8 {
+							c.tsw.WriteLiterally("new Uint8Array(")
+							if len(exp.Args) >= 2 {
+								if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
+									return err
+								}
+								// Capacity argument for make([]byte, len, cap) is ignored for new Uint8Array(len)
+							} else {
+								// If no length is provided, default to 0
+								c.tsw.WriteLiterally("0")
+							}
+							c.tsw.WriteLiterally(")")
+							return nil // Handled make for instantiated generic []byte type
+						}
+
+						// Handle other instantiated generic slice types
+						c.tsw.WriteLiterally("$.makeSlice<")
+						c.WriteGoType(goElemType, GoTypeContextGeneral) // Write the element type
+						c.tsw.WriteLiterally(">(")
+
+						if len(exp.Args) >= 2 {
+							if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
+								return err
+							}
+							if len(exp.Args) == 3 {
+								c.tsw.WriteLiterally(", ")
+								if err := c.WriteValueExpr(exp.Args[2]); err != nil { // Capacity
+									return err
+								}
+							} else if len(exp.Args) > 3 {
+								return errors.New("makeSlice expects 2 or 3 arguments")
+							}
+						} else {
+							// If no length is provided, default to 0
+							c.tsw.WriteLiterally("0")
+						}
+						c.tsw.WriteLiterally(")")
+						return nil // Handled make for instantiated generic slice type
+					}
+
+					// Handle instantiated generic channel types: make(GenericChannel[T], bufferSize)
+					if chanType, isChan := underlying.(*types.Chan); isChan {
+						c.tsw.WriteLiterally("$.makeChannel<")
+						c.WriteGoType(chanType.Elem(), GoTypeContextGeneral)
+						c.tsw.WriteLiterally(">(")
+
+						// If buffer size is provided, add it
+						if len(exp.Args) >= 2 {
+							if err := c.WriteValueExpr(exp.Args[1]); err != nil {
+								return fmt.Errorf("failed to write buffer size in makeChannel: %w", err)
+							}
+						} else {
+							// Default to 0 (unbuffered channel)
+							c.tsw.WriteLiterally("0")
+						}
+
+						c.tsw.WriteLiterally(", ") // Add comma for zero value argument
+
+						// Write the zero value for the channel's element type
+						if chanType.Elem().String() == "struct{}" {
+							c.tsw.WriteLiterally("{}")
+						} else {
+							c.WriteZeroValueForType(chanType.Elem())
+						}
+
+						// Add direction parameter
+						c.tsw.WriteLiterally(", ")
+
+						// Determine channel direction
+						switch chanType.Dir() {
+						case types.SendRecv:
+							c.tsw.WriteLiterally("'both'")
+						case types.SendOnly:
+							c.tsw.WriteLiterally("'send'")
+						case types.RecvOnly:
+							c.tsw.WriteLiterally("'receive'")
+						default:
+							c.tsw.WriteLiterally("'both'") // Default to bidirectional
+						}
+
+						c.tsw.WriteLiterally(")")
+						return nil // Handled make for instantiated generic channel type
+					}
+				}
+			}
+			// Handle selector expressions: make(pkg.TypeName, ...)
+			// This handles cases like: make(fstest.MapFS) where fstest.MapFS is map[string]*MapFile
+			if selectorExpr, ok := exp.Args[0].(*ast.SelectorExpr); ok {
+				// Get the type information for the selector expression
+				if typ := c.pkg.TypesInfo.TypeOf(selectorExpr); typ != nil {
+					// Check the underlying type of the selector expression
+					underlying := typ.Underlying()
+
+					// Handle selector expression map types: make(pkg.MapType)
+					if mapType, isMap := underlying.(*types.Map); isMap {
+						c.tsw.WriteLiterally("$.makeMap<")
+						c.WriteGoType(mapType.Key(), GoTypeContextGeneral) // Write the key type
+						c.tsw.WriteLiterally(", ")
+						c.WriteGoType(mapType.Elem(), GoTypeContextGeneral) // Write the value type
+						c.tsw.WriteLiterally(">()")
+						return nil // Handled make for selector expression map type
+					}
+
+					// Handle selector expression slice types: make(pkg.SliceType, len, cap)
+					if sliceType, isSlice := underlying.(*types.Slice); isSlice {
+						goElemType := sliceType.Elem()
+
+						// Check if it's a selector expression with []byte underlying type
+						if basicElem, isBasic := goElemType.(*types.Basic); isBasic && basicElem.Kind() == types.Uint8 {
+							c.tsw.WriteLiterally("new Uint8Array(")
+							if len(exp.Args) >= 2 {
+								if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
+									return err
+								}
+								// Capacity argument for make([]byte, len, cap) is ignored for new Uint8Array(len)
+							} else {
+								// If no length is provided, default to 0
+								c.tsw.WriteLiterally("0")
+							}
+							c.tsw.WriteLiterally(")")
+							return nil // Handled make for selector expression []byte type
+						}
+
+						// Handle other selector expression slice types
+						c.tsw.WriteLiterally("$.makeSlice<")
+						c.WriteGoType(goElemType, GoTypeContextGeneral) // Write the element type
+						c.tsw.WriteLiterally(">(")
+
+						if len(exp.Args) >= 2 {
+							if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
+								return err
+							}
+							if len(exp.Args) == 3 {
+								c.tsw.WriteLiterally(", ")
+								if err := c.WriteValueExpr(exp.Args[2]); err != nil { // Capacity
+									return err
+								}
+							} else if len(exp.Args) > 3 {
+								return errors.New("makeSlice expects 2 or 3 arguments")
+							}
+						} else {
+							// If no length is provided, default to 0
+							c.tsw.WriteLiterally("0")
+						}
+						c.tsw.WriteLiterally(")")
+						return nil // Handled make for selector expression slice type
+					}
+
+					// Handle selector expression channel types: make(pkg.ChannelType, bufferSize)
+					if chanType, isChan := underlying.(*types.Chan); isChan {
+						c.tsw.WriteLiterally("$.makeChannel<")
+						c.WriteGoType(chanType.Elem(), GoTypeContextGeneral)
+						c.tsw.WriteLiterally(">(")
+
+						// If buffer size is provided, add it
+						if len(exp.Args) >= 2 {
+							if err := c.WriteValueExpr(exp.Args[1]); err != nil {
+								return fmt.Errorf("failed to write buffer size in makeChannel: %w", err)
+							}
+						} else {
+							// Default to 0 (unbuffered channel)
+							c.tsw.WriteLiterally("0")
+						}
+
+						c.tsw.WriteLiterally(", ") // Add comma for zero value argument
+
+						// Write the zero value for the channel's element type
+						if chanType.Elem().String() == "struct{}" {
+							c.tsw.WriteLiterally("{}")
+						} else {
+							c.WriteZeroValueForType(chanType.Elem())
+						}
+
+						// Add direction parameter
+						c.tsw.WriteLiterally(", ")
+
+						// Determine channel direction
+						switch chanType.Dir() {
+						case types.SendRecv:
+							c.tsw.WriteLiterally("'both'")
+						case types.SendOnly:
+							c.tsw.WriteLiterally("'send'")
+						case types.RecvOnly:
+							c.tsw.WriteLiterally("'receive'")
+						default:
+							c.tsw.WriteLiterally("'both'") // Default to bidirectional
+						}
+
+						c.tsw.WriteLiterally(")")
+						return nil // Handled make for selector expression channel type
+					}
+				}
+			}
 			// Fallthrough for unhandled make calls (e.g., channels)
 			return errors.New("unhandled make call")
 		case "string":
@@ -771,12 +987,16 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 			}
 			c.tsw.WriteLiterally(")")
 		} else {
-			// Not an identifier (e.g., method call on a value)
+			// Not an identifier (e.g., method call on a value, function call result)
 			if err := c.WriteValueExpr(expFun); err != nil {
 				return fmt.Errorf("failed to write method expression in call: %w", err)
 			}
 
-			if funType := c.pkg.TypesInfo.TypeOf(expFun); funType != nil {
+			// Check if this is a function call that returns a function (e.g., simpleIterator(m)())
+			// Add non-null assertion since the returned function could be null
+			if _, isCallExpr := expFun.(*ast.CallExpr); isCallExpr {
+				c.tsw.WriteLiterally("!")
+			} else 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 {
@@ -791,6 +1011,13 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 					} 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.go

@@ -52,7 +52,7 @@ func (c *GoToTSCompiler) WriteIndexExpr(exp *ast.IndexExpr) error {
 
 			// Generate the zero value as the default value for mapGet
 			c.WriteZeroValueForType(mapType.Elem())
-			c.tsw.WriteLiterally(")")
+			c.tsw.WriteLiterally(")[0]") // Extract the value from the tuple
 			return nil
 		}
 
@@ -77,6 +77,31 @@ func (c *GoToTSCompiler) WriteIndexExpr(exp *ast.IndexExpr) error {
 			if constraint != nil {
 				underlying := constraint.Underlying()
 				if iface, isInterface := underlying.(*types.Interface); isInterface {
+					// Check if this is a map constraint (like ~map[K]V)
+					if hasMapConstraint(iface) {
+						// This is a map type parameter, use map access
+						c.tsw.WriteLiterally("$.mapGet(")
+						if err := c.WriteValueExpr(exp.X); err != nil {
+							return err
+						}
+						c.tsw.WriteLiterally(", ")
+						if err := c.WriteValueExpr(exp.Index); err != nil {
+							return err
+						}
+						c.tsw.WriteLiterally(", ")
+
+						// Generate the zero value as the default value for mapGet
+						// For type parameters, we need to get the value type from the constraint
+						mapValueType := getMapValueTypeFromConstraint(iface)
+						if mapValueType != nil {
+							c.WriteZeroValueForType(mapValueType)
+						} else {
+							c.tsw.WriteLiterally("null")
+						}
+						c.tsw.WriteLiterally(")[0]") // Extract the value from the tuple
+						return nil
+					}
+
 					// Check if this is a mixed string/byte constraint (like string | []byte)
 					if hasMixedStringByteConstraint(iface) {
 						// For mixed constraints, use specialized function that returns number (byte value)
@@ -694,3 +719,43 @@ func (c *GoToTSCompiler) WriteKeyValueExpr(exp *ast.KeyValueExpr) error {
 	}
 	return nil
 }
+
+// hasMapConstraint checks if an interface constraint includes map types
+// For constraints like ~map[K]V, this returns true
+func hasMapConstraint(iface *types.Interface) bool {
+	// Check if the interface has type terms that include map types
+	for i := 0; i < iface.NumEmbeddeds(); i++ {
+		embedded := iface.EmbeddedType(i)
+		if union, ok := embedded.(*types.Union); ok {
+			for j := 0; j < union.Len(); j++ {
+				term := union.Term(j)
+				if _, isMap := term.Type().Underlying().(*types.Map); isMap {
+					return true
+				}
+			}
+		} else if _, isMap := embedded.Underlying().(*types.Map); isMap {
+			return true
+		}
+	}
+	return false
+}
+
+// getMapValueTypeFromConstraint extracts the value type from a map constraint
+// For constraints like ~map[K]V, this returns V
+func getMapValueTypeFromConstraint(iface *types.Interface) types.Type {
+	// Check if the interface has type terms that include map types
+	for i := 0; i < iface.NumEmbeddeds(); i++ {
+		embedded := iface.EmbeddedType(i)
+		if union, ok := embedded.(*types.Union); ok {
+			for j := 0; j < union.Len(); j++ {
+				term := union.Term(j)
+				if mapType, isMap := term.Type().Underlying().(*types.Map); isMap {
+					return mapType.Elem()
+				}
+			}
+		} else if mapType, isMap := embedded.Underlying().(*types.Map); isMap {
+			return mapType.Elem()
+		}
+	}
+	return nil
+}

package/compiler/lit.go

@@ -118,7 +118,7 @@ func (c *GoToTSCompiler) WriteFuncLitValue(exp *ast.FuncLit) error {
 	}
 
 	// Write function body
-	if err := c.WriteStmtBlock(exp.Body, false); err != nil {
+	if err := c.WriteStmtBlock(exp.Body, true); err != nil {
 		return fmt.Errorf("failed to write block statement: %w", err)
 	}
 

package/compiler/spec.go

@@ -414,6 +414,12 @@ func (c *GoToTSCompiler) WriteTypeSpec(a *ast.TypeSpec) error {
 		if err := c.WriteValueExpr(a.Name); err != nil {
 			return err
 		}
+
+		// Write type parameters if present (for generics)
+		if a.TypeParams != nil {
+			c.WriteTypeParameters(a.TypeParams)
+		}
+
 		c.tsw.WriteLiterally(" = ")
 		c.WriteTypeExpr(a.Type) // The aliased type
 		c.tsw.WriteLine(";")