goscript 0.0.47 → 0.0.49

package/cmd/goscript/deps.go

@@ -3,9 +3,6 @@ package main
 // This file has _ imports to ensure we include these in the go module.
 
 import (
-	// _ ensure we include the gs package
+	// _ ensure we include the root 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

@@ -1,12 +1,14 @@
 package compiler
 
 import (
+	"encoding/json"
 	"go/ast"
 	"go/token"
 	"go/types"
 	"path/filepath"
 	"strings"
 
+	"github.com/aperturerobotics/goscript"
 	"golang.org/x/tools/go/packages"
 )
 
@@ -81,6 +83,7 @@ type NodeInfo struct {
 	IsInsideFunction  bool           // true if this declaration is inside a function body
 	IsMethodValue     bool           // true if this SelectorExpr is a method value that needs binding
 	ShadowingInfo     *ShadowingInfo // variable shadowing information for if statements
+	IdentifierMapping string         // replacement name for this identifier (e.g., receiver -> "receiver")
 }
 
 // Analysis holds information gathered during the analysis phase of the Go code compilation.
@@ -115,6 +118,10 @@ type Analysis struct {
 
 	// PackageMetadata holds package-level metadata
 	PackageMetadata map[string]interface{}
+
+	// WrapperTypes tracks types that should be implemented as wrapper classes
+	// This includes both local types with methods and imported types that are known wrapper types
+	WrapperTypes map[types.Type]bool
 }
 
 // PackageAnalysis holds cross-file analysis data for a package
@@ -136,6 +143,12 @@ type PackageAnalysis struct {
 	TypeCalls map[string]map[string][]string
 }
 
+// GsMetadata represents the structure of a meta.json file in gs/ packages
+type GsMetadata struct {
+	Dependencies []string        `json:"dependencies,omitempty"`
+	AsyncMethods map[string]bool `json:"asyncMethods,omitempty"`
+}
+
 // NewAnalysis creates a new Analysis instance.
 func NewAnalysis() *Analysis {
 	return &Analysis{
@@ -147,6 +160,7 @@ func NewAnalysis() *Analysis {
 		ReflectedFunctions:  make(map[ast.Node]*ReflectedFunctionInfo),
 		FunctionAssignments: make(map[types.Object]ast.Node),
 		PackageMetadata:     make(map[string]interface{}),
+		WrapperTypes:        make(map[types.Type]bool),
 	}
 }
 
@@ -1299,85 +1313,91 @@ func AnalyzePackage(pkg *packages.Package) *PackageAnalysis {
 	return analysis
 }
 
-// LoadPackageMetadata loads metadata from gs packages to determine which functions are async
+// LoadPackageMetadata loads metadata from gs packages using embedded JSON files
 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,
+	// Use the embedded filesystem from gs.go
+	// The GsOverrides embed.FS should be available but we need to import it
+	// For now, let's iterate through known packages and load their meta.json files
+
+	// Discover all packages in the embedded gs/ directory
+	packagePaths := a.discoverEmbeddedGsPackages()
+
+	for _, pkgPath := range packagePaths {
+		metaFilePath := filepath.Join("gs", pkgPath, "meta.json")
+
+		// Try to read the meta.json file from embedded filesystem
+		// We need access to the embedded FS, which should be imported from the parent package
+		if metadata := a.loadGsMetadata(metaFilePath); metadata != nil {
+			// Store async method information
+			for methodKey, isAsync := range metadata.AsyncMethods {
+				// Convert "Type.Method" format to our internal key format
+				parts := strings.Split(methodKey, ".")
+				if len(parts) == 2 {
+					typeName := parts[0]
+					methodName := parts[1]
+					// The key format is "pkgName.TypeNameMethodNameInfo"
+					key := pkgPath + "." + typeName + methodName + "Info"
+
+					// Store the async value directly in PackageMetadata
+					a.PackageMetadata[key] = isAsync
+				}
+			}
 		}
+	}
+}
 
-		pkgs, err := packages.Load(cfg, pkgPath)
-		if err != nil || len(pkgs) == 0 {
-			continue // Skip if package can't be loaded
-		}
+// discoverEmbeddedGsPackages finds all packages in the embedded gs/ directory
+func (a *Analysis) discoverEmbeddedGsPackages() []string {
+	var packageList []string
 
-		pkg := pkgs[0]
-		if pkg.Types == nil {
-			continue
-		}
+	// Read the gs/ directory from the embedded filesystem
+	entries, err := goscript.GsOverrides.ReadDir("gs")
+	if err != nil {
+		// If we can't read the gs/ directory, return empty list
+		return packageList
+	}
 
-		// Extract the package name (e.g., "sync" from "github.com/aperturerobotics/goscript/gs/sync")
-		parts := strings.Split(pkgPath, "/")
-		pkgName := parts[len(parts)-1]
+	// Iterate through all entries in gs/
+	for _, entry := range entries {
+		if entry.IsDir() {
+			packageName := entry.Name()
 
-		// Look for metadata variables in the package scope
-		scope := pkg.Types.Scope()
-		for _, name := range scope.Names() {
-			obj := scope.Lookup(name)
-			if obj == nil {
+			// Skip special directories like github.com
+			if strings.Contains(packageName, ".") {
 				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
-				}
-			}
+			packageList = append(packageList, packageName)
 		}
 	}
+
+	return packageList
+}
+
+// loadGsMetadata loads metadata from a meta.json file in the embedded filesystem
+func (a *Analysis) loadGsMetadata(metaFilePath string) *GsMetadata {
+	// Read the meta.json file from the embedded filesystem
+	content, err := goscript.GsOverrides.ReadFile(metaFilePath)
+	if err != nil {
+		return nil // No metadata file found
+	}
+
+	var metadata GsMetadata
+	if err := json.Unmarshal(content, &metadata); err != nil {
+		return nil // Invalid JSON
+	}
+
+	return &metadata
 }
 
 // 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,
-			}
+	// The metadata keys are stored as "pkgName.TypeNameMethodNameInfo"
+	// e.g., "sync.MutexLockInfo", "sync.WaitGroupWaitInfo", etc.
+	key := pkgName + "." + typeName + methodName + "Info"
 
-			isAsync := asyncMethods[varName]
+	if asyncValue, exists := a.PackageMetadata[key]; exists {
+		if isAsync, ok := asyncValue.(bool); ok {
 			return isAsync
 		}
 	}
@@ -1581,3 +1601,144 @@ func (v *analysisVisitor) findVariableUsageInExpr(expr ast.Expr, lhsVarNames map
 		// For now, we'll ignore them as they're less common in shadowing scenarios
 	}
 }
