goscript 0.0.26 → 0.0.29

package/README.md

@@ -152,9 +152,10 @@ This example imports the `compile` function, configures it to compile a Go packa
 Check [the compliance tests](./compliance/COMPLIANCE.md) for implementation progress.
 
  - [X] Simple programs compile & run
- - [ ] Compliance for basic language features complete
- - [ ] Function coloring and async logic
- - [ ] Work our way up to more complex programs
+ - [X] Compliance for basic language features complete
+ - [X] Function coloring and async logic
+ - [X] Work our way up to more complex programs
+ - [ ] Implement most of the Go standard library
  - [ ] Generate init() function to recursively initialize packages
  - [ ] Tooling to integrate with typescript compiler
  - [ ] "go test" implementation with Go -> Ts transformation
@@ -162,7 +163,6 @@ Check [the compliance tests](./compliance/COMPLIANCE.md) for implementation prog
  - [ ] performance testing
  - [ ] examples of calling Go code from TypeScript
 
-
 ## Generated Code
 
 Below is a simple example of how code is generated:

package/cmd/goscript/cmd_compile.go

@@ -8,9 +8,6 @@ import (
 	"github.com/aperturerobotics/goscript/compiler"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
-
-	// _ ensure we include the gs package
-	_ "github.com/aperturerobotics/goscript"
 )
 
 var (

package/cmd/goscript/deps.go

@@ -0,0 +1,11 @@
+package main
+
+// This file has _ imports to ensure we include these in the go module.
+
+import (
+	// _ ensure we include the gs package
+	_ "github.com/aperturerobotics/goscript"
+	// _ ensure we include the gs metadata packages
+	_ "github.com/aperturerobotics/goscript/gs/sync"
+	_ "github.com/aperturerobotics/goscript/gs/unicode"
+)

package/compiler/analysis.go

@@ -4,6 +4,8 @@ import (
 	"go/ast"
 	"go/token"
 	"go/types"
+	"path/filepath"
+	"strings"
 
 	"golang.org/x/tools/go/packages"
 )
@@ -54,6 +56,8 @@ type NodeInfo struct {
 	IsBareReturn      bool
 	EnclosingFuncDecl *ast.FuncDecl
 	EnclosingFuncLit  *ast.FuncLit
+	IsInsideFunction  bool // true if this declaration is inside a function body
+	IsMethodValue     bool // true if this SelectorExpr is a method value that needs binding
 }
 
 // Analysis holds information gathered during the analysis phase of the Go code compilation.
@@ -79,16 +83,39 @@ type Analysis struct {
 	// Keep specialized maps that serve different purposes
 	// FuncLitData tracks function literal specific data since they don't have types.Object
 	FuncLitData map[*ast.FuncLit]*FunctionInfo
+
+	// PackageMetadata holds package-level metadata
+	PackageMetadata map[string]interface{}
+}
+
+// PackageAnalysis holds cross-file analysis data for a package
+type PackageAnalysis struct {
+	// FunctionDefs maps file names to the functions defined in that file
+	// Key: filename (without .go extension), Value: list of function names
+	FunctionDefs map[string][]string
+
+	// FunctionCalls maps file names to the functions they call from other files
+	// Key: filename (without .go extension), Value: map[sourceFile][]functionNames
+	FunctionCalls map[string]map[string][]string
 }
 
 // NewAnalysis creates a new Analysis instance.
 func NewAnalysis() *Analysis {
 	return &Analysis{
-		VariableUsage: make(map[types.Object]*VariableUsageInfo),
-		Imports:       make(map[string]*fileImport),
-		FunctionData:  make(map[types.Object]*FunctionInfo),
-		NodeData:      make(map[ast.Node]*NodeInfo),
-		FuncLitData:   make(map[*ast.FuncLit]*FunctionInfo),
+		VariableUsage:   make(map[types.Object]*VariableUsageInfo),
+		Imports:         make(map[string]*fileImport),
+		FunctionData:    make(map[types.Object]*FunctionInfo),
+		NodeData:        make(map[ast.Node]*NodeInfo),
+		FuncLitData:     make(map[*ast.FuncLit]*FunctionInfo),
+		PackageMetadata: make(map[string]interface{}),
+	}
+}
+
+// NewPackageAnalysis creates a new PackageAnalysis instance
+func NewPackageAnalysis() *PackageAnalysis {
+	return &PackageAnalysis{
+		FunctionDefs:  make(map[string][]string),
+		FunctionCalls: make(map[string]map[string][]string),
 	}
 }
 
@@ -210,54 +237,16 @@ func (a *Analysis) NeedsVarRefAccess(obj types.Object) bool {
 	return false
 }
 
-// NeedsVarRefDeref determines whether a pointer dereference operation (*ptr) needs
-// additional .value access beyond the standard !.value pattern.
-//
-// Standard pattern: ptr!.value  (for *int, *string, etc.)
-// Enhanced pattern: ptr.value!.value  (when ptr itself is variable referenced)
-//
-// This function returns true when the pointer variable itself is variable referenced,
-// meaning we need an extra .value to access the actual pointer before dereferencing.
-//
-// Examples:
-//   - ptr := &x (ptr not variable referenced): *ptr => ptr!.value
-//   - ptrPtr := &ptr (ptr is variable referenced): *ptr => ptr.value!.value
-//
-// Args:
-//
-//	ptrType: The type of the pointer being dereferenced
-//
-// Returns:
-//
-//	true if additional .value access is needed due to the pointer being variable referenced
-func (a *Analysis) NeedsVarRefDeref(ptrType types.Type) bool {
-	// For now, return false - this would need more sophisticated analysis
-	// to track when pointer variables themselves are variable referenced
-	return false
-}
-
-// NeedsVarRefFieldAccess determines whether a pointer variable needs the .value
-// access when performing field access through the pointer.
-//
-// In Go, field access through pointers is automatically dereferenced:
-//
-//	ptr.Field  // equivalent to (*ptr).Field
-//
-// In TypeScript, we need to determine if the pointer is:
-//  1. A simple pointer: ptr.Field  (no .value needed)
-//  2. A variable-referenced pointer: ptr.value.Field  (needs .value)
-//
-// Args:
-//
-//	ptrType: The pointer type being used for field access
-//
-// Returns:
-//
-//	true if .value access is needed before field access
-func (a *Analysis) NeedsVarRefFieldAccess(ptrType types.Type) bool {
-	// This would require analysis of the specific pointer variable
-	// For now, return false as a conservative default
-	return false
+// IsMethodValue returns whether the given SelectorExpr node is a method value that needs binding.
+func (a *Analysis) IsMethodValue(node *ast.SelectorExpr) bool {
+	if node == nil {
+		return false
+	}
+	nodeInfo := a.NodeData[node]
+	if nodeInfo == nil {
+		return false
+	}
+	return nodeInfo.IsMethodValue
 }
 
 // analysisVisitor implements ast.Visitor and is used to traverse the AST during analysis.
@@ -590,8 +579,20 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 		return v
 
 	case *ast.SelectorExpr:
-		// No need to track private field access since all fields are public
-		return v
+		// Initialize NodeData for this selector expression
+		if v.analysis.NodeData[n] == nil {
+			v.analysis.NodeData[n] = &NodeInfo{}
+		}
+		v.analysis.NodeData[n].InAsyncContext = v.inAsyncFunction
+
+		// Check if this is a method value (method being used as a value, not called immediately)
+		if selection := v.pkg.TypesInfo.Selections[n]; selection != nil {
+			if selection.Kind() == types.MethodVal {
+				// This is a method value - mark it for binding during code generation
+				v.analysis.NodeData[n].IsMethodValue = true
+			}
+		}
+		return v // Continue traversal
 
 	case *ast.AssignStmt:
 		for i, currentLHSExpr := range n.Lhs {
@@ -718,6 +719,25 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 			}
 		}
 		return v // Continue traversal
+
+	case *ast.DeclStmt:
+		// Handle declarations inside functions (const, var, type declarations within function bodies)
+		// These should not have export modifiers in TypeScript
+		if genDecl, ok := n.Decl.(*ast.GenDecl); ok {
+			// Check if we're inside a function (either FuncDecl or FuncLit)
+			isInsideFunction := v.currentFuncDecl != nil || v.currentFuncLit != nil
+
+			if isInsideFunction {
+				// Mark all specs in this declaration as being inside a function
+				for _, spec := range genDecl.Specs {
+					if v.analysis.NodeData[spec] == nil {
+						v.analysis.NodeData[spec] = &NodeInfo{}
+					}
+					v.analysis.NodeData[spec].IsInsideFunction = true
+				}
+			}
+		}
+		return v // Continue traversal
 	}
 
 	// For all other nodes, continue traversal
