goscript 0.0.18 → 0.0.19

package/compiler/compiler.go

@@ -628,6 +628,18 @@ func (c *GoToTSCompiler) WriteZeroValueForType(typ any) {
 		default:
 			c.tsw.WriteLiterally("0")
 		}
+	case *types.Named:
+		// Handle named types, especially struct types
+		if _, isStruct := t.Underlying().(*types.Struct); isStruct {
+			// Initialize struct types with a new instance
+			c.tsw.WriteLiterallyf("new %s()", t.Obj().Name())
+			return
+		}
+		// For other named types, use the zero value of the underlying type
+		c.WriteZeroValueForType(t.Underlying())
+	case *types.Struct:
+		// For anonymous struct types, initialize with {}
+		c.tsw.WriteLiterally("{}")
 	default:
 		c.tsw.WriteLiterally("null")
 	}
@@ -1492,12 +1504,12 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 							if _, isFuncType := typeName.Type().Underlying().(*types.Signature); isFuncType {
 								// For function types, we need to add a __goTypeName property
 								c.tsw.WriteLiterally("Object.assign(")
-								
+
 								// Write the argument first
 								if err := c.WriteValueExpr(exp.Args[0]); err != nil {
 									return fmt.Errorf("failed to write argument for function type cast: %w", err)
 								}
-								
+
 								// Add the __goTypeName property with the function type name
 								c.tsw.WriteLiterallyf(", { __goTypeName: '%s' })", funIdent.String())
 								return nil // Handled function type cast
@@ -1507,7 +1519,7 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 								if err := c.WriteValueExpr(exp.Args[0]); err != nil {
 									return fmt.Errorf("failed to write argument for type cast: %w", err)
 								}
-								
+
 								// Then use the TypeScript "as" operator with the type name
 								c.tsw.WriteLiterallyf(" as %s)", funIdent.String())
 								return nil // Handled non-function type cast
@@ -4600,8 +4612,61 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 			}
 		}
 