+
+// IsWrapperType returns whether the given type should be implemented as a wrapper class
+// This includes both local types with methods and imported types that are known wrapper types
+func (a *Analysis) IsWrapperType(t types.Type) bool {
+	if t == nil {
+		return false
+	}
+
+	// Check if we've already determined this type is a wrapper type
+	if isWrapper, exists := a.WrapperTypes[t]; exists {
+		return isWrapper
+	}
+
+	// For named types, check if they have methods and underlying primitive types
+	if namedType, ok := t.(*types.Named); ok {
+		// Exclude struct types - they should remain as classes, not wrapper types
+		if _, isStruct := namedType.Underlying().(*types.Struct); isStruct {
+			a.WrapperTypes[t] = false
+			return false
+		}
+
+		// Exclude interface types
+		if _, isInterface := namedType.Underlying().(*types.Interface); isInterface {
+			a.WrapperTypes[t] = false
+			return false
+		}
+
+		// Check if this type has methods defined on it
+		if namedType.NumMethods() > 0 {
+			// Additional check: the underlying type should be a basic type (primitive)
+			// This distinguishes wrapper types from complex types with methods
+			underlying := namedType.Underlying()
+
+			if isBasicType(underlying) {
+				a.WrapperTypes[t] = true
+				return true
+			}
+
+			// For non-basic underlying types with methods, still consider them wrapper types
+			// if they're not structs or interfaces (already excluded above)
+			a.WrapperTypes[t] = true
+			return true
+		}
+	}
+
+	// Handle type aliases (Go 1.9+)
+	if aliasType, ok := t.(*types.Alias); ok {
+		// For type aliases, we need to check the RHS (right-hand side) type
+		// For example, if we have: type FileMode = fs.FileMode
+		// We need to check if fs.FileMode has methods
+		rhs := aliasType.Rhs()
+
+		if rhsNamed, ok := rhs.(*types.Named); ok {
+			// Check if the RHS named type has methods and a basic underlying type
+			if rhsNamed.NumMethods() > 0 {
+				underlying := rhsNamed.Underlying()
+
+				// Exclude struct types
+				if _, isStruct := underlying.(*types.Struct); isStruct {
+					a.WrapperTypes[t] = false
+					return false
+				}
+
+				// Exclude interface types
+				if _, isInterface := underlying.(*types.Interface); isInterface {
+					a.WrapperTypes[t] = false
+					return false
+				}
+
+				if isBasicType(underlying) {
+					a.WrapperTypes[t] = true
+					return true
+				}
+
+				// For non-basic underlying types with methods, still consider them wrapper types
+				// if they're not structs or interfaces (already excluded above)
+				a.WrapperTypes[t] = true
+				return true
+			}
+		}
+
+		// Fallback: check the underlying type for older Go versions or different alias patterns
+		underlying := aliasType.Underlying()
+		if namedUnderlying, ok := underlying.(*types.Named); ok {
+			if namedUnderlying.NumMethods() > 0 && isBasicType(namedUnderlying.Underlying()) {
+				a.WrapperTypes[t] = true
+				return true
+			}
+		}
+	}
+
+	// Cache negative result
+	a.WrapperTypes[t] = false
+	return false
+}
+
+// isBasicType checks if a type is a basic/primitive type
+func isBasicType(t types.Type) bool {
+	if t == nil {
+		return false
+	}
+
+	switch underlying := t.(type) {
+	case *types.Basic:
+		// Basic types like int, string, bool, etc.
+		return true
+	case *types.Pointer:
+		// Pointers to basic types could also be considered for wrapper types
+		return isBasicType(underlying.Elem())
+	default:
+		return false
+	}
+}
+
+// GetReceiverMapping returns the receiver variable mapping for a function declaration
+func (a *Analysis) GetReceiverMapping(funcDecl *ast.FuncDecl) string {
+	if funcDecl.Recv != nil && len(funcDecl.Recv.List) > 0 {
+		for _, field := range funcDecl.Recv.List {
+			for _, name := range field.Names {
+				if name != nil && name.Name != "_" {
+					return "receiver"
+				}
+			}
+		}
+	}
+	return ""
+}
+
+// GetIdentifierMapping returns the replacement name for an identifier
+func (a *Analysis) GetIdentifierMapping(ident *ast.Ident) string {
+	if ident == nil {
+		return ""
+	}
+
+	// Check if this identifier has a mapping in NodeData
+	if nodeInfo := a.NodeData[ident]; nodeInfo != nil {
+		return nodeInfo.IdentifierMapping
+	}
+
+	return ""
+}

