goscript 0.0.58 → 0.0.60

package/README.md

@@ -9,7 +9,7 @@
 
 ## What is GoScript?
 
-GoScript is a **Go to TypeScript compiler** that translates Go code to TypeScript at the AST level. Perfect for sharing algorithms and business logic between Go backends and TypeScript frontends.
+GoScript is an experimental **Go to TypeScript compiler** that translates Go code to TypeScript at the AST level. The goal is to enable sharing algorithms and business logic between Go backends and TypeScript frontends.
 
 > Right now goscript looks pretty cool if you problem is "I want this self-sufficient algorithm be available in Go and JS runtimes". gopherjs's ambition, however, has always been "any valid Go program can run in a browser". There is a lot that goes on in gopherjs that is necessary for supporting the standard library, which goes beyond cross-language translation.
 >
@@ -17,33 +17,46 @@ GoScript is a **Go to TypeScript compiler** that translates Go code to TypeScrip
 
 ### 🎯 Why GoScript?
 
-**Write once, run everywhere.** Share your Go algorithms, business logic, and data structures seamlessly between your backend and frontend without maintaining two codebases.
+Write once, run everywhere. Share your Go algorithms, business logic, and data structures seamlessly between your backend and frontend without maintaining two codebases.
 
-✅ **Perfect for:**
+🔬 **Experimental features being developed:**
 - Sharing business logic between Go services and web apps
 - Porting Go algorithms to run in browsers
 - Building TypeScript libraries from existing Go code
-- Full-stack teams that love Go's simplicity
 
-⚠️ **What's supported:**
-GoScript compiles a powerful subset of Go:
-- Structs, interfaces, methods, and functions
-- Channels and goroutines (translated to async/await)
-- Slices, maps, and most built-in types
-- Basic reflection support
-- Standard control flow (if, for, switch, etc.)
+Go has powerful concurrency support and an excellent standard library. GoScript brings these capabilities to TypeScript with as simple and readable of a translation as possible.
 
