goscript 0.0.58 → 0.0.59

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

@@ -641,6 +641,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 +775,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)
@@ -2234,13 +2333,12 @@ func (v *analysisVisitor) analyzeMethodAsync(funcDecl *ast.FuncDecl, pkg *packag
 	isExternalPackage := pkg.Types != v.pkg.Types && v.analysis.AllPackages[pkg.Types.Path()] == nil
 
 	if isExternalPackage {
-		// Truly external package: check metadata first, fall back to body analysis
+		// Truly external package: check metadata first
 		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 not determined async yet and body exists, analyze it
+	if !isAsync && funcDecl.Body != nil {
+		isAsync = v.containsAsyncOperationsComplete(funcDecl.Body, pkg)
 	}
 
 	// Store result in MethodAsyncStatus
@@ -2459,21 +2557,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 {