package/compiler/analysis_test.go

@@ -5,6 +5,7 @@ import (
 	"go/parser"
 	"go/token"
 	"go/types"
+	"os"
 	"testing"
 
 	"golang.org/x/tools/go/packages"
@@ -232,3 +233,114 @@ func main() {
 		t.Log("")
 	}
 }
+
+// TestWrapperTypeDetection verifies that the analysis correctly identifies wrapper types
+func TestWrapperTypeDetection(t *testing.T) {
+	// Use the actual compliance test case
+	testPath := "../compliance/tests/wrapper_type_args"
+
+	// Load the package using the packages config like the main compiler does
+	cfg := &packages.Config{
+		Mode: packages.NeedName |
+			packages.NeedFiles |
+			packages.NeedCompiledGoFiles |
+			packages.NeedImports |
+			packages.NeedDeps |
+			packages.NeedExportFile |
+			packages.NeedTypes |
+			packages.NeedSyntax |
+			packages.NeedTypesInfo |
+			packages.NeedTypesSizes,
+		Tests: false,
+		Env:   append(os.Environ(), "GOOS=js", "GOARCH=wasm"),
+	}
+
+	pkgs, err := packages.Load(cfg, testPath)
+	if err != nil {
+		t.Fatalf("Failed to load test package: %v", err)
+	}
+
+	if len(pkgs) != 1 {
+		t.Fatalf("Expected 1 package, got %d", len(pkgs))
+	}
+
+	pkg := pkgs[0]
+	if len(pkg.Errors) > 0 {
+		t.Fatalf("Package has errors: %v", pkg.Errors[0])
+	}
+
+	// Run analysis on the first file
+	if len(pkg.Syntax) == 0 {
+		t.Fatal("No syntax files found")
+	}
+
+	analysis := NewAnalysis()
+	cmap := ast.NewCommentMap(pkg.Fset, pkg.Syntax[0], pkg.Syntax[0].Comments)
+	AnalyzeFile(pkg.Syntax[0], pkg, analysis, cmap)
+
+	// Verify the WrapperTypes map was initialized
+	if analysis.WrapperTypes == nil {
+		t.Error("WrapperTypes map was not initialized")
+	}
+
+	// Test some type lookups to verify wrapper type detection works
+	// We'll check if MyMode (which has methods) is detected as a wrapper type
+	scope := pkg.Types.Scope()
+
+	// Check if MyMode is detected as a wrapper type
+	if obj := scope.Lookup("MyMode"); obj != nil {
+		if typeName, ok := obj.(*types.TypeName); ok {
+			isWrapper := analysis.IsWrapperType(typeName.Type())
+			if !isWrapper {
+				t.Errorf("MyMode should be detected as wrapper type, got %v", isWrapper)
+			}
+			t.Logf("MyMode wrapper detection: %v (correct)", isWrapper)
+		}
+	}
+
+	// Test that regular struct types are not detected as wrapper types
+	if obj := scope.Lookup("MyDir"); obj != nil {
+		if typeName, ok := obj.(*types.TypeName); ok {
+			isWrapper := analysis.IsWrapperType(typeName.Type())
+			if isWrapper {
+				t.Errorf("MyDir should not be detected as wrapper type, got %v", isWrapper)
+			}
+			t.Logf("MyDir wrapper detection: %v (correct)", isWrapper)
+		}
+	}
+
+	t.Logf("Analysis completed successfully with %d wrapper types tracked", len(analysis.WrapperTypes))
+}
+
+// TestDiscoverGsPackages verifies that the discoverEmbeddedGsPackages function
+// can find packages in the embedded gs/ directory
+func TestDiscoverGsPackages(t *testing.T) {
+	analysis := NewAnalysis()
+
+	// Test package discovery using the embedded filesystem
+	packages := analysis.discoverEmbeddedGsPackages()
+	t.Logf("Discovered %d packages:", len(packages))
+	for _, pkg := range packages {
+		t.Logf("  - %s", pkg)
+	}
+
+	// We should find at least some packages
+	if len(packages) == 0 {
+		t.Errorf("Expected to find at least one package in gs/ directory")
+	}
+
+	// Check for some known packages that should exist
+	expectedPackages := []string{"sync", "bytes", "strings"}
+	for _, expected := range expectedPackages {
+		found := false
+		for _, pkg := range packages {
+			if pkg == expected {
+				found = true
+				break
+			}
+		}
+		if !found {
+			t.Logf("Expected package '%s' not found in discovered packages: %v", expected, packages)
+		}
+	}
+}