-		// Write the left-hand side as a destructuring pattern
-		// For token.DEFINE, we've already declared any new variables above
+		
+		// First, collect all the selector expressions to identify variables that need to be initialized
+		hasSelectors := false
+		for _, lhsExpr := range lhs {
+			if _, ok := lhsExpr.(*ast.SelectorExpr); ok {
+				hasSelectors = true
+				break
+			}
+		}
+		
+		// If we have selector expressions, we need to ensure variables are initialized
+		// before the destructuring assignment
+		if hasSelectors {
+			c.tsw.WriteLiterally("{")
+			c.tsw.WriteLine("")
+			
+			// Write a temporary variable to hold the function call result
+			c.tsw.WriteLiterally("  const _tmp = ")
+			if err := c.WriteValueExpr(callExpr); err != nil {
+				return fmt.Errorf("failed to write RHS call expression in assignment: %w", err)
+			}
+			c.tsw.WriteLine("")
+			
+			for i, lhsExpr := range lhs {
+				// Skip underscore variables
+				if ident, ok := lhsExpr.(*ast.Ident); ok && ident.Name == "_" {
+					continue
+				}
+				
+				// Write the LHS with indentation
+				c.tsw.WriteLiterally("  ")
+				if ident, ok := lhsExpr.(*ast.Ident); ok {
+					c.WriteIdent(ident, false)
+				} else if selectorExpr, ok := lhsExpr.(*ast.SelectorExpr); ok {
+					if err := c.WriteValueExpr(selectorExpr); err != nil {
+						return fmt.Errorf("failed to write selector expression in LHS: %w", err)
+					}
+				} else {
+					return errors.Errorf("unhandled LHS expression in assignment: %T", lhsExpr)
+				}
+				
+				// Write the assignment
+				c.tsw.WriteLiterallyf(" = _tmp[%d]", i)
+				// Always add a newline after each assignment
+				c.tsw.WriteLine("")
+			}
+			
+			// Close the block scope
+			c.tsw.WriteLiterally("}")
+			c.tsw.WriteLine("")
+			
+			return nil
+		}
+		
+		// For simple cases without selector expressions, use array destructuring
 		c.tsw.WriteLiterally("[")
 
 		for i, lhsExpr := range lhs {
@@ -4610,11 +4675,15 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 			}
 
 			if ident, ok := lhsExpr.(*ast.Ident); ok {
-				if ident.Name == "_" {
-					// For underscore variables, use empty slots in destructuring pattern
-				} else {
+				// For underscore variables, use empty slots in destructuring pattern
+				if ident.Name != "_" {
 					c.WriteIdent(ident, false)
 				}
+			} else if selectorExpr, ok := lhsExpr.(*ast.SelectorExpr); ok {
+				// Handle selector expressions (e.g., a.b) by using WriteValueExpr
+				if err := c.WriteValueExpr(selectorExpr); err != nil {
+					return fmt.Errorf("failed to write selector expression in LHS: %w", err)
+				}
 			} else {
 				// Should not happen for valid Go code in this context, but handle defensively
 				return errors.Errorf("unhandled LHS expression in destructuring: %T", lhsExpr)
@@ -5690,14 +5759,14 @@ func (c *GoToTSCompiler) writeTypeAssertion(lhs []ast.Expr, typeAssertExpr *ast.
 		// For function types, create a type descriptor object with params and results
 		c.tsw.WriteLiterally("{")
 		c.tsw.WriteLiterally("kind: $.TypeKind.Function")
-		
+
 		// Add name if this is a named function type
 		if namedType := c.pkg.TypesInfo.TypeOf(typeExpr); namedType != nil {
 			if named, ok := namedType.(*types.Named); ok {
 				c.tsw.WriteLiterallyf(", name: '%s'", named.Obj().Name())
 			}
 		}
-		
+
 		// Add params if present
 		if typeExpr.Params != nil && len(typeExpr.Params.List) > 0 {
 			c.tsw.WriteLiterally(", params: [")
@@ -5709,7 +5778,7 @@ func (c *GoToTSCompiler) writeTypeAssertion(lhs []ast.Expr, typeAssertExpr *ast.
 			}
 			c.tsw.WriteLiterally("]")
 		}
-		
+
 		// Add results if present
 		if typeExpr.Results != nil && len(typeExpr.Results.List) > 0 {
 			c.tsw.WriteLiterally(", results: [")
@@ -5721,7 +5790,7 @@ func (c *GoToTSCompiler) writeTypeAssertion(lhs []ast.Expr, typeAssertExpr *ast.
 			}
 			c.tsw.WriteLiterally("]")
 		}
-		
+
 		c.tsw.WriteLiterally("}")
 	case *ast.Ident:
 		if isPrimitiveType(typeExpr.Name) {
@@ -5747,10 +5816,10 @@ func (c *GoToTSCompiler) writeTypeAssertion(lhs []ast.Expr, typeAssertExpr *ast.
 						c.tsw.WriteLiterally("{")
 						c.tsw.WriteLiterally("kind: $.TypeKind.Function")
 						c.tsw.WriteLiterallyf(", name: '%s'", typeExpr.Name)
-						
+
 						// Get the underlying signature
 						signature := named.Underlying().(*types.Signature)
-						
+
 						// Add params if present
 						params := signature.Params()
 						if params != nil && params.Len() > 0 {
@@ -5763,19 +5832,19 @@ func (c *GoToTSCompiler) writeTypeAssertion(lhs []ast.Expr, typeAssertExpr *ast.
 								param := params.At(i)
 								c.tsw.WriteLiterally("{")
 								c.tsw.WriteLiterally("kind: $.TypeKind.Basic, ")
-								
+
 								typeName := param.Type().String()
 								if tsType, ok := GoBuiltinToTypescript(typeName); ok {
 									c.tsw.WriteLiterallyf("name: '%s'", tsType)
 								} else {
 									c.tsw.WriteLiterallyf("name: '%s'", typeName)
 								}
-								
+
 								c.tsw.WriteLiterally("}")
 							}
 							c.tsw.WriteLiterally("]")
 						}
-						
+
 						// Add results if present
 						results := signature.Results()
 						if results != nil && results.Len() > 0 {
@@ -5787,24 +5856,24 @@ func (c *GoToTSCompiler) writeTypeAssertion(lhs []ast.Expr, typeAssertExpr *ast.
 								result := results.At(i)
 								c.tsw.WriteLiterally("{")
 								c.tsw.WriteLiterally("kind: $.TypeKind.Basic, ")
-								
+
 								typeName := result.Type().String()
 								if tsType, ok := GoBuiltinToTypescript(typeName); ok {
 									c.tsw.WriteLiterallyf("name: '%s'", tsType)
 								} else {
 									c.tsw.WriteLiterallyf("name: '%s'", typeName)
 								}
-								
+
 								c.tsw.WriteLiterally("}")
 							}
 							c.tsw.WriteLiterally("]")
 						}
-						
+
 						c.tsw.WriteLiterally("}")
 					}
 				}
 			}
-			
+
 			// Default case for non-function named types
 			if !isFunctionType {
 				c.tsw.WriteLiterallyf("'%s'", typeExpr.Name)
@@ -5924,14 +5993,14 @@ func (c *GoToTSCompiler) writeTypeDescription(typeExpr ast.Expr) {
 		// For function types, create a type descriptor object with params and results
 		c.tsw.WriteLiterally("{")
 		c.tsw.WriteLiterally("kind: $.TypeKind.Function")
-		
+
 		// Add name if this is a named function type
 		if namedType := c.pkg.TypesInfo.TypeOf(typeExpr); namedType != nil {
 			if named, ok := namedType.(*types.Named); ok {
 				c.tsw.WriteLiterallyf(", name: '%s'", named.Obj().Name())
 			}
 		}
-		
+
 		// Add params if present
 		if t.Params != nil && len(t.Params.List) > 0 {
 			c.tsw.WriteLiterally(", params: [")
@@ -5943,7 +6012,7 @@ func (c *GoToTSCompiler) writeTypeDescription(typeExpr ast.Expr) {
 			}
 			c.tsw.WriteLiterally("]")
 		}
-		
+
 		// Add results if present
 		if t.Results != nil && len(t.Results.List) > 0 {
 			c.tsw.WriteLiterally(", results: [")
@@ -5955,7 +6024,7 @@ func (c *GoToTSCompiler) writeTypeDescription(typeExpr ast.Expr) {
 			}
 			c.tsw.WriteLiterally("]")
 		}
-		
+
 		c.tsw.WriteLiterally("}")
 		return
 	case *ast.ChanType:

package/compiler/compiler_test.go

@@ -48,7 +48,7 @@ func TestCompliance(t *testing.T) {
 	}
 
 	// limit concurrency
-	simulLimit := make(chan struct{}, runtime.GOMAXPROCS(-1))
+	simulLimit := make(chan struct{}, runtime.GOMAXPROCS(-1)*2)
 	for range cap(simulLimit) {
 		simulLimit <- struct{}{}
 	}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "goscript",
   "description": "Go to TypeScript transpiler",
-  "version": "0.0.18",
+  "version": "0.0.19",
   "author": {
     "name": "Aperture Robotics LLC.",
     "email": "support@aperture.us",