@@ -756,6 +776,37 @@ func (v *analysisVisitor) containsAsyncOperations(node ast.Node) bool {
 				}
 			}
 
+			// Check for method calls on imported types (e.g., sync.Mutex.Lock())
+			if selExpr, ok := s.Fun.(*ast.SelectorExpr); ok {
+				// Check if this is a method call on a variable (e.g., mu.Lock())
+				if ident, ok := selExpr.X.(*ast.Ident); ok {
+					// Get the type of the receiver
+					if obj := v.pkg.TypesInfo.Uses[ident]; obj != nil {
+						if varObj, ok := obj.(*types.Var); ok {
+							// Get the type name and package
+							if namedType, ok := varObj.Type().(*types.Named); ok {
+								typeName := namedType.Obj().Name()
+								methodName := selExpr.Sel.Name
+
+								// Check if the type is from an imported package
+								if typePkg := namedType.Obj().Pkg(); typePkg != nil && typePkg != v.pkg.Types {
+									pkgPath := typePkg.Path()
+									// Extract package name from path (e.g., "sync" from "github.com/.../gs/sync")
+									parts := strings.Split(pkgPath, "/")
+									pkgName := parts[len(parts)-1]
+
+									// Check if this method is async based on metadata
+									if v.analysis.IsMethodAsync(pkgName, typeName, methodName) {
+										hasAsync = true
+										return false
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+
 			// TODO: Add detection of method calls on async types
 		}
 
@@ -789,6 +840,9 @@ func AnalyzeFile(file *ast.File, pkg *packages.Package, analysis *Analysis, cmap
 	// Store the comment map in the analysis object
 	analysis.Cmap = cmap
 
+	// Load package metadata for async function detection
+	analysis.LoadPackageMetadata()
+
 	// Process imports from the file
 	for _, imp := range file.Imports {
 		path := ""
@@ -830,6 +884,20 @@ func AnalyzeFile(file *ast.File, pkg *packages.Package, analysis *Analysis, cmap
 
 	// Walk the AST with our visitor
 	ast.Walk(visitor, file)
+
+	// Post-processing: Find all CallExpr nodes and unmark their Fun SelectorExpr as method values
+	// This distinguishes between method calls (obj.Method()) and method values (obj.Method)
+	ast.Inspect(file, func(n ast.Node) bool {
+		if callExpr, ok := n.(*ast.CallExpr); ok {
+			if selExpr, ok := callExpr.Fun.(*ast.SelectorExpr); ok {
+				// This SelectorExpr is the function being called, so it's NOT a method value
+				if nodeInfo := analysis.NodeData[selExpr]; nodeInfo != nil {
+					nodeInfo.IsMethodValue = false
+				}
+			}
+		}
+		return true
+	})
 }
 
 // getNamedReturns retrieves the named returns for a function
@@ -844,3 +912,178 @@ func (v *analysisVisitor) getNamedReturns(funcDecl *ast.FuncDecl) []string {
 	}
 	return namedReturns
 }
+
+// AnalyzePackage performs package-level analysis to collect function definitions
+// and calls across all files in the package for auto-import generation
+func AnalyzePackage(pkg *packages.Package) *PackageAnalysis {
+	analysis := NewPackageAnalysis()
+
+	// First pass: collect all function definitions per file
+	for i, syntax := range pkg.Syntax {
+		fileName := pkg.CompiledGoFiles[i]
+		baseFileName := strings.TrimSuffix(filepath.Base(fileName), ".go")
+
+		var functions []string
+		for _, decl := range syntax.Decls {
+			if funcDecl, ok := decl.(*ast.FuncDecl); ok {
+				// Only collect top-level functions (not methods)
+				if funcDecl.Recv == nil {
+					functions = append(functions, funcDecl.Name.Name)
+				}
+			}
+		}
+
+		if len(functions) > 0 {
+			analysis.FunctionDefs[baseFileName] = functions
+		}
+	}
+
+	// Second pass: analyze function calls and determine which need imports
+	for i, syntax := range pkg.Syntax {
+		fileName := pkg.CompiledGoFiles[i]
+		baseFileName := strings.TrimSuffix(filepath.Base(fileName), ".go")
+
+		// Find all function calls in this file
+		callsFromOtherFiles := make(map[string][]string)
+
+		ast.Inspect(syntax, func(n ast.Node) bool {
+			if callExpr, ok := n.(*ast.CallExpr); ok {
+				if ident, ok := callExpr.Fun.(*ast.Ident); ok {
+					funcName := ident.Name
+
+					// Check if this function is defined in the current file
+					currentFileFuncs := analysis.FunctionDefs[baseFileName]
+					isDefinedInCurrentFile := false
+					for _, f := range currentFileFuncs {
+						if f == funcName {
+							isDefinedInCurrentFile = true
+							break
+						}
+					}
+
+					// If not defined in current file, find which file defines it
+					if !isDefinedInCurrentFile {
+						for sourceFile, funcs := range analysis.FunctionDefs {
+							if sourceFile == baseFileName {
+								continue // Skip current file
+							}
+							for _, f := range funcs {
+								if f == funcName {
+									// Found the function in another file
+									if callsFromOtherFiles[sourceFile] == nil {
+										callsFromOtherFiles[sourceFile] = []string{}
+									}
+									// Check if already added to avoid duplicates
+									found := false
+									for _, existing := range callsFromOtherFiles[sourceFile] {
+										if existing == funcName {
+											found = true
+											break
+										}
+									}
+									if !found {
+										callsFromOtherFiles[sourceFile] = append(callsFromOtherFiles[sourceFile], funcName)
+									}
+									break
+								}
+							}
+						}
+					}
+				}
+			}
+			return true
+		})
+
+		if len(callsFromOtherFiles) > 0 {
+			analysis.FunctionCalls[baseFileName] = callsFromOtherFiles
+		}
+	}
+
+	return analysis
+}
+
+// LoadPackageMetadata loads metadata from gs packages to determine which functions are async
+func (a *Analysis) LoadPackageMetadata() {
+	// List of gs packages that have metadata
+	metadataPackages := []string{
+		"github.com/aperturerobotics/goscript/gs/sync",
+		"github.com/aperturerobotics/goscript/gs/unicode",
+	}
+
+	for _, pkgPath := range metadataPackages {
+		cfg := &packages.Config{
+			Mode: packages.NeedTypes | packages.NeedTypesInfo | packages.NeedSyntax,
+		}
+
+		pkgs, err := packages.Load(cfg, pkgPath)
+		if err != nil || len(pkgs) == 0 {
+			continue // Skip if package can't be loaded
+		}
+
+		pkg := pkgs[0]
+		if pkg.Types == nil {
+			continue
+		}
+
+		// Extract the package name (e.g., "sync" from "github.com/aperturerobotics/goscript/gs/sync")
+		parts := strings.Split(pkgPath, "/")
+		pkgName := parts[len(parts)-1]
+
+		// Look for metadata variables in the package scope
+		scope := pkg.Types.Scope()
+		for _, name := range scope.Names() {
+			obj := scope.Lookup(name)
+			if obj == nil {
+				continue
+			}
+
+			// Check if this is a metadata variable (ends with "Info")
+			if strings.HasSuffix(name, "Info") {
+				if varObj, ok := obj.(*types.Var); ok {
+					// Store the metadata with a key like "sync.MutexLock"
+					methodName := strings.TrimSuffix(name, "Info")
+					key := pkgName + "." + methodName
+					a.PackageMetadata[key] = varObj
+				}
+			}
+		}
+	}
+}
+
+// IsMethodAsync checks if a method call is async based on package metadata
+func (a *Analysis) IsMethodAsync(pkgName, typeName, methodName string) bool {
+	// The metadata keys are stored as "sync.MutexLock", "sync.WaitGroupWait", etc.
+	// We need to match "sync.Mutex.Lock" -> "sync.MutexLock"
+	key := pkgName + "." + typeName + methodName
+
+	if metaObj, exists := a.PackageMetadata[key]; exists {
+		if varObj, ok := metaObj.(*types.Var); ok {
+			// Try to get the actual value of the variable
+			// For now, we'll use the variable name to determine if it's async
+			// The variable names follow the pattern: MutexLockInfo, WaitGroupWaitInfo, etc.
+			// We can check if the corresponding metadata indicates IsAsync: true
+			varName := varObj.Name()
+
+			// Based on our metadata definitions, these should be async:
+			asyncMethods := map[string]bool{
+				"MutexLockInfo":        true,
+				"RWMutexLockInfo":      true,
+				"RWMutexRLockInfo":     true,
+				"WaitGroupWaitInfo":    true,
+				"OnceDoInfo":           true,
+				"CondWaitInfo":         true,
+				"MapDeleteInfo":        true,
+				"MapLoadInfo":          true,
+				"MapLoadAndDeleteInfo": true,
+				"MapLoadOrStoreInfo":   true,
+				"MapRangeInfo":         true,
+				"MapStoreInfo":         true,
+			}
+
+			isAsync := asyncMethods[varName]
+			return isAsync
+		}
+	}
+
+	return false
+}

package/compiler/assignment.go

@@ -68,7 +68,7 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 			return nil
 		}
 
-		// Special handling for variable referenced variables in declarations
+		// Handle variable referenced variables in declarations
 		if addDeclaration && tok == token.DEFINE {
 			// Determine if LHS is variable referenced
 			isLHSVarRefed := false
@@ -90,7 +90,7 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 				}
 			}
 
-			// Special handling for short declaration of variable referenced variables
+			// Handle short declaration of variable referenced variables
 			if isLHSVarRefed && lhsIdent != nil {
 				c.tsw.WriteLiterally("let ")
 				// Just write the identifier name without .value

package/compiler/builtin_test.go

@@ -42,7 +42,7 @@ func TestEmitBuiltinOption(t *testing.T) {
 			t.Fatalf("Compilation failed: %v", err)
 		}
 
-		// Check that the unsafe package wasn't emitted (we know it's handwritten)
+		// Check that handwritten packages like unsafe aren't emitted when DisableEmitBuiltin=true
 		unsafePath := filepath.Join(outputDir, "@goscript/unsafe")
 		if _, err := os.Stat(unsafePath); !os.IsNotExist(err) {
 			t.Errorf("unsafe package was emitted when DisableEmitBuiltin=true")