goscript 0.0.22 → 0.0.23

package/cmd/goscript/cmd_compile.go

@@ -9,8 +9,8 @@ import (
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 
-	// _ ensure we include the builtin package
-	_ "github.com/aperturerobotics/goscript/builtin"
+	// _ ensure we include the gs package
+	_ "github.com/aperturerobotics/goscript"
 )
 
 var (

package/compiler/analysis.go

@@ -41,6 +41,21 @@ type VariableUsageInfo struct {
 	Destinations []AssignmentInfo
 }
 
+// FunctionInfo consolidates function-related tracking data.
+type FunctionInfo struct {
+	IsAsync      bool
+	NamedReturns []string
+}
+
+// NodeInfo consolidates node-related tracking data.
+type NodeInfo struct {
+	NeedsDefer        bool
+	InAsyncContext    bool
+	IsBareReturn      bool
+	EnclosingFuncDecl *ast.FuncDecl
+	EnclosingFuncLit  *ast.FuncLit
+}
+
 // Analysis holds information gathered during the analysis phase of the Go code compilation.
 // This data is used to make decisions about how to generate TypeScript code.
 // Analysis is read-only after being built and should not be modified during code generation.
@@ -55,25 +70,25 @@ type Analysis struct {
 	// Cmap stores the comment map for the file
 	Cmap ast.CommentMap
 
-	// AsyncFuncs tracks which functions are async using the function's types.Object
-	// as the key to avoid false-positive matches with functions having the same name
-	AsyncFuncs map[types.Object]bool
+	// FunctionData consolidates function-related tracking into one map
+	FunctionData map[types.Object]*FunctionInfo
 
-	// NeedsDeferMap tracks nodes that need defer handling
-	NeedsDeferMap map[ast.Node]bool
+	// NodeData consolidates node-related tracking into one map
+	NodeData map[ast.Node]*NodeInfo
 
-	// IsInAsyncFunctionMap tracks nodes that are inside async functions
-	IsInAsyncFunctionMap map[ast.Node]bool
+	// Keep specialized maps that serve different purposes
+	// FuncLitData tracks function literal specific data since they don't have types.Object
+	FuncLitData map[*ast.FuncLit]*FunctionInfo
 }
 
 // NewAnalysis creates a new Analysis instance.
 func NewAnalysis() *Analysis {
 	return &Analysis{
-		VariableUsage:        make(map[types.Object]*VariableUsageInfo),
-		Imports:              make(map[string]*fileImport),
-		AsyncFuncs:           make(map[types.Object]bool),
-		NeedsDeferMap:        make(map[ast.Node]bool),
-		IsInAsyncFunctionMap: make(map[ast.Node]bool),
+		VariableUsage: make(map[types.Object]*VariableUsageInfo),
+		Imports:       make(map[string]*fileImport),
+		FunctionData:  make(map[types.Object]*FunctionInfo),
+		NodeData:      make(map[ast.Node]*NodeInfo),
+		FuncLitData:   make(map[*ast.FuncLit]*FunctionInfo),
 	}
 }
 
@@ -82,7 +97,11 @@ func (a *Analysis) NeedsDefer(node ast.Node) bool {
 	if node == nil {
 		return false
 	}
-	return a.NeedsDeferMap[node]
+	nodeInfo := a.NodeData[node]
+	if nodeInfo == nil {
+		return false
+	}
+	return nodeInfo.NeedsDefer
 }
 
 // IsInAsyncFunction returns whether the given node is inside an async function.
@@ -90,7 +109,11 @@ func (a *Analysis) IsInAsyncFunction(node ast.Node) bool {
 	if node == nil {
 		return false
 	}
-	return a.IsInAsyncFunctionMap[node]
+	nodeInfo := a.NodeData[node]
+	if nodeInfo == nil {
+		return false
+	}
+	return nodeInfo.InAsyncContext
 }
 
 // IsAsyncFunc returns whether the given object represents an async function.
@@ -98,7 +121,11 @@ func (a *Analysis) IsAsyncFunc(obj types.Object) bool {
 	if obj == nil {
 		return false
 	}
-	return a.AsyncFuncs[obj]
+	funcInfo := a.FunctionData[obj]
+	if funcInfo == nil {
+		return false
+	}
+	return funcInfo.IsAsync
 }
 
 // IsFuncLitAsync checks if a function literal is async based on our analysis.
@@ -106,8 +133,16 @@ func (a *Analysis) IsFuncLitAsync(funcLit *ast.FuncLit) bool {
 	if funcLit == nil {
 		return false
 	}
-	// Function literals are marked during analysis if they contain async operations
-	return a.IsInAsyncFunctionMap[funcLit]
+	// Check function literal specific data first
+	if funcInfo := a.FuncLitData[funcLit]; funcInfo != nil {
+		return funcInfo.IsAsync
+	}
+	// Fall back to node data for backwards compatibility
+	nodeInfo := a.NodeData[funcLit]
+	if nodeInfo == nil {
+		return false
+	}
+	return nodeInfo.InAsyncContext
 }
 
 // NeedsBoxed returns whether the given object needs to be boxed.
@@ -302,6 +337,12 @@ type analysisVisitor struct {
 
 	// currentFuncObj tracks the object of the function declaration we're currently analyzing
 	currentFuncObj types.Object
+
+	// currentFuncDecl tracks the *ast.FuncDecl of the function we're currently analyzing.
+	currentFuncDecl *ast.FuncDecl
+
+	// currentFuncLit tracks the *ast.FuncLit of the function literal we're currently analyzing.
+	currentFuncLit *ast.FuncLit
 }
 
 // getOrCreateUsageInfo retrieves or creates the VariableUsageInfo for a given object.
@@ -324,8 +365,11 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 		return nil
 	}
 
