goscript 0.0.48 → 0.0.50

package/compiler/expr.go

@@ -294,70 +294,6 @@ func (c *GoToTSCompiler) isNamedNumericType(t types.Type) bool {
 	return false
 }
 
-// isWrapperType checks if a type is implemented as a wrapper class with valueOf() method
-// This is true for named types that have methods defined on them
-func (c *GoToTSCompiler) isWrapperType(t types.Type) bool {
-	if t == nil {
-		return false
-	}
-
-	// Follow any type aliases to get to the actual named type
-	namedType, ok := t.(*types.Named)
-	if !ok {
-		return false
-	}
-
-	// If the named type has methods, it's implemented as a class with valueOf()
-	numMethods := namedType.NumMethods()
-	return numMethods > 0
-}
-
-// needsValueOfForBitwiseOp checks if an operand in a bitwise operation needs .valueOf() to be called
-// This is needed for custom types (like FileMode) that have a valueOf() method and need to be treated as numbers
-func (c *GoToTSCompiler) needsValueOfForBitwiseOp(expr ast.Expr) bool {
-	if c.pkg == nil || c.pkg.TypesInfo == nil {
-		return false
-	}
-
-	exprType := c.pkg.TypesInfo.TypeOf(expr)
-	if exprType == nil {
-		return false
-	}
-
-	// Don't add valueOf() for basic literals (numeric, string, bool literals)
-	switch expr.(type) {
-	case *ast.BasicLit:
-		return false
-	}
-
-	// Check if this is a compile-time constant of a primitive type
-	if tv, ok := c.pkg.TypesInfo.Types[expr]; ok {
-		if tv.Value != nil {
-			// This is a constant expression - but only skip valueOf() if it's truly a primitive type
-			// (not a named type with methods that happens to be constant)
-			if _, isBasic := exprType.(*types.Basic); isBasic {
-				// Primitive constant, don't add valueOf()
-				return false
-			}
-		}
-	}
-
-	// Check if this type is implemented as a wrapper class with valueOf()
-	return c.isWrapperType(exprType)
-}
-
-// writeBitwiseOperand writes an operand for a bitwise operation, adding .valueOf() if needed
-func (c *GoToTSCompiler) writeBitwiseOperand(expr ast.Expr) error {
-	if c.needsValueOfForBitwiseOp(expr) {
-		if err := c.WriteValueExpr(expr); err != nil {
-			return err
-		}
-		c.tsw.WriteLiterally(".valueOf()")
-		return nil
-	}
-	return c.WriteValueExpr(expr)
-}
-
 // WriteBinaryExpr translates a Go binary expression (`ast.BinaryExpr`) into its
 // TypeScript equivalent.
 // It handles several cases:
@@ -542,16 +478,10 @@ func (c *GoToTSCompiler) WriteBinaryExpr(exp *ast.BinaryExpr) error {
 		c.tsw.WriteLiterally("(") // Add opening parenthesis for bitwise operations
 	}
 
-	// For bitwise operations, use special operand writing that adds .valueOf() when needed
-	if isBitwise {
-		if err := c.writeBitwiseOperand(exp.X); err != nil {
-			return fmt.Errorf("failed to write binary expression left operand: %w", err)
-		}
-	} else {
-		if err := c.WriteValueExpr(exp.X); err != nil {
-			return fmt.Errorf("failed to write binary expression left operand: %w", err)
-		}
+	if err := c.WriteValueExpr(exp.X); err != nil {
+		return fmt.Errorf("failed to write binary expression left operand: %w", err)
 	}
+
 	c.tsw.WriteLiterally(" ")
 	tokStr, ok := TokenToTs(exp.Op)
 	if !ok {
@@ -561,15 +491,8 @@ func (c *GoToTSCompiler) WriteBinaryExpr(exp *ast.BinaryExpr) error {
 	c.tsw.WriteLiterally(tokStr)
 	c.tsw.WriteLiterally(" ")
 
-	// For bitwise operations, use special operand writing that adds .valueOf() when needed
-	if isBitwise {
-		if err := c.writeBitwiseOperand(exp.Y); err != nil {
-			return fmt.Errorf("failed to write binary expression right operand: %w", err)
-		}
-	} else {
-		if err := c.WriteValueExpr(exp.Y); err != nil {
-			return fmt.Errorf("failed to write binary expression right operand: %w", err)
-		}
+	if err := c.WriteValueExpr(exp.Y); err != nil {
+		return fmt.Errorf("failed to write binary expression right operand: %w", err)
 	}
 
 	if isBitwise {

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.IsNamedBasicType(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.IsNamedBasicType(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)