goscript 0.0.47 → 0.0.49

package/compiler/gs_dependencies_test.go

@@ -30,7 +30,7 @@ func TestReadGsPackageMetadata(t *testing.T) {
 		t.Fatalf("Failed to read metadata: %v", err)
 	}
 
-	// Check that we found the expected dependency
+	// Check that we found the expected dependencies
 	if len(metadata.Dependencies) == 0 {
 		t.Errorf("Expected at least one dependency, got none")
 	}
@@ -47,6 +47,61 @@ func TestReadGsPackageMetadata(t *testing.T) {
 	if !foundIter {
 		t.Errorf("Expected to find 'iter' dependency, got dependencies: %v", metadata.Dependencies)
 	}
+
+	// Also check for other expected dependencies from the bytes package
+	expectedDeps := []string{"errors", "io", "iter", "unicode", "unicode/utf8", "unsafe"}
+	for _, expected := range expectedDeps {
+		found := false
+		for _, dep := range metadata.Dependencies {
+			if dep == expected {
+				found = true
+				break
+			}
+		}
+		if !found {
+			t.Errorf("Expected to find dependency '%s', got dependencies: %v", expected, metadata.Dependencies)
+		}
+	}
+}
+
+func TestReadGsPackageMetadataWithAsyncMethods(t *testing.T) {
+	// Create a basic compiler configuration
+	config := &Config{
+		OutputPath: "./test_output",
+		Dir:        ".",
+	}
+
+	// Create a logger (set to warn level to reduce noise in tests)
+	logger := logrus.New()
+	logger.SetLevel(logrus.WarnLevel)
+	le := logrus.NewEntry(logger)
+
+	// Create a compiler
+	comp, err := NewCompiler(config, le, nil)
+	if err != nil {
+		t.Fatalf("Failed to create compiler: %v", err)
+	}
+
+	// Test reading metadata from the sync package (which has async methods)
+	metadata, err := comp.ReadGsPackageMetadata("gs/sync")
+	if err != nil {
+		t.Fatalf("Failed to read metadata: %v", err)
+	}
+
+	// Check that we have async methods
+	if len(metadata.AsyncMethods) == 0 {
+		t.Errorf("Expected at least one async method for sync package, got none")
+	}
+
+	// Check for specific async methods
+	expectedAsyncMethods := []string{"Mutex.Lock", "WaitGroup.Wait", "RWMutex.Lock"}
+	for _, methodName := range expectedAsyncMethods {
+		if isAsync, exists := metadata.AsyncMethods[methodName]; !exists {
+			t.Errorf("Expected to find async method '%s'", methodName)
+		} else if !isAsync {
+			t.Errorf("Expected method '%s' to be async, but it's not", methodName)
+		}
+	}
 }
 
 func TestReadGsPackageMetadataNonExistent(t *testing.T) {
@@ -77,4 +132,8 @@ func TestReadGsPackageMetadataNonExistent(t *testing.T) {
 	if len(metadata.Dependencies) != 0 {
 		t.Errorf("Expected empty dependencies for non-existent package, got: %v", metadata.Dependencies)
 	}
+
+	if len(metadata.AsyncMethods) != 0 {
+		t.Errorf("Expected empty async methods for non-existent package, got: %v", metadata.AsyncMethods)
+	}
 }

package/compiler/spec-value.go

@@ -236,46 +236,74 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 				} else {
 					// Check if this is a named type with methods and the initializer is a basic value
 					if namedType, isNamed := goType.(*types.Named); isNamed {
-						typeName := namedType.Obj().Name()
-						if c.hasReceiverMethods(typeName) {
-							// Check if the initializer is a basic literal or simple value that needs wrapping
-							needsConstructor := false
-							switch expr := initializerExpr.(type) {
-							case *ast.BasicLit:
-								needsConstructor = true
-							case *ast.Ident:
-								// Check if it's a simple identifier (not a function call or complex expression)
-								if expr.Name != "nil" {
-									// Check if this identifier refers to a value of the underlying type
-									if obj := c.pkg.TypesInfo.Uses[expr]; obj != nil {
-										if objType := obj.Type(); objType != nil {
-											// If the identifier's type matches the underlying type, wrap it
-											if types.Identical(objType, namedType.Underlying()) {
-												needsConstructor = true
+						// Check if this is a wrapper type first
+						isWrapperType := c.analysis.IsWrapperType(namedType)
+						if isWrapperType {
+							// For wrapper types, no constructor wrapping needed
+							if shouldApplyClone(c.pkg, initializerExpr) {
+								if err := c.WriteValueExpr(initializerExpr); err != nil {
+									return err
+								}
+								c.tsw.WriteLiterally(".clone()")
+							} else {
+								if err := c.WriteValueExpr(initializerExpr); err != nil {
+									return err
+								}
+							}
+						} else {
+							typeName := namedType.Obj().Name()
+							if c.hasReceiverMethods(typeName) {
+								// Check if the initializer is a basic literal or simple value that needs wrapping
+								needsConstructor := false
+								switch expr := initializerExpr.(type) {
+								case *ast.BasicLit:
+									needsConstructor = true
+								case *ast.Ident:
+									// Check if it's a simple identifier (not a function call or complex expression)
+									if expr.Name != "nil" {
+										// Check if this identifier refers to a value of the underlying type
+										if obj := c.pkg.TypesInfo.Uses[expr]; obj != nil {
+											if objType := obj.Type(); objType != nil {
+												// If the identifier's type matches the underlying type, wrap it
+												if types.Identical(objType, namedType.Underlying()) {
+													needsConstructor = true
+												}
 											}
 										}
 									}
-								}
-							case *ast.CallExpr:
-								// Check if this is a make() call that returns the underlying type
-								if funIdent, ok := expr.Fun.(*ast.Ident); ok && funIdent.Name == "make" {
-									// Check if the make call returns a type that matches the underlying type
-									if exprType := c.pkg.TypesInfo.TypeOf(expr); exprType != nil {
-										if types.Identical(exprType, namedType.Underlying()) {
-											needsConstructor = true
+								case *ast.CallExpr:
+									// Check if this is a make() call that returns the underlying type
+									if funIdent, ok := expr.Fun.(*ast.Ident); ok && funIdent.Name == "make" {
+										// Check if the make call returns a type that matches the underlying type
+										if exprType := c.pkg.TypesInfo.TypeOf(expr); exprType != nil {
+											if types.Identical(exprType, namedType.Underlying()) {
+												needsConstructor = true
+											}
 										}
 									}
 								}
-							}
 
-							if needsConstructor {
-								c.tsw.WriteLiterallyf("new %s(", typeName)
-								if err := c.WriteValueExpr(initializerExpr); err != nil {
-									return err
+								if needsConstructor {
+									c.tsw.WriteLiterallyf("new %s(", typeName)
+									if err := c.WriteValueExpr(initializerExpr); err != nil {
+										return err
+									}
+									c.tsw.WriteLiterally(")")
+								} else {
+									// Regular initializer for named type (e.g., function call that returns the type)
+									if shouldApplyClone(c.pkg, initializerExpr) {
+										if err := c.WriteValueExpr(initializerExpr); err != nil {
+											return err
+										}
+										c.tsw.WriteLiterally(".clone()")
+									} else {
+										if err := c.WriteValueExpr(initializerExpr); err != nil {
+											return err
+										}
+									}
 								}
-								c.tsw.WriteLiterally(")")
 							} else {
-								// Regular initializer for named type (e.g., function call that returns the type)
+								// Named type without methods, handle normally
 								if shouldApplyClone(c.pkg, initializerExpr) {
 									if err := c.WriteValueExpr(initializerExpr); err != nil {
 										return err
@@ -287,18 +315,6 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 									}
 								}
 							}
-						} else {
-							// Named type without methods, handle normally
-							if shouldApplyClone(c.pkg, initializerExpr) {
-								if err := c.WriteValueExpr(initializerExpr); err != nil {
-									return err
-								}
-								c.tsw.WriteLiterally(".clone()")
-							} else {
-								if err := c.WriteValueExpr(initializerExpr); err != nil {
-									return err
-								}
-							}
 						}
 					} else {
 						// Regular initializer, clone if needed
@@ -316,16 +332,22 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 				}
 			} else {
 				// No initializer, use the zero value directly
-				// Check if this is a named type with methods
+				// Check if this is a wrapper type first
 				if namedType, isNamed := goType.(*types.Named); isNamed {
-					typeName := namedType.Obj().Name()
-					if c.hasReceiverMethods(typeName) {
-						// For named types with methods, create a new instance with zero value
-						c.tsw.WriteLiterallyf("new %s(", typeName)
-						c.WriteZeroValueForType(namedType.Underlying())
-						c.tsw.WriteLiterally(")")
-					} else {
+					isWrapperType := c.analysis.IsWrapperType(namedType)
+					if isWrapperType {
+						// For wrapper types, just use zero value directly
 						c.WriteZeroValueForType(goType)
+					} else {
+						typeName := namedType.Obj().Name()
+						if c.hasReceiverMethods(typeName) {
+							// For named types with methods, create a new instance with zero value
+							c.tsw.WriteLiterallyf("new %s(", typeName)
+							c.WriteZeroValueForType(namedType.Underlying())
+							c.tsw.WriteLiterally(")")
+						} else {
+							c.WriteZeroValueForType(goType)
+						}
 					}
 				} else {
 					c.WriteZeroValueForType(goType)