-**Current limitations:**
+⚠️ **Current development status:**
+GoScript is working on compiling a subset of Go:
+- ✅ Basic structs, interfaces, methods, and functions
+- ✅ Channels and goroutines (translating to async/await)
+- ✅ Slice semantics, maps, and built-in types
+- ✅ Standard control flow (if, for, switch, select, range, etc.)
+- 🚧 Basic reflection support
+- 🚧 Standard library support
+
+**Known limitations in this preview:**
 - Uses JavaScript `number` type (64-bit float, not Go's int types)
 - No pointer arithmetic (`uintptr`) or `unsafe` package
 - No complex numbers
-- Limited standard library (growing rapidly)
+- Limited standard library (working on it)
+- Performance not yet optimized
+
+**This is a prototype!** Expect bugs and missing features. Please contribute!
+
+### ⚠️ Development Preview
+
+**This project is currently in active development and should be considered experimental.** GoScript is a work-in-progress prototype that may have bugs, incomplete features, and breaking changes. We're actively iterating on the compiler and welcome your feedback!
+
+🐛 **Found an issue?** Please [open an issue](https://github.com/aperturerobotics/goscript/issues) and we'll fix it.
 
-If you're building algorithms, business logic, or data processing code, GoScript has you covered! 🚀
+🤖 **AI** This prototype is heavily AI-written, but I plan to manually rewrite the codebase by hand once it reaches a working state for advanced use cases. AI Producer, human Reducer.
 
 📖 **Learn more:** [Design document](./design/DESIGN.md) | [Compliance tests](./compliance/COMPLIANCE.md)
 
-## 🚀 Get Started in 2 Minutes
+## 🚀 Try It
+
+> **Warning:** This is experimental software. Features may be incomplete or broken. Please report any issues!
 
 ### Installation
 
@@ -52,18 +65,20 @@ If you're building algorithms, business logic, or data processing code, GoScript
 go install github.com/aperturerobotics/goscript/cmd/goscript@latest
 ```
 
-**Option 2: NPM**
+**Option 2: NPM** (if available)
 ```bash
 npm install -g goscript
 ```
 
-### Your First Compilation
+### Compilation
 
 ```bash
-# Compile your Go package to TypeScript
+# Try compiling your Go package to TypeScript
 goscript compile --package . --output ./dist
 ```
 
+**Note:** Many Go packages may not compile successfully yet. Start with simple code and gradually test more complex features.
+
 ## 📦 Using Generated Code in Your Project
 
 After compiling your Go code to TypeScript, you'll need to set up your project appropriately.
@@ -168,6 +183,8 @@ const searchUser = (email: string) => {
 
 ## 💡 See It In Action
 
+> **Disclaimer:** These examples represent the target functionality. Your mileage may vary with the current development preview.
+
 ### Example: User Management
 
 **Go Code** (`user.go`):
@@ -203,7 +220,7 @@ func FindUserByEmail(users []*User, email string) *User {
 goscript compile --package . --output ./dist
 ```
 
-**Generated TypeScript** (`user.ts`):
+**Generated TypeScript** (`user.gs.ts`):
 ```typescript
 export class User {
   public ID: number = 0
@@ -298,21 +315,11 @@ async function handleMessages() {
 }
 ```
 
-## 🚀 What's Next?
-
-**Current Status:**
-- ✅ Core language features (structs, methods, interfaces)
-- ✅ Async/await for goroutines and channels  
-- ✅ Basic reflection support
-- ✅ Most control flow and data types
-
-**Coming Soon:**
-- 📦 Expanded standard library
-- 🧪 Go test → TypeScript test conversion
-- ⚡ Performance optimizations
-- 🔧 Better tooling integration
+## 🤝 How You Can Help
 
-Check the [compliance tests](./compliance/COMPLIANCE.md) for detailed progress.
+- Try GoScript on your code and [report issues](https://github.com/aperturerobotics/goscript/issues)
+- Check the [compliance tests](./compliance/COMPLIANCE.md) for current progress
+- Contribute test cases for edge cases you discover
 
 ## License
 

package/compiler/analysis.go

@@ -2,7 +2,6 @@ package compiler
 
 import (
 	"encoding/json"
-	"fmt"
 	"go/ast"
 	"go/token"
 	"go/types"
@@ -641,6 +640,22 @@ func (v *analysisVisitor) visitFuncDecl(n *ast.FuncDecl) ast.Visitor {
 							funcInfo := v.analysis.ensureFunctionData(obj)
 							funcInfo.ReceiverUsed = receiverUsed
 						}
+
+						// If receiver is used, mark all identifiers that refer to the receiver variable
+						if receiverUsed && n.Body != nil {
+							recvName := ident.Name
+							ast.Inspect(n.Body, func(nn ast.Node) bool {
+								id, ok := nn.(*ast.Ident)
+								if !ok {
+									return true
+								}
+								if obj := v.pkg.TypesInfo.Uses[id]; obj != nil && obj == vr {
+									ni := v.analysis.ensureNodeData(id)
+									ni.IdentifierMapping = recvName
+								}
+								return true
+							})
+						}
 					}
 				}
 			}
@@ -759,9 +774,92 @@ func (v *analysisVisitor) visitCallExpr(n *ast.CallExpr) ast.Visitor {
 	// Track interface implementations from function call arguments
 	v.trackInterfaceCallArguments(n)
 
+	// Check for implicit address-taking in method calls with pointer receivers
+	v.checkImplicitAddressTaking(n)
+
 	return v
 }
 
+// checkImplicitAddressTaking detects when a method call with a pointer receiver
+// is called on a non-pointer variable, which requires implicit address-taking.
+// Example: var s MySlice; s.Add(10) where Add has receiver *MySlice
+// This is equivalent to (&s).Add(10), so s needs to be marked as NeedsVarRef
+func (v *analysisVisitor) checkImplicitAddressTaking(callExpr *ast.CallExpr) {
+	// Check if this is a method call (selector expression)
+	selExpr, ok := callExpr.Fun.(*ast.SelectorExpr)
+	if !ok {
+		return
+	}
+
+	// Get the selection information
+	selection := v.pkg.TypesInfo.Selections[selExpr]
+	if selection == nil || selection.Kind() != types.MethodVal {
+		return
+	}
+
+	// Get the method object
+	methodObj := selection.Obj()
+	if methodObj == nil {
+		return
+	}
+
+	// Get the method's signature to check the receiver type
+	methodFunc, ok := methodObj.(*types.Func)
+	if !ok {
+		return
+	}
+
+	sig := methodFunc.Type().(*types.Signature)
+	recv := sig.Recv()
+	if recv == nil {
+		return
+	}
+
+	// Check if the method has a pointer receiver
+	recvType := recv.Type()
+	_, hasPointerReceiver := recvType.(*types.Pointer)
+	if !hasPointerReceiver {
+		return
+	}
+
+	// Get the type of the receiver expression (the thing before the dot)
+	exprType := v.pkg.TypesInfo.TypeOf(selExpr.X)
+	if exprType == nil {
+		return
+	}
+
+	// Check if the receiver expression is NOT already a pointer
+	_, exprIsPointer := exprType.(*types.Pointer)
+	if exprIsPointer {
+		// Expression is already a pointer, no implicit address-taking needed
+		return
+	}
+
+	// At this point, we have:
+	// - A method with a pointer receiver
+	// - Being called on a non-pointer expression
+	// This means Go will implicitly take the address
+
+	// Check if the receiver expression is an identifier (variable)
+	ident, ok := selExpr.X.(*ast.Ident)
+	if !ok {
+		return
+	}
+
+	// Get the variable object
+	obj := v.pkg.TypesInfo.ObjectOf(ident)
+	if obj == nil {
+		return
+	}
+
+	// Mark this variable as needing VarRef (its address is being taken)
+	usageInfo := v.getOrCreateUsageInfo(obj)
+	usageInfo.Destinations = append(usageInfo.Destinations, AssignmentInfo{
+		Object: nil, // No specific destination for method calls
+		Type:   AddressOfAssignment,
+	})
+}
+
 // visitSelectorExpr handles selector expression analysis
 func (v *analysisVisitor) visitSelectorExpr(n *ast.SelectorExpr) ast.Visitor {
 	// Check if this is a method value (method being used as a value, not called immediately)
@@ -1373,6 +1471,14 @@ func (a *Analysis) loadGsMetadata(metaFilePath string) *GsMetadata {
 	return &metadata
 }
 
+// isHandwrittenPackage checks if a package path corresponds to a handwritten package in gs/
+func (a *Analysis) isHandwrittenPackage(pkgPath string) bool {
+	// Check if the package exists in the embedded gs/ directory
+	metaFilePath := filepath.Join("gs", pkgPath, "meta.json")
+	_, err := goscript.GsOverrides.ReadFile(metaFilePath)
+	return err == nil
+}
+
 // IsMethodAsync checks if a method call is async based on package metadata
 func (a *Analysis) IsMethodAsync(pkgPath, typeName, methodName string) bool {
 	// First, check pre-computed method async status
@@ -2147,13 +2253,49 @@ func (v *analysisVisitor) analyzeAllMethodsAsync() {
 	// Initialize visitingMethods map
 	v.visitingMethods = make(map[MethodKey]bool)
 
-	// Analyze methods in current package
-	v.analyzePackageMethodsAsync(v.pkg)
+	// Fixed-point iteration: keep analyzing until nothing changes
+	// This handles cases where method A calls method B, but B is analyzed after A
+	maxIterations := 10
+	for iteration := 0; iteration < maxIterations; iteration++ {
+		// Clear visitingMethods map for this iteration
+		v.visitingMethods = make(map[MethodKey]bool)
 
-	// Analyze methods in all dependency packages
-	for _, pkg := range v.analysis.AllPackages {
-		if pkg != v.pkg {
-			v.analyzePackageMethodsAsync(pkg)
+		// Track if anything changed in this iteration
+		changed := false
+
+		// Save previous state
+		previousState := make(map[MethodKey]bool)
+		for k, v := range v.analysis.MethodAsyncStatus {
+			previousState[k] = v
+		}
+
+		// Re-analyze methods in current package
+		v.analyzePackageMethodsAsync(v.pkg)
+
+		// Re-analyze methods in all dependency packages
+		for _, pkg := range v.analysis.AllPackages {
+			if pkg != v.pkg {
+				v.analyzePackageMethodsAsync(pkg)
+			}
+		}
+
+		// Check if anything changed
+		for k, newValue := range v.analysis.MethodAsyncStatus {
+			oldValue, existed := previousState[k]
+			if !existed {
+				// New method added - check if it's async (if sync, no need to re-analyze dependents)
+				if newValue {
+					changed = true
+				}
+			} else if oldValue != newValue {
+				// Method changed from sync to async (or vice versa)
+				changed = true
+			}
+		}
+
+		// If nothing changed, we've reached a fixed point
+		if !changed {
+			break
 		}
 	}
 
@@ -2212,11 +2354,6 @@ func (v *analysisVisitor) analyzeFunctionLiteralAsync(funcLit *ast.FuncLit, pkg
 func (v *analysisVisitor) analyzeMethodAsync(funcDecl *ast.FuncDecl, pkg *packages.Package) {
 	methodKey := v.getMethodKey(funcDecl, pkg)
 
-	// Check if already analyzed
-	if _, exists := v.analysis.MethodAsyncStatus[methodKey]; exists {
-		return
-	}
-
 	// Check for cycles
 	if v.visitingMethods[methodKey] {
 		// Cycle detected, assume sync to break recursion
@@ -2230,18 +2367,32 @@ func (v *analysisVisitor) analyzeMethodAsync(funcDecl *ast.FuncDecl, pkg *packag
 	// Determine if method is async
 	isAsync := false
 
-	// Determine if this is a truly external package vs a package being compiled locally
-	isExternalPackage := pkg.Types != v.pkg.Types && v.analysis.AllPackages[pkg.Types.Path()] == nil
+	// Determine if this is a handwritten package (from gs/ directory)
+	// Handwritten packages should not have their bodies analyzed
+	isHandwrittenPackage := v.analysis.isHandwrittenPackage(methodKey.PackagePath)
 
-	if isExternalPackage {
-		// Truly external package: check metadata first, fall back to body analysis
-		isAsync = v.checkExternalMethodMetadata(methodKey.PackagePath, methodKey.ReceiverType, methodKey.MethodName)
-	} else {
-		// Local package or package being compiled: analyze method body
-		if funcDecl.Body != nil {
-			isAsync = v.containsAsyncOperationsComplete(funcDecl.Body, pkg)
+	if isHandwrittenPackage {
+		// For handwritten packages, check if we have pre-loaded metadata
+		metadataKey := MethodKey{
+			PackagePath:  methodKey.PackagePath,
+			ReceiverType: methodKey.ReceiverType,
+			MethodName:   methodKey.MethodName,
+		}
+		metadataIsAsync, hasMetadata := v.analysis.MethodAsyncStatus[metadataKey]
+
+		if hasMetadata {
+			// Use explicit metadata from handwritten packages (gs/)
+			isAsync = metadataIsAsync
+		} else {
+			// Handwritten package but no explicit metadata: assume sync
+			isAsync = false
 		}
+	} else if funcDecl.Body != nil {
+		// Not a handwritten package and has body: always analyze for async operations
+		// This allows fixed-point iteration to update results
+		isAsync = v.containsAsyncOperationsComplete(funcDecl.Body, pkg)
 	}
+	// Otherwise leave isAsync as false
 
 	// Store result in MethodAsyncStatus
 	v.analysis.MethodAsyncStatus[methodKey] = isAsync
@@ -2319,16 +2470,8 @@ func (v *analysisVisitor) containsAsyncOperationsComplete(node ast.Node, pkg *pa
 
 		case *ast.CallExpr:
 			// Check if we're calling a function known to be async
-			isCallAsyncResult := v.isCallAsync(s, pkg)
-			if isCallAsyncResult {
+			if v.isCallAsync(s, pkg) {
 				hasAsync = true
-				callName := ""
-				if ident, ok := s.Fun.(*ast.Ident); ok {
-					callName = ident.Name
-				} else if sel, ok := s.Fun.(*ast.SelectorExpr); ok {
-					callName = sel.Sel.Name
-				}
-				asyncReasons = append(asyncReasons, fmt.Sprintf("async call: %s", callName))
 				return false
 			}
 		}
@@ -2459,21 +2602,19 @@ func (v *analysisVisitor) isMethodAsyncFromSelection(selExpr *ast.SelectorExpr,
 		return status
 	}
 
-	// Only try to analyze methods for packages that don't have metadata loaded
-	// If a package has metadata, we should rely solely on that metadata
-	if targetPkg := v.analysis.AllPackages[methodPkgPath]; targetPkg != nil {
-		// Check if this package has metadata loaded by checking if any method from this package
-		// exists in MethodAsyncStatus. If so, don't analyze - rely on metadata only.
-		hasMetadata := false
-		for key := range v.analysis.MethodAsyncStatus {
-			if key.PackagePath == methodPkgPath {
-				hasMetadata = true
-				break
+	// Check if this is a method in the same package we're currently analyzing
+	if methodPkgPath == v.pkg.Types.Path() {
+		// This is a method in the same package - we should analyze it if we haven't yet
+		if funcDecl := v.findMethodDecl(receiverType, methodObj.Name(), v.pkg); funcDecl != nil {
+			v.analyzeMethodAsync(funcDecl, v.pkg)
+			if status, exists := v.analysis.MethodAsyncStatus[methodKey]; exists {
+				return status
 			}
 		}
-
-		// Only analyze if no metadata exists for this package
-		if !hasMetadata {
+	} else {
+		// For methods in other packages that we're compiling together
+		if targetPkg := v.analysis.AllPackages[methodPkgPath]; targetPkg != nil {
+			// Try to analyze the method if we haven't already
 			if funcDecl := v.findMethodDecl(receiverType, methodObj.Name(), targetPkg); funcDecl != nil {
 				v.analyzeMethodAsync(funcDecl, targetPkg)
 				if status, exists := v.analysis.MethodAsyncStatus[methodKey]; exists {