-	// Store async state for the current node
-	v.analysis.IsInAsyncFunctionMap[node] = v.inAsyncFunction
+	// Initialize and store async state for the current node
+	if v.analysis.NodeData[node] == nil {
+		v.analysis.NodeData[node] = &NodeInfo{}
+	}
+	v.analysis.NodeData[node].InAsyncContext = v.inAsyncFunction
 
 	switch n := node.(type) {
 	case *ast.GenDecl:
@@ -393,24 +437,40 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 		return v
 
 	case *ast.FuncDecl:
-		// Determine if this function declaration is async based on its body
+		// Save original states to restore after visiting
+		originalInAsync := v.inAsyncFunction
+		originalFuncObj := v.currentFuncObj
+		originalFuncDecl := v.currentFuncDecl
+		originalFuncLit := v.currentFuncLit
+		originalReceiver := v.currentReceiver
+
+		// Reset for current function
 		v.currentFuncName = n.Name.Name
+		v.currentFuncDecl = n
+		v.currentFuncLit = nil
+		v.currentReceiver = nil
+
+		// Determine if this function declaration is async based on its body
 		isAsync := false
 		if n.Body != nil {
 			containsAsyncOps := v.containsAsyncOperations(n.Body)
 			if containsAsyncOps {
 				// Get the object for this function declaration
 				if obj := v.pkg.TypesInfo.ObjectOf(n.Name); obj != nil {
-					v.analysis.AsyncFuncs[obj] = true
+					v.analysis.FunctionData[obj] = &FunctionInfo{
+						IsAsync:      true,
+						NamedReturns: v.getNamedReturns(n),
+					}
+					isAsync = true
 				}
-				isAsync = true
 			}
 		}
-		v.analysis.IsInAsyncFunctionMap[n] = isAsync
+		if v.analysis.NodeData[n] == nil {
+			v.analysis.NodeData[n] = &NodeInfo{}
+		}
+		v.analysis.NodeData[n].InAsyncContext = isAsync
 
 		// Set current receiver if this is a method
-		originalReceiver := v.currentReceiver
-		v.currentReceiver = nil // Reset for current function
 		if n.Recv != nil && len(n.Recv.List) > 0 {
 			// Assuming a single receiver for simplicity for now
 			if len(n.Recv.List[0].Names) > 0 {
@@ -427,22 +487,41 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 			}
 		}
 
-		// Save original states to restore after visiting
-		originalInAsync := v.inAsyncFunction
-		originalFuncObj := v.currentFuncObj
+		// Store named return variables
+		if n.Type != nil && n.Type.Results != nil {
+			var namedReturns []string
+			for _, field := range n.Type.Results.List {
+				for _, name := range field.Names {
+					namedReturns = append(namedReturns, name.Name)
+				}
+			}
+			if len(namedReturns) > 0 {
+				if obj := v.pkg.TypesInfo.ObjectOf(n.Name); obj != nil {
+					if v.analysis.FunctionData[obj] == nil {
+						v.analysis.FunctionData[obj] = &FunctionInfo{}
+					}
+					v.analysis.FunctionData[obj].NamedReturns = namedReturns
+				}
+			}
+		}
 
 		// Update visitor state for this function
 		v.inAsyncFunction = isAsync
 		v.currentFuncObj = v.pkg.TypesInfo.ObjectOf(n.Name)
-		v.analysis.IsInAsyncFunctionMap[n] = isAsync // Ensure FuncDecl node itself is marked
+		v.analysis.NodeData[n].InAsyncContext = isAsync // Ensure FuncDecl node itself is marked
 
-		// Check if the body contains any defer statements
-		if n.Body != nil && v.containsDefer(n.Body) {
-			v.analysis.NeedsDeferMap[n.Body] = true
-		}
+		if n.Body != nil {
+			// Check if the body contains any defer statements
+			if v.containsDefer(n.Body) {
+				if v.analysis.NodeData[n] == nil {
+					v.analysis.NodeData[n] = &NodeInfo{}
+				}
+				v.analysis.NodeData[n].NeedsDefer = true
+			}
 
-		// Visit the body with updated state
-		ast.Walk(v, n.Body)
+			// Visit the body with updated state
+			ast.Walk(v, n.Body)
+		}
 
 		// Restore states after visiting
 		defer func() {
@@ -450,21 +529,52 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 			v.inAsyncFunction = originalInAsync
 			v.currentReceiver = originalReceiver
 			v.currentFuncObj = originalFuncObj
+			v.currentFuncDecl = originalFuncDecl
+			v.currentFuncLit = originalFuncLit
 		}()
 		return nil // Stop traversal here, ast.Walk handled the body
 
 	case *ast.FuncLit:
+		// Save original inAsyncFunction state to restore after visiting
+		originalInAsync := v.inAsyncFunction
+		originalFuncDecl := v.currentFuncDecl
+		originalFuncLit := v.currentFuncLit
+
+		// Set current function literal
+		v.currentFuncDecl = nil
+		v.currentFuncLit = n
+
 		// Determine if this function literal is async based on its body
 		isAsync := v.containsAsyncOperations(n.Body)
-		v.analysis.IsInAsyncFunctionMap[n] = isAsync
+		if v.analysis.NodeData[n] == nil {
+			v.analysis.NodeData[n] = &NodeInfo{}
+		}
+		v.analysis.NodeData[n].InAsyncContext = isAsync
+
+		// Store named return variables for function literal
+		if n.Type != nil && n.Type.Results != nil {
+			var namedReturns []string
+			for _, field := range n.Type.Results.List {
+				for _, name := range field.Names {
+					namedReturns = append(namedReturns, name.Name)
+				}
+			}
+			if len(namedReturns) > 0 {
+				v.analysis.FuncLitData[n] = &FunctionInfo{
+					IsAsync:      isAsync,
+					NamedReturns: namedReturns,
+				}
+			}
+		}
 
-		// Save original inAsyncFunction state to restore after visiting
-		originalInAsync := v.inAsyncFunction
 		v.inAsyncFunction = isAsync
 
 		// Check if the body contains any defer statements
 		if n.Body != nil && v.containsDefer(n.Body) {
-			v.analysis.NeedsDeferMap[n.Body] = true
+			if v.analysis.NodeData[n] == nil {
+				v.analysis.NodeData[n] = &NodeInfo{}
+			}
+			v.analysis.NodeData[n].NeedsDefer = true
 		}
 
 		// Visit the body with updated state
@@ -472,16 +582,27 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 
 		// Restore inAsyncFunction state after visiting
 		v.inAsyncFunction = originalInAsync
+		v.currentFuncDecl = originalFuncDecl
+		v.currentFuncLit = originalFuncLit
 		return nil // Stop traversal here, ast.Walk handled the body
 
 	case *ast.BlockStmt:
+		if n == nil || len(n.List) == 0 {
+			break
+		}
+
+		// Initialize NodeData for this block
+		if v.analysis.NodeData[n] == nil {
+			v.analysis.NodeData[n] = &NodeInfo{}
+		}
+
 		// Check for defer statements in this block
 		if v.containsDefer(n) {
-			v.analysis.NeedsDeferMap[n] = true
+			v.analysis.NodeData[n].NeedsDefer = true
 		}
 
 		// Store async state for this block
-		v.analysis.IsInAsyncFunctionMap[n] = v.inAsyncFunction
+		v.analysis.NodeData[n].InAsyncContext = v.inAsyncFunction
 
 		return v
 
@@ -500,12 +621,18 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 			if obj := v.pkg.TypesInfo.Uses[funcIdent]; obj != nil && v.analysis.IsAsyncFunc(obj) {
 				// We're calling an async function, so mark current function as async if we're in one
 				if v.currentFuncObj != nil {
-					v.analysis.AsyncFuncs[v.currentFuncObj] = true
+					v.analysis.FunctionData[v.currentFuncObj] = &FunctionInfo{
+						IsAsync:      true,
+						NamedReturns: v.getNamedReturns(v.currentFuncDecl),
+					}
 					v.inAsyncFunction = true // Update visitor state
 					// Mark the FuncDecl node itself if possible (might need to store the node too)
-					for nodeAst := range v.analysis.IsInAsyncFunctionMap { // Find the node to update
+					for nodeAst := range v.analysis.NodeData { // Find the node to update
 						if fd, ok := nodeAst.(*ast.FuncDecl); ok && v.pkg.TypesInfo.ObjectOf(fd.Name) == v.currentFuncObj {
-							v.analysis.IsInAsyncFunctionMap[nodeAst] = true
+							if v.analysis.NodeData[nodeAst] == nil {
+								v.analysis.NodeData[nodeAst] = &NodeInfo{}
+							}
+							v.analysis.NodeData[nodeAst].InAsyncContext = true
 						}
 					}
 				}
@@ -513,7 +640,10 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 		}
 
 		// Store async state for this call expression
-		v.analysis.IsInAsyncFunctionMap[n] = v.inAsyncFunction
+		if v.analysis.NodeData[n] == nil {
+			v.analysis.NodeData[n] = &NodeInfo{}
+		}
+		v.analysis.NodeData[n].InAsyncContext = v.inAsyncFunction
 
 		return v
 
@@ -610,14 +740,46 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 		}
 		return v // Continue traversal
 
-	case *ast.CompositeLit:
-		// No need to track private field access in composite literals since all fields are public
-		return v
+	case *ast.ReturnStmt:
+		// Initialize NodeData for return statement
+		if v.analysis.NodeData[n] == nil {
+			v.analysis.NodeData[n] = &NodeInfo{}
+		}
 
-	default:
-		// For all other nodes, continue traversal
-		return v
+		// Record the enclosing function/literal for this return statement
+		if v.currentFuncDecl != nil {
+			v.analysis.NodeData[n].EnclosingFuncDecl = v.currentFuncDecl
+		} else if v.currentFuncLit != nil {
+			v.analysis.NodeData[n].EnclosingFuncLit = v.currentFuncLit
+		}
+
+		// Check if it's a bare return
+		if len(n.Results) == 0 {
+			if v.currentFuncDecl != nil {
+				// Check if the enclosing function declaration has named returns
+				if obj := v.pkg.TypesInfo.ObjectOf(v.currentFuncDecl.Name); obj != nil {
+					if _, ok := v.analysis.FunctionData[obj]; ok {
+						if v.analysis.NodeData[n] == nil {
+							v.analysis.NodeData[n] = &NodeInfo{}
+						}
+						v.analysis.NodeData[n].IsBareReturn = true
+					}
+				}
+			} else if v.currentFuncLit != nil {
+				// Check if the enclosing function literal has named returns
+				if _, ok := v.analysis.FuncLitData[v.currentFuncLit]; ok {
+					if v.analysis.NodeData[n] == nil {
+						v.analysis.NodeData[n] = &NodeInfo{}
+					}
+					v.analysis.NodeData[n].IsBareReturn = true
+				}
+			}
+		}
+		return v // Continue traversal
 	}
