goscript 0.0.58 → 0.0.59

package/compiler/assignment.go

@@ -1,11 +1,10 @@
 package compiler
 
 import (
+	"fmt"
 	"go/ast"
 	"go/token"
 	"go/types"
-
-	"golang.org/x/tools/go/packages"
 )
 
 // writeAssignmentCore handles the central logic for translating Go assignment
@@ -37,75 +36,19 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 	// Handle blank identifier (_) on the LHS for single assignments
 	if len(lhs) == 1 && len(rhs) == 1 {
 		if ident, ok := lhs[0].(*ast.Ident); ok && ident.Name == "_" {
-			// Evaluate the RHS expression for side effects, but don't assign it
-			c.tsw.WriteLiterally("/* _ = */ ")
-			if err := c.WriteValueExpr(rhs[0]); err != nil {
-				return err
-			}
-			return nil
+			return c.writeBlankIdentifierAssign(rhs[0])
 		}
 
-		// Handle the special case of "*p = val" (assignment to dereferenced pointer)
+		// Handle the special case of "*p = val" or "*p += val" (assignment to dereferenced pointer)
 		if starExpr, ok := lhs[0].(*ast.StarExpr); ok {
-			// For *p = val, we need to set p's .value property
-			// Write "p!.value = " for the underlying value
-			if err := c.WriteValueExpr(starExpr.X); err != nil { // p in *p
-				return err
-			}
-			c.tsw.WriteLiterally("!.value = ") // Add non-null assertion for TS safety
-
-			// Handle the RHS expression (potentially adding .clone() for structs)
-			if shouldApplyClone(c.pkg, rhs[0]) {
-				// When cloning for value assignment, mark the result as struct value
-				c.tsw.WriteLiterally("$.markAsStructValue(")
-				if err := c.WriteValueExpr(rhs[0]); err != nil {
-					return err
-				}
-				c.tsw.WriteLiterally(".clone())")
-			} else {
-				if err := c.WriteValueExpr(rhs[0]); err != nil {
-					return err
-				}
-			}
-			return nil
+			return c.writePointerDerefAssign(starExpr, rhs[0], tok)
 		}
 
 		// Handle variable referenced variables in declarations
 		if addDeclaration && tok == token.DEFINE {
-			// Determine if LHS is variable referenced
-			isLHSVarRefed := false
-			var lhsIdent *ast.Ident
-			var lhsObj types.Object
-
-			if ident, ok := lhs[0].(*ast.Ident); ok {
-				lhsIdent = ident
-				// Get the types.Object from the identifier
-				if use, ok := c.pkg.TypesInfo.Uses[ident]; ok {
-					lhsObj = use
-				} else if def, ok := c.pkg.TypesInfo.Defs[ident]; ok {
-					lhsObj = def
-				}
-
-				// Check if this variable needs to be variable referenced
-				if lhsObj != nil && c.analysis.NeedsVarRef(lhsObj) {
-					isLHSVarRefed = true
-				}
-			}
-
-			// Handle short declaration of variable referenced variables
-			if isLHSVarRefed && lhsIdent != nil {
-				c.tsw.WriteLiterally("let ")
-				// Just write the identifier name without .value
-				c.tsw.WriteLiterally(c.sanitizeIdentifier(lhsIdent.Name))
-				// No type annotation, allow TypeScript to infer it from varRef.
-				c.tsw.WriteLiterally(" = ")
-
-				// Create the variable reference for the initializer
-				c.tsw.WriteLiterally("$.varRef(")
-				if err := c.WriteValueExpr(rhs[0]); err != nil {
-					return err
-				}
-				c.tsw.WriteLiterally(")")
+			if handled, err := c.writeVarRefShortDecl(lhs[0], rhs[0]); err != nil {
+				return err
+			} else if handled {
 				return nil
 			}
 
@@ -115,82 +58,7 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 
 	// Special case for multi-variable assignment to handle array element swaps
 	if len(lhs) > 1 && len(rhs) > 1 {
-		// Check if this is an array element swap pattern (common pattern a[i], a[j] = a[j], a[i])
-		// Identify if we're dealing with array index expressions that might need null assertions
-		allIndexExprs := true
-		for _, expr := range append(lhs, rhs...) {
-			_, isIndexExpr := expr.(*ast.IndexExpr)
-			if !isIndexExpr {
-				allIndexExprs = false
-				break
-			}
-		}
-
-		// Add semicolon before destructuring assignment to prevent TypeScript
-		// from interpreting it as array access on the previous line
-		if tok != token.DEFINE {
-			c.tsw.WriteLiterally(";")
-		}
-
-		// Use array destructuring for multi-variable assignments
-		c.tsw.WriteLiterally("[")
-		for i, l := range lhs {
-			if i != 0 {
-				c.tsw.WriteLiterally(", ")
-			}
-
-			// Handle blank identifier
-			if ident, ok := l.(*ast.Ident); ok && ident.Name == "_" {
-				// If it's a blank identifier, we write nothing,
-				// leaving an empty slot in the destructuring array.
-			} else if indexExpr, ok := l.(*ast.IndexExpr); ok && allIndexExprs { // MODIFICATION: Added 'else if'
-				// Note: We don't use WriteIndexExpr here because we need direct array access for swapping
-				if err := c.WriteValueExpr(indexExpr.X); err != nil {
-					return err
-				}
-				c.tsw.WriteLiterally("!") // non-null assertion
-				c.tsw.WriteLiterally("[")
-				if err := c.WriteValueExpr(indexExpr.Index); err != nil {
-					return err
-				}
-				c.tsw.WriteLiterally("]")
-			} else {
-				// Normal case - write the entire expression
-				if err := c.WriteValueExpr(l); err != nil {
-					return err
-				}
-			}
-		}
-		c.tsw.WriteLiterally("] = [")
-		for i, r := range rhs {
-			if i != 0 {
-				c.tsw.WriteLiterally(", ")
-			}
-			if indexExpr, ok := r.(*ast.IndexExpr); ok && allIndexExprs {
-				// Note: We don't use WriteIndexExpr here because we need direct array access for swapping
-				if err := c.WriteValueExpr(indexExpr.X); err != nil {
-					return err
-				}
-				c.tsw.WriteLiterally("!")
-				c.tsw.WriteLiterally("[")
-				if err := c.WriteValueExpr(indexExpr.Index); err != nil {
-					return err
-				}
-				c.tsw.WriteLiterally("]")
-			} else if callExpr, isCallExpr := r.(*ast.CallExpr); isCallExpr {
-				// If the RHS is a function call, write it as a call
-				if err := c.WriteCallExpr(callExpr); err != nil {
-					return err
-				}
-			} else {
-				// Normal case - write the entire expression
-				if err := c.WriteValueExpr(r); err != nil {
-					return err
-				}
-			}
-		}
-		c.tsw.WriteLiterally("]")
-		return nil
+		return c.writeMultiVarAssign(lhs, rhs, tok)
 	}
 
 	// --- Logic for assignments ---
@@ -259,13 +127,8 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 					// Determine if LHS is variable referenced
 					isLHSVarRefed := false
 					var lhsObj types.Object
-
 					// Get the types.Object from the identifier
-					if use, ok := c.pkg.TypesInfo.Uses[lhsExprIdent]; ok {
-						lhsObj = use
-					} else if def, ok := c.pkg.TypesInfo.Defs[lhsExprIdent]; ok {
-						lhsObj = def
-					}
+					lhsObj = c.objectOfIdent(lhsExprIdent)
 
 					// Check if this variable needs to be variable referenced
 					if lhsObj != nil && c.analysis.NeedsVarRef(lhsObj) {
@@ -290,20 +153,8 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 		// Continue, we've already written part of the mapSet() function call
 	} else {
 		c.tsw.WriteLiterally(" ")
-
-		// Special handling for &^= (bitwise AND NOT assignment)
-		if tok == token.AND_NOT_ASSIGN {
-			// Transform x &^= y to x &= ~(y)
-			c.tsw.WriteLiterally("&= ~(")
-		} else {
-			tokStr, ok := TokenToTs(tok) // Use explicit gstypes alias
-			if !ok {
-				c.tsw.WriteLiterally("?= ")
-				c.tsw.WriteCommentLine("Unknown token " + tok.String())
-			} else {
-				c.tsw.WriteLiterally(tokStr)
-			}
-			c.tsw.WriteLiterally(" ")
+		if err := c.writeAssignmentOperator(tok); err != nil {
+			return err
 		}
 	}
 
@@ -327,10 +178,7 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 		// Check if RHS is an identifier (variable name)
 		rhsIdent, rhsIsIdent := r.(*ast.Ident)
 		if rhsIsIdent {
-			rhsObj = c.pkg.TypesInfo.Uses[rhsIdent]
-			if rhsObj == nil {
-				rhsObj = c.pkg.TypesInfo.Defs[rhsIdent]
-			}
+			rhsObj = c.objectOfIdent(rhsIdent)
 
 			// Important: For struct copying, we need to check if the variable itself is variable referenced
 			// Important: For struct copying, we need to check if the variable needs variable referenced access
@@ -440,73 +288,171 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 	return nil
 }
 
-// shouldApplyClone determines whether a `.clone()` method call should be appended
-// to the TypeScript translation of a Go expression `rhs` when it appears on the
-// right-hand side of an assignment. This is primarily to emulate Go's value
-// semantics for struct assignments, where assigning one struct variable to another
-// creates a copy of the struct.
-//
-// It uses `go/types` information (`pkg.TypesInfo`) to determine the type of `rhs`.
-//   - If `rhs` is identified as a struct type (either directly, as a named type
-//     whose underlying type is a struct, or an unnamed type whose underlying type
-//     is a struct), it returns `true`.
-//   - An optimization: if `rhs` is a composite literal (`*ast.CompositeLit`),
-//     it returns `false` because a composite literal already produces a new value,
-//     so cloning is unnecessary.
-//   - If type information is unavailable or `rhs` is not a struct type, it returns `false`.
-//
-// This function is crucial for ensuring that assignments of struct values in
-// TypeScript behave like copies, as they do in Go, rather than reference assignments.
-func shouldApplyClone(pkg *packages.Package, rhs ast.Expr) bool {
-	if pkg == nil || pkg.TypesInfo == nil {
-		// Cannot determine type without type info, default to no clone
-		return false
+// writeBlankIdentifierAssign handles assignment to blank identifier (_)
+func (c *GoToTSCompiler) writeBlankIdentifierAssign(rhs ast.Expr) error {
+	c.tsw.WriteLiterally("/* _ = */ ")
+	return c.WriteValueExpr(rhs)
+}
+
+// writePointerDerefAssign handles assignments to dereferenced pointers (*p = val)
+func (c *GoToTSCompiler) writePointerDerefAssign(starExpr *ast.StarExpr, rhs ast.Expr, tok token.Token) error {
+	// Write pointer dereference
+	if ident, ok := starExpr.X.(*ast.Ident); ok {
+		obj := c.objectOfIdent(ident)
+		if obj != nil && c.analysis.NeedsVarRef(obj) {
+			c.WriteIdent(ident, true)
+			c.tsw.WriteLiterally("!.value")
+		} else {
+			c.WriteIdent(ident, false)
+			c.tsw.WriteLiterally("!.value")
+		}
+	} else {
+		if err := c.WriteValueExpr(starExpr.X); err != nil {
+			return err
+		}
+		c.tsw.WriteLiterally("!.value")
 	}
 
-	// Get the type of the RHS expression
-	var exprType types.Type
-
-	// Handle identifiers (variables) directly - the most common case
-	if ident, ok := rhs.(*ast.Ident); ok {
-		if obj := pkg.TypesInfo.Uses[ident]; obj != nil {
-			// Get the type directly from the object
-			exprType = obj.Type()
-		} else if obj := pkg.TypesInfo.Defs[ident]; obj != nil {
-			// Also check Defs map for definitions
-			exprType = obj.Type()
+	// Write assignment operator
+	if tok == token.AND_NOT_ASSIGN {
+		c.tsw.WriteLiterally(" &= ~(")
+	} else {
+		c.tsw.WriteLiterally(" ")
+		tokStr, ok := TokenToTs(tok)
+		if !ok {
+			return fmt.Errorf("unknown assignment token: %s", tok.String())
 		}
+		c.tsw.WriteLiterally(tokStr)
+		c.tsw.WriteLiterally(" ")
+	}
+
+	// Write RHS with cloning if needed
+	if shouldApplyClone(c.pkg, rhs) {
+		c.tsw.WriteLiterally("$.markAsStructValue(")
+		if err := c.WriteValueExpr(rhs); err != nil {
+			return err
+		}
+		c.tsw.WriteLiterally(".clone())")
+	} else {
+		if err := c.WriteValueExpr(rhs); err != nil {
+			return err
+		}
+	}
+
+	if tok == token.AND_NOT_ASSIGN {
+		c.tsw.WriteLiterally(")")
 	}
 
-	// If we couldn't get the type from Uses/Defs, try getting it from Types
-	if exprType == nil {
-		if tv, found := pkg.TypesInfo.Types[rhs]; found && tv.Type != nil {
-			exprType = tv.Type
+	return nil
+}
+
+// writeVarRefShortDecl handles short declarations of varrefed variables
+// Returns true if handled, false otherwise
+func (c *GoToTSCompiler) writeVarRefShortDecl(lhs, rhs ast.Expr) (bool, error) {
+	ident, ok := lhs.(*ast.Ident)
+	if !ok {
+		return false, nil
+	}
+
+	obj := c.objectOfIdent(ident)
+	if obj == nil || !c.analysis.NeedsVarRef(obj) {
+		return false, nil
+	}
+
+	c.tsw.WriteLiterally("let ")
+	c.tsw.WriteLiterally(c.sanitizeIdentifier(ident.Name))
+	c.tsw.WriteLiterally(" = $.varRef(")
+	if err := c.WriteValueExpr(rhs); err != nil {
+		return false, err
+	}
+	c.tsw.WriteLiterally(")")
+	return true, nil
+}
+
+// writeMultiVarAssign handles multi-variable assignments with array destructuring
+func (c *GoToTSCompiler) writeMultiVarAssign(lhs, rhs []ast.Expr, tok token.Token) error {
+	// Check if all expressions are index expressions (for swap optimization)
+	allIndexExprs := true
+	for _, expr := range append(lhs, rhs...) {
+		if _, isIndexExpr := expr.(*ast.IndexExpr); !isIndexExpr {
+			allIndexExprs = false
+			break
 		}
 	}
 
-	// No type information available
-	if exprType == nil {
-		return false
+	// Add semicolon to prevent TypeScript parsing issues
+	if tok != token.DEFINE {
+		c.tsw.WriteLiterally(";")
 	}
 
-	// Optimization: If it's a composite literal for a struct, no need to clone
-	// as it's already a fresh value
-	if _, isCompositeLit := rhs.(*ast.CompositeLit); isCompositeLit {
-		return false
+	// Write LHS array destructuring pattern
+	c.tsw.WriteLiterally("[")
+	for i, l := range lhs {
+		if i != 0 {
+			c.tsw.WriteLiterally(", ")
+		}
+
+		if ident, ok := l.(*ast.Ident); ok && ident.Name == "_" {
+			// Blank identifier - leave empty slot
+		} else if indexExpr, ok := l.(*ast.IndexExpr); ok && allIndexExprs {
+			if err := c.WriteValueExpr(indexExpr.X); err != nil {
+				return err
+			}
+			c.tsw.WriteLiterally("![")
+			if err := c.WriteValueExpr(indexExpr.Index); err != nil {
+				return err
+			}
+			c.tsw.WriteLiterally("]")
+		} else {
+			if err := c.WriteValueExpr(l); err != nil {
+				return err
+			}
+		}
 	}
 
-	// Check if it's a struct type (directly, through named type, or underlying)
-	if named, ok := exprType.(*types.Named); ok {
-		if _, isStruct := named.Underlying().(*types.Struct); isStruct {
-			return true // Named struct type
+	// Write RHS array
+	c.tsw.WriteLiterally("] = [")
+	for i, r := range rhs {
+		if i != 0 {
+			c.tsw.WriteLiterally(", ")
 		}
-	} else if _, ok := exprType.(*types.Struct); ok {
-		return true // Direct struct type
-	} else if underlying := exprType.Underlying(); underlying != nil {
-		if _, isStruct := underlying.(*types.Struct); isStruct {
-			return true // Underlying is a struct
+
+		if indexExpr, ok := r.(*ast.IndexExpr); ok && allIndexExprs {
+			if err := c.WriteValueExpr(indexExpr.X); err != nil {
+				return err
+			}
+			c.tsw.WriteLiterally("![")
+			if err := c.WriteValueExpr(indexExpr.Index); err != nil {
+				return err
+			}
+			c.tsw.WriteLiterally("]")
+		} else if callExpr, isCallExpr := r.(*ast.CallExpr); isCallExpr {
+			if err := c.WriteCallExpr(callExpr); err != nil {
+				return err
+			}
+		} else {
+			if err := c.WriteValueExpr(r); err != nil {
+				return err
+			}
 		}
 	}
+	c.tsw.WriteLiterally("]")
 
-	return false // Not a struct, do not apply clone
+	return nil
+}
+
+// writeAssignmentOperator writes the TypeScript assignment operator
+func (c *GoToTSCompiler) writeAssignmentOperator(tok token.Token) error {
+	if tok == token.AND_NOT_ASSIGN {
+		c.tsw.WriteLiterally("&= ~(")
+		return nil
+	}
+
+	tokStr, ok := TokenToTs(tok)
+	if !ok {
+		return fmt.Errorf("unknown assignment token: %s", tok.String())
+	}
+	c.tsw.WriteLiterally(tokStr)
+	c.tsw.WriteLiterally(" ")
+	return nil
 }

package/compiler/compiler.go

@@ -249,10 +249,14 @@ func (c *Compiler) CompilePackages(ctx context.Context, patterns ...string) (*Co
 			}
 		}
 
-		// Skip packages that failed to load
+		// Fail fast on packages that failed to load to avoid hiding errors
 		if len(pkg.Errors) > 0 {
-			c.le.WithError(pkg.Errors[0]).Warnf("Skipping package %s due to errors", pkg.PkgPath)
-			continue
+			var msgs []string
+			for _, e := range pkg.Errors {
+				// packages.Error is a struct; collect all messages
+				msgs = append(msgs, e.Error())
+			}
+			return nil, fmt.Errorf("package %s has load errors: %s", pkg.PkgPath, strings.Join(msgs, "; "))
 		}
 
 		pkgCompiler, err := NewPackageCompiler(c.le, &c.config, pkg, allPackages)
@@ -593,7 +597,7 @@ func (c *FileCompiler) Compile(ctx context.Context) error {
 	goWriter := NewGoToTSCompiler(c.codeWriter, c.pkg, c.Analysis)
 
 	// Add import for the goscript runtime using namespace import and alias
-	c.codeWriter.WriteLinef("import * as $ from %q;", "@goscript/builtin/index.js")
+	c.codeWriter.WriteLinef("import * as $ from %q", "@goscript/builtin/index.js")
 
 	// Check if there are any .pb.go files in this package and add imports for them
 	if err := c.addProtobufImports(); err != nil {
@@ -641,28 +645,14 @@ func (c *FileCompiler) Compile(ctx context.Context) error {
 				// Filter out protobuf types - they should be imported from .pb.js files, not .gs.js files
 				var nonProtobufTypes []string
 				for _, typeName := range typeImports {
-					// Check if this type is a protobuf type by looking for it in the package
+					// Check if this type is a protobuf type by looking at its type info
 					isProtobuf := false
 					if typeObj := c.pkg.Types.Scope().Lookup(typeName); typeObj != nil {
 						objType := typeObj.Type()
 						if namedType, ok := objType.(*types.Named); ok {
-							obj := namedType.Obj()
-							if obj != nil && obj.Pkg() != nil {
-								// Check if the type is defined in the current package and has a corresponding .pb.go file
-								if obj.Pkg() == c.pkg.Types {
-									// Check if there's a .pb.go file in the package that exports this type
-									// For now, we'll use a simple heuristic: if the type name ends with "Msg"
-									// and there's a .pb.go file in the package, assume it's a protobuf type
-									if strings.HasSuffix(typeName, "Msg") {
-										// Check if there are any .pb.go files in this package
-										for _, fileName := range c.pkg.CompiledGoFiles {
-											if strings.HasSuffix(fileName, ".pb.go") {
-												isProtobuf = true
-												break
-											}
-										}
-									}
-								}
+							// Use the same detection logic as codegen
+							if goWriter.isProtobufType(namedType) {
+								isProtobuf = true
 							}
 						}
 					}
@@ -720,6 +710,21 @@ func NewGoToTSCompiler(tsw *TSCodeWriter, pkg *packages.Package, analysis *Analy
 	}
 }
 
+// objectOfIdent returns the types.Object associated with the identifier.
+// It checks Uses first, then Defs, and returns nil if neither is found.
+func (c *GoToTSCompiler) objectOfIdent(ident *ast.Ident) types.Object {
+	if ident == nil || c.pkg == nil || c.pkg.TypesInfo == nil {
+		return nil
+	}
+	if obj := c.pkg.TypesInfo.Uses[ident]; obj != nil {
+		return obj
+	}
+	if obj := c.pkg.TypesInfo.Defs[ident]; obj != nil {
+		return obj
+	}
+	return nil
+}
+
 // getDeterministicID generates a deterministic unique ID based on file position
 // This replaces the non-deterministic Pos() values to ensure reproducible builds
 func (c *GoToTSCompiler) getDeterministicID(pos token.Pos) string {
@@ -778,11 +783,7 @@ func (c *GoToTSCompiler) WriteIdent(exp *ast.Ident, accessVarRefedValue bool) {
 	}
 
 	// Use TypesInfo to find the object associated with the identifier
-	var obj types.Object
-	obj = c.pkg.TypesInfo.Uses[exp]
-	if obj == nil {
-		obj = c.pkg.TypesInfo.Defs[exp]
-	}
+	obj := c.objectOfIdent(exp)
 
 	// Check if this identifier refers to a constant
 	if obj != nil {
@@ -1143,8 +1144,11 @@ func (c *Compiler) ReadGsPackageMetadata(gsSourcePath string) (*GsPackageMetadat
 	metaFilePath := filepath.Join(gsSourcePath, "meta.json")
 	content, err := gs.GsOverrides.ReadFile(metaFilePath)
 	if err != nil {
-		// No meta.json file found, return empty metadata
-		return metadata, nil
+		// Only treat missing file as "no metadata"; surface other errors
+		if os.IsNotExist(err) {
+			return metadata, nil
+		}
+		return nil, fmt.Errorf("failed to read meta.json in %s: %w", gsSourcePath, err)
 	}
 
 	// Parse the JSON content
@@ -1181,8 +1185,8 @@ func (c *Compiler) copyGsPackageWithDependencies(packagePath string, processedPa
 	// Read metadata to get dependencies
 	metadata, err := c.ReadGsPackageMetadata(gsSourcePath)
 	if err != nil {
-		c.le.WithError(err).Warnf("Failed to read metadata for gs package %s, continuing without dependencies", packagePath)
-		metadata = &GsPackageMetadata{Dependencies: []string{}}
+		// Surface metadata errors instead of silently continuing
+		return fmt.Errorf("failed to read metadata for gs package %s: %w", packagePath, err)
 	}
 
 	// Log dependencies if any are found