package/compiler/compiler.go

@@ -2,10 +2,10 @@ package compiler
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
 	"go/ast"
 	"go/constant"
-	"go/parser"
 	"go/token"
 	"go/types"
 	"os"
@@ -644,9 +644,6 @@ type GoToTSCompiler struct {
 	pkg *packages.Package
 
 	analysis *Analysis
-
-	// shadowingContext tracks temporary variable mappings when we're in a shadowing context
-	shadowingContext map[string]string
 }
 
 // It initializes the compiler with a `TSCodeWriter` for output,
@@ -654,10 +651,9 @@ type GoToTSCompiler struct {
 // analysis results (`Analysis`) to guide the translation process.
 func NewGoToTSCompiler(tsw *TSCodeWriter, pkg *packages.Package, analysis *Analysis) *GoToTSCompiler {
 	return &GoToTSCompiler{
-		tsw:              tsw,
-		pkg:              pkg,
-		analysis:         analysis,
-		shadowingContext: make(map[string]string),
+		tsw:      tsw,
+		pkg:      pkg,
+		analysis: analysis,
 	}
 }
 
@@ -679,9 +675,9 @@ func (c *GoToTSCompiler) WriteIdent(exp *ast.Ident, accessVarRefedValue bool) {
 		return
 	}
 
-	// Check if we're in a shadowing context and should use a temporary variable
-	if tempVarName, exists := c.shadowingContext[exp.Name]; exists {
-		c.tsw.WriteLiterally(c.sanitizeIdentifier(tempVarName))
+	// Check if this identifier has a pre-computed mapping (e.g., wrapper function receiver)
+	if mappedName := c.analysis.GetIdentifierMapping(exp); mappedName != "" {
+		c.tsw.WriteLiterally(c.sanitizeIdentifier(mappedName))
 		return
 	}
 
@@ -1036,97 +1032,33 @@ func (c *Compiler) copyEmbeddedPackage(embeddedPath string, outputPath string) e
 // GsPackageMetadata holds metadata about a gs/ package
 type GsPackageMetadata struct {
 	// Dependencies lists the import paths that this gs/ package requires
-	Dependencies []string
+	Dependencies []string        `json:"dependencies,omitempty"`
+	AsyncMethods map[string]bool `json:"asyncMethods,omitempty"`
 }
 
-// ReadGsPackageMetadata reads dependency metadata from .go files in a gs/ package
-// It looks for a var variable named "GsDependencies" which should be a slice of strings
-// containing the import paths that this package depends on.
+// ReadGsPackageMetadata reads dependency metadata from meta.json file in a gs/ package
 func (c *Compiler) ReadGsPackageMetadata(gsSourcePath string) (*GsPackageMetadata, error) {
 	metadata := &GsPackageMetadata{
 		Dependencies: []string{},
+		AsyncMethods: make(map[string]bool),
 	}
 
-	// Check if there are any .go files in the gs package directory
-	entries, err := gs.GsOverrides.ReadDir(gsSourcePath)
+	// Try to read meta.json file
+	metaFilePath := filepath.Join(gsSourcePath, "meta.json")
+	content, err := gs.GsOverrides.ReadFile(metaFilePath)
 	if err != nil {
-		return metadata, nil // No metadata files, return empty metadata
+		// No meta.json file found, return empty metadata
+		return metadata, nil
 	}
 
-	// Look for .go files containing metadata
-	for _, entry := range entries {
-		if !entry.IsDir() && strings.HasSuffix(entry.Name(), ".go") {
-			metadataFilePath := filepath.Join(gsSourcePath, entry.Name())
-
-			// Read the .go file content
-			content, err := gs.GsOverrides.ReadFile(metadataFilePath)
-			if err != nil {
-				continue // Skip files we can't read
-			}
-
-			// Parse the file to extract metadata
-			if deps, err := c.extractDependenciesFromGoFile(content); err == nil {
-				metadata.Dependencies = append(metadata.Dependencies, deps...)
-			}
-		}
+	// Parse the JSON content
+	if err := json.Unmarshal(content, metadata); err != nil {
+		return metadata, fmt.Errorf("failed to parse meta.json in %s: %w", gsSourcePath, err)
 	}
 
 	return metadata, nil
 }
 
-// extractDependenciesFromGoFile parses a .go file and extracts the GsDependencies var
-func (c *Compiler) extractDependenciesFromGoFile(content []byte) ([]string, error) {
-	// Parse the Go file
-	fset := token.NewFileSet()
-	file, err := parser.ParseFile(fset, "metadata.go", content, 0)
-	if err != nil {
-		return nil, err
-	}
-
-	var dependencies []string
-
-	// Look for var declarations
-	for _, decl := range file.Decls {
-		if genDecl, ok := decl.(*ast.GenDecl); ok && genDecl.Tok == token.VAR {
-			for _, spec := range genDecl.Specs {
-				if valueSpec, ok := spec.(*ast.ValueSpec); ok {
-					for i, name := range valueSpec.Names {
-						if name.Name == "GsDependencies" {
-							// Found the GsDependencies var, extract its value
-							if i < len(valueSpec.Values) {
-								if deps := c.extractStringSliceFromExpr(valueSpec.Values[i]); deps != nil {
-									dependencies = append(dependencies, deps...)
-								}
-							}
-						}
-					}
-				}
-			}
-		}
-	}
-
-	return dependencies, nil
-}
-
-// extractStringSliceFromExpr extracts string values from a composite literal expression
-func (c *Compiler) extractStringSliceFromExpr(expr ast.Expr) []string {
-	var result []string
-
-	if compLit, ok := expr.(*ast.CompositeLit); ok {
-		for _, elt := range compLit.Elts {
-			if basicLit, ok := elt.(*ast.BasicLit); ok && basicLit.Kind == token.STRING {
-				// Remove quotes from string literal
-				value := basicLit.Value
-				if len(value) >= 2 && value[0] == '"' && value[len(value)-1] == '"' {
-					result = append(result, value[1:len(value)-1])
-				}
-			}
-		}
-	}
-
-	return result
-}
-
 // copyGsPackageWithDependencies copies a gs/ package and all its dependencies recursively
 // It tracks already processed packages to avoid infinite loops and duplicate work
 func (c *Compiler) copyGsPackageWithDependencies(packagePath string, processedPackages map[string]bool, result *CompilationResult) error {