+
+	// For all other nodes, continue traversal
+	return v
 }
 
 // containsAsyncOperations checks if a node contains any async operations like channel operations.
@@ -666,6 +828,9 @@ func (v *analysisVisitor) containsDefer(block *ast.BlockStmt) bool {
 	hasDefer := false
 
 	ast.Inspect(block, func(n ast.Node) bool {
+		if n == nil {
+			return true
+		}
 		if _, ok := n.(*ast.DeferStmt); ok {
 			hasDefer = true
 			return false
@@ -724,3 +889,16 @@ func AnalyzeFile(file *ast.File, pkg *packages.Package, analysis *Analysis, cmap
 	// Walk the AST with our visitor
 	ast.Walk(visitor, file)
 }
+
+// getNamedReturns retrieves the named returns for a function
+func (v *analysisVisitor) getNamedReturns(funcDecl *ast.FuncDecl) []string {
+	var namedReturns []string
+	if funcDecl.Type != nil && funcDecl.Type.Results != nil {
+		for _, field := range funcDecl.Type.Results.List {
+			for _, name := range field.Names {
+				namedReturns = append(namedReturns, name.Name)
+			}
+		}
+	}
+	return namedReturns
+}

package/compiler/assignment.go

@@ -100,7 +100,7 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 				if lhsObj != nil {
 					c.tsw.WriteLiterally(": ")
 					c.tsw.WriteLiterally("$.Box<")
-					c.WriteGoType(lhsObj.Type())
+					c.WriteGoType(lhsObj.Type(), GoTypeContextGeneral)
 					c.tsw.WriteLiterally(">")
 				}
 
@@ -177,6 +177,11 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 					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 {

package/compiler/compiler.go

@@ -8,8 +8,10 @@ import (
 	"go/types"
 	"os"
 	"path/filepath"
+	"slices"
 	"strings"
 
+	gs "github.com/aperturerobotics/goscript"
 	"github.com/sirupsen/logrus"
 	"golang.org/x/tools/go/packages"
 )
@@ -88,6 +90,12 @@ func (c *Compiler) CompilePackages(ctx context.Context, patterns ...string) erro
 		return fmt.Errorf("failed to load packages: %w", err)
 	}
 
+	// build a list of packages that patterns matched
+	patternPkgPaths := make([]string, 0, len(pkgs))
+	for _, pkg := range pkgs {
+		patternPkgPaths = append(patternPkgPaths, pkg.PkgPath)
+	}
+
 	// If AllDependencies is true, we need to collect all dependencies
 	if c.config.AllDependencies {
 		// Create a set to track processed packages by their ID
@@ -140,6 +148,18 @@ func (c *Compiler) CompilePackages(ctx context.Context, patterns ...string) erro
 
 	// Compile all packages
 	for _, pkg := range pkgs {
+		// Check if the package has a handwritten equivalent
+		if !slices.Contains(patternPkgPaths, pkg.PkgPath) {
+			_, gsErr := gs.GsOverrides.ReadDir("gs/" + pkg.PkgPath)
+			if gsErr != nil && !os.IsNotExist(gsErr) {
+				return gsErr
+			}
+			if gsErr == nil {
+				c.le.Infof("Skipping compilation for overridden package %s", pkg.PkgPath)
+				continue
+			}
+		}
+
 		// Skip packages that failed to load
 		if len(pkg.Errors) > 0 {
 			c.le.WithError(pkg.Errors[0]).Warnf("Skipping package %s due to errors", pkg.PkgPath)
@@ -328,8 +348,8 @@ func NewFileCompiler(
 // top-level declarations in the Go file.
 func (c *FileCompiler) Compile(ctx context.Context) error {
 	f := c.ast
-
 	pkgPath := c.pkg.PkgPath
+
 	outputFilePath := TranslateGoFilePathToTypescriptFilePath(pkgPath, filepath.Base(c.fullPath))
 	outputFilePathAbs := filepath.Join(c.compilerConfig.OutputPathRoot, outputFilePath)
 
@@ -349,7 +369,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.WriteLine("import * as $ from \"@goscript/builtin\";")
+	c.codeWriter.WriteLinef("import * as $ from %q;", "@goscript/builtin/builtin.js")
 	c.codeWriter.WriteLine("") // Add a newline after the import
 
 	if err := goWriter.WriteDecls(f.Decls); err != nil {
@@ -368,7 +388,7 @@ type GoToTSCompiler struct {
 
 	pkg *packages.Package
 
-	analysis *Analysis // Holds analysis information for code generation decisions
+	analysis *Analysis
 }
 
 // It initializes the compiler with a `TSCodeWriter` for output,
@@ -437,28 +457,31 @@ func (c *GoToTSCompiler) WriteCaseClause(exp *ast.CaseClause) error {
 		c.tsw.WriteLine("")
 	} else {
 		// Case with expressions
-		c.tsw.WriteLiterally("case ")
-		for i, expr := range exp.List {
-			if i > 0 {
-				c.tsw.WriteLiterally(", ") // Although Go doesn't support multiple expressions per case like this,
-			} // TypeScript does, so we'll write it this way for now.
-			if err := c.WriteValueExpr(expr); err != nil {
+		// For Go's `case expr1, expr2:`, we translate to:
+		// case expr1:
+		// case expr2:
+		// ... body ...
+		// break
+		for _, caseExpr := range exp.List {
+			c.tsw.WriteLiterally("case ")
+			if err := c.WriteValueExpr(caseExpr); err != nil {
 				return fmt.Errorf("failed to write case clause expression: %w", err)
 			}
+			c.tsw.WriteLiterally(":")
+			c.tsw.WriteLine("")
 		}
-		c.tsw.WriteLiterally(":")
-		c.tsw.WriteLine("")
 	}
 
+	// The body is written once, after all case labels for this clause.
+	// Indentation for the body starts here.
 	c.tsw.Indent(1)
-	// Write the body of the case clause
 	for _, stmt := range exp.Body {
 		if err := c.WriteStmt(stmt); err != nil {
 			return fmt.Errorf("failed to write statement in case clause body: %w", err)
 		}
 	}
-	// Add break statement (Go's switch has implicit breaks)
-	c.tsw.WriteLine("break") // Remove semicolon
+	// Add break statement (Go's switch has implicit breaks, TS needs explicit break)
+	c.tsw.WriteLine("break")
 	c.tsw.Indent(-1)
 	return nil
 }
@@ -527,11 +550,11 @@ func (c *GoToTSCompiler) writeChannelReceiveWithOk(lhs []ast.Expr, unaryExpr *as
 	} else {
 		// If both are blank, just await the call and return
 		if okIsBlank {
-			c.tsw.WriteLiterally("await ")
+			c.tsw.WriteLiterally("await $.chanRecvWithOk(")
 			if err := c.WriteValueExpr(unaryExpr.X); err != nil { // Channel expression
 				return fmt.Errorf("failed to write channel expression in receive: %w", err)
 			}
-			c.tsw.WriteLiterally(".receiveWithOk()")
+			c.tsw.WriteLiterally(")")
 			c.tsw.WriteLine("")
 			return nil // Nothing to assign
 		}
@@ -549,11 +572,11 @@ func (c *GoToTSCompiler) writeChannelReceiveWithOk(lhs []ast.Expr, unaryExpr *as
 	// Write the destructuring assignment/declaration
 	c.tsw.WriteLiterally(keyword) // "const " or ""
 	c.tsw.WriteLiterally(destructuringPattern)
-	c.tsw.WriteLiterally(" = await ")
+	c.tsw.WriteLiterally(" = await $.chanRecvWithOk(")
 	if err := c.WriteValueExpr(unaryExpr.X); err != nil { // Channel expression
 		return fmt.Errorf("failed to write channel expression in receive: %w", err)
 	}
-	c.tsw.WriteLiterally(".receiveWithOk()")
+	c.tsw.WriteLiterally(")")
 	c.tsw.WriteLine("")
 
 	return nil

package/compiler/compiler_test.go

@@ -6,6 +6,7 @@ import (
 	"path/filepath"
 	"runtime"
 	"slices"
+	"strings"
 	"sync"
 	"sync/atomic"
 	"testing"
@@ -38,7 +39,7 @@ func TestCompliance(t *testing.T) {
 		testPath := filepath.Join(testsDir, dir.Name())
 		goFiles, err := filepath.Glob(filepath.Join(testPath, "*.go"))
 		if err != nil || len(goFiles) == 0 {
-			t.Errorf("no .go files found in %s", testPath)
+			// t.Errorf("no .go files found in %s", testPath)
 			continue
 		}
 		testPaths = append(testPaths, testPath)
@@ -97,15 +98,42 @@ func TestCompliance(t *testing.T) {
 			t.SkipNow()
 		}
 
-		t.Log("running: npm run typecheck")
-		cmd := exec.Command("npm", "run", "typecheck")
-		cmd.Dir = workspaceDir // Run in the workspace directory
-		cmd.Stdout = os.Stderr
-		cmd.Stderr = os.Stderr
+		// Get parent module path for the global typecheck
+		parentModPath, err := getParentGoModulePath()
+		if err != nil {
+			t.Fatalf("Failed to determine parent Go module path: %v", err)
+		}
+
+		// Create global typecheck tsconfig
+		tsconfigPath := compliance.WriteGlobalTypeCheckConfig(t, parentModPath, workspaceDir)
+
+		// Run TypeScript type checking
+		typecheckDir := filepath.Dir(tsconfigPath)
+		cmd := exec.Command("tsc", "--project", filepath.Base(tsconfigPath))
+		cmd.Dir = typecheckDir
+
+		// Set up PATH to include node_modules/.bin
+		nodeBinDir := filepath.Join(workspaceDir, "node_modules", ".bin")
+		currentPath := os.Getenv("PATH")
+		newPath := nodeBinDir + string(os.PathListSeparator) + currentPath
+		cmd.Env = append(os.Environ(), "PATH="+newPath)
 
-		err = cmd.Run()
+		output, err := cmd.CombinedOutput()
 		if err != nil {
-			t.Errorf("npm run typecheck failed: %v", err)
+			t.Errorf("Global TypeScript type checking failed: %v\noutput:\n%s", err, string(output))
+		} else {
+			t.Logf("Global TypeScript type checking passed")
 		}
 	})
 }
+
+// getParentGoModulePath is a helper function to get the parent Go module path
+// This is similar to the one in compliance.go but simplified for use in tests
+func getParentGoModulePath() (string, error) {
+	cmd := exec.Command("go", "list", "-m")
+	output, err := cmd.Output()
+	if err != nil {
+		return "", err
+	}
+	return strings.TrimSpace(string(output)), nil
+}