goscript 0.0.70 → 0.0.73

package/cmd/goscript-wasm/main.go

@@ -0,0 +1,46 @@
+//go:build js && wasm
+
+package main
+
+import (
+	"syscall/js"
+
+	"github.com/aperturerobotics/goscript/compiler/wasm"
+)
+
+func main() {
+	// Register the compile function as a global JavaScript function
+	js.Global().Set("goscriptCompile", js.FuncOf(compileWrapper))
+
+	// Keep the program running
+	select {}
+}
+
+// compileWrapper wraps the compile function for JavaScript interop
+func compileWrapper(this js.Value, args []js.Value) interface{} {
+	if len(args) < 1 {
+		return map[string]interface{}{
+			"error":  "missing source code argument",
+			"output": "",
+		}
+	}
+
+	source := args[0].String()
+	packageName := "main"
+	if len(args) > 1 {
+		packageName = args[1].String()
+	}
+
+	output, err := wasm.CompileSource(source, packageName)
+	if err != nil {
+		return map[string]interface{}{
+			"error":  err.Error(),
+			"output": "",
+		}
+	}
+
+	return map[string]interface{}{
+		"error":  "",
+		"output": output,
+	}
+}

package/compiler/analysis.go

@@ -221,10 +221,10 @@ func NewAnalysis(allPackages map[string]*packages.Package) *Analysis {
 		AsyncReturningVars:       make(map[types.Object]bool),
 		NamedBasicTypes:          make(map[types.Type]bool),
 		AllPackages:              allPackages,
-		InterfaceImplementations:  make(map[InterfaceMethodKey][]ImplementationInfo),
-		MethodAsyncStatus:         make(map[MethodKey]bool),
-		ReferencedTypesPerFile:    make(map[string]map[*types.Named]bool),
-		SyntheticImportsPerFile:   make(map[string]map[string]*fileImport),
+		InterfaceImplementations: make(map[InterfaceMethodKey][]ImplementationInfo),
+		MethodAsyncStatus:        make(map[MethodKey]bool),
+		ReferencedTypesPerFile:   make(map[string]map[*types.Named]bool),
+		SyntheticImportsPerFile:  make(map[string]map[string]*fileImport),
 	}
 }
 

package/compiler/compiler.go

@@ -17,6 +17,7 @@ import (
 
 	gs "github.com/aperturerobotics/goscript"
 	"github.com/sirupsen/logrus"
+	"golang.org/x/mod/modfile"
 	"golang.org/x/tools/go/packages"
 )
 
@@ -90,6 +91,67 @@ type CompilationResult struct {
 	OriginalPackages []string
 }
 
+// resolveReplaceDirectives transforms local path patterns (like ./subpkg) to their
+// corresponding module paths using replace directives from go.mod.
+// This allows users to specify local paths that are mapped via replace directives.
+// For example, if go.mod has:
+//
+//	replace github.com/example/lib => ./local/lib
+//
+// And the user runs: goscript compile ./local/lib
+// This function transforms ./local/lib to github.com/example/lib
+func (c *Compiler) resolveReplaceDirectives(patterns []string) ([]string, error) {
+	dir := c.config.Dir
+	if dir == "" {
+		dir = "."
+	}
+	goModPath := filepath.Join(dir, "go.mod")
+
+	data, err := os.ReadFile(goModPath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return patterns, nil
+		}
+		return nil, err
+	}
+
+	modFile, err := modfile.Parse(goModPath, data, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	// Build replace map: local path -> module path
+	// The replace directive syntax is: replace old => new
+	// For local replacements: replace github.com/example/lib => ./local/lib
+	// So r.Old.Path = "github.com/example/lib" (the module path)
+	// And r.New.Path = "./local/lib" (the local replacement path)
+	replaceMap := make(map[string]string)
+	for _, r := range modFile.Replace {
+		if r.New.Version == "" { // Local path replacements have no version
+			// Normalize the path for consistent comparison across platforms
+			localPath := filepath.Clean(r.New.Path)
+			replaceMap[localPath] = r.Old.Path
+		}
+	}
+
+	// Transform patterns that are local paths to their module path equivalents
+	result := make([]string, len(patterns))
+	for i, pattern := range patterns {
+		// Check if this is a filesystem path (relative or absolute)
+		if filepath.IsAbs(pattern) || strings.HasPrefix(pattern, "./") || strings.HasPrefix(pattern, "../") {
+			// Normalize the pattern for consistent comparison
+			normalizedPattern := filepath.Clean(pattern)
+			if modulePath, ok := replaceMap[normalizedPattern]; ok {
+				result[i] = modulePath
+				continue
+			}
+		}
+		result[i] = pattern
+	}
+
+	return result, nil
+}
+
 // CompilePackages loads Go packages based on the provided patterns and
 // then compiles each loaded package into TypeScript. It uses the context for
 // cancellation and applies the compiler's configured options during package loading.
@@ -102,9 +164,15 @@ func (c *Compiler) CompilePackages(ctx context.Context, patterns ...string) (*Co
 	opts := c.opts
 	opts.Context = ctx
 
+	// Resolve local path patterns using replace directives from go.mod
+	resolvedPatterns, err := c.resolveReplaceDirectives(patterns)
+	if err != nil {
+		return nil, fmt.Errorf("failed to resolve replace directives: %w", err)
+	}
+
 	// First, load the initial packages with NeedImports to get all dependencies
 	opts.Mode |= packages.NeedImports
-	pkgs, err := packages.Load(&opts, patterns...)
+	pkgs, err := packages.Load(&opts, resolvedPatterns...)
 	if err != nil {
 		return nil, fmt.Errorf("failed to load packages: %w", err)
 	}

package/compiler/composite-lit.go

@@ -38,7 +38,14 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 
 	if exp.Type != nil {
 		// Handle map literals: map[K]V{k1: v1, k2: v2}
-		if _, isMapType := exp.Type.(*ast.MapType); isMapType {
+		// Also handle type alias for map: type OpNames map[K]V; OpNames{k1: v1}
+		isMapType := false
+		if _, astMapType := exp.Type.(*ast.MapType); astMapType {
+			isMapType = true
+		} else if litType != nil {
+			_, isMapType = litType.Underlying().(*types.Map)
+		}
+		if isMapType {
 			c.tsw.WriteLiterally("new Map([")
 
 			// Add each key-value pair as an entry

package/compiler/decl.go

@@ -6,8 +6,42 @@ import (
 	"go/token"
 	"go/types"
 	"slices"
+	"strings"
 )
 
+// linknameInfo holds parsed //go:linkname directive information.
+type linknameInfo struct {
+	targetPkg  string // target package path (e.g., "github.com/example/package")
+	targetName string // target symbol name (e.g., "CanHaveDecorators")
+}
+
+// parseLinknameDirective checks if a doc comment contains a //go:linkname directive
+// and returns the parsed information if found.
+func parseLinknameDirective(doc *ast.CommentGroup) *linknameInfo {
+	if doc == nil {
+		return nil
+	}
+	for _, comment := range doc.List {
+		text := strings.TrimSpace(comment.Text)
+		if strings.HasPrefix(text, "//go:linkname ") {
+			// Format: //go:linkname localname importpath.name
+			parts := strings.Fields(text)
+			if len(parts) >= 3 {
+				target := parts[2]
+				// Split target into package path and symbol name
+				lastDot := strings.LastIndex(target, ".")
+				if lastDot > 0 {
+					return &linknameInfo{
+						targetPkg:  target[:lastDot],
+						targetName: target[lastDot+1:],
+					}
+				}
+			}
+		}
+	}
+	return nil
+}
+
 // WriteDecls iterates through a slice of Go top-level declarations (`ast.Decl`)
 // and translates each one into its TypeScript equivalent.
 // It distinguishes between:
@@ -436,6 +470,12 @@ func (c *GoToTSCompiler) WriteFuncDeclAsFunction(decl *ast.FuncDecl) error {
 		return nil
 	}
 
+	// Check for //go:linkname directive on functions without a body
+	if linkInfo := parseLinknameDirective(decl.Doc); linkInfo != nil && decl.Body == nil {
+		// This is a linkname function - generate a re-export with type annotation
+		return c.writeLinknameFunction(decl, linkInfo)
+	}
+
 	if decl.Doc != nil {
 		c.WriteDoc(decl.Doc)
 	}
@@ -495,6 +535,59 @@ func (c *GoToTSCompiler) WriteFuncDeclAsFunction(decl *ast.FuncDecl) error {
 	return nil
 }
 
+// writeLinknameFunction generates a TypeScript const re-export for a //go:linkname function.
+// It generates: export const LocalName: (params) => ReturnType = alias.TargetName
+//
+// Unlike Go's //go:linkname, which does not perform type checking between the
+// local declaration and the target symbol, the generated TypeScript code includes an
+// explicit function type annotation. This means the TypeScript compiler will enforce
+// that the declared parameter and return types match the actual target function type.
+// Any mismatch will result in a TypeScript compilation error.
+func (c *GoToTSCompiler) writeLinknameFunction(decl *ast.FuncDecl, info *linknameInfo) error {
+	// Find the import alias for the target package
+	alias := c.findImportAlias(info.targetPkg)
+	if alias == "" {
+		// Package not imported, write a comment and fall back to empty function
+		c.tsw.WriteLinef("//go:linkname target %s not found in imports", info.targetPkg)
+		c.tsw.WriteLiterally("export function ")
+		c.tsw.WriteLiterally(c.sanitizeIdentifier(decl.Name.Name))
+		c.WriteFuncType(decl.Type, false)
+		c.tsw.WriteLine(" {}")
+		return nil
+	}
+
+	// Generate: export const LocalName: (params) => ReturnType = alias.TargetName
+	c.tsw.WriteLiterally("export const ")
+	c.tsw.WriteLiterally(c.sanitizeIdentifier(decl.Name.Name))
+	c.tsw.WriteLiterally(": ")
+
+	// Write the function type as an arrow function type
+	c.WriteFuncTypeAsArrow(decl.Type)
+
+	c.tsw.WriteLiterally(" = ")
+	c.tsw.WriteLiterally(alias)
+	c.tsw.WriteLiterally(".")
+	c.tsw.WriteLiterally(info.targetName)
+	c.tsw.WriteLine("")
+
+	return nil
+}
+
+// findImportAlias finds the import alias used for a Go package path in the current file.
+// Returns empty string if the package is not imported.
+func (c *GoToTSCompiler) findImportAlias(pkgPath string) string {
+	// The importPath in analysis.Imports is stored as the TypeScript path (e.g., @goscript/pkg/path)
+	// We need to convert the Go package path to match
+	tsPath := "@goscript/" + pkgPath
+
+	for alias, imp := range c.analysis.Imports {
+		if imp.importPath == tsPath {
+			return alias
+		}
+	}
+	return ""
+}
+
 // WriteFuncDeclAsMethod translates a Go function declaration (`ast.FuncDecl`)
 // that has a receiver (i.e., it's a method) into a TypeScript class method.
 //   - It preserves Go documentation comments (`decl.Doc`).

package/compiler/expr-call-type-conversion.go

@@ -264,7 +264,14 @@ func (c *GoToTSCompiler) writeStringConversion(exp *ast.CallExpr) error {
 		}
 	}
 
-	return fmt.Errorf("unhandled string conversion: %s", exp.Fun)
+	// Fallback: when type info is not available (e.g., in WASM context),
+	// use a generic conversion that handles both []byte and string
+	c.tsw.WriteLiterally("$.genericBytesOrStringToString(")
+	if err := c.WriteValueExpr(arg); err != nil {
+		return fmt.Errorf("failed to write argument for string(unknown type) conversion: %w", err)
+	}
+	c.tsw.WriteLiterally(")")
+	return nil
 }
 
 // handleTypeConversionCommon contains the shared logic for type conversions

package/compiler/expr.go

@@ -566,7 +566,7 @@ func (c *GoToTSCompiler) WriteUnaryExpr(exp *ast.UnaryExpr) error {
 			}
 			if obj != nil && c.analysis.NeedsVarRef(obj) {
 				// &varRefVar -> varRefVar (the variable reference itself)
-				c.tsw.WriteLiterally(ident.Name) // Write the identifier name (which holds the variable reference)
+				c.tsw.WriteLiterally(c.sanitizeIdentifier(ident.Name)) // Write the identifier name (which holds the variable reference)
 				return nil
 			}
 		}

package/compiler/spec.go

@@ -602,12 +602,17 @@ func (c *GoToTSCompiler) WriteImportSpec(a *ast.ImportSpec) {
 
 	// Determine the import name to use in TypeScript
 	var impName string
-	if a.Name != nil && a.Name.Name != "" {
+	if a.Name != nil && a.Name.Name != "" && a.Name.Name != "." && a.Name.Name != "_" {
 		// Explicit alias provided: import alias "path/to/pkg"
+		// Skip dot imports (. "pkg") and blank imports (_ "pkg")
 		impName = a.Name.Name
+	} else if a.Name != nil && a.Name.Name == "_" {
+		// Blank import (_ "pkg") - skip entirely, these are for side effects only
+		return
 	} else {
-		// No explicit alias, use the actual package name from type information
+		// No explicit alias, or dot import - use the actual package name from type information
 		// This handles cases where package name differs from the last path segment
+		// For dot imports, we still need a valid identifier for the import
 		if actualName, err := getActualPackageName(goPath, c.pkg.Imports); err == nil {
 			impName = actualName
 		} else {

package/compiler/stmt-assign.go

@@ -310,10 +310,12 @@ func (c *GoToTSCompiler) writeMultiVarAssignFromCall(lhs []ast.Expr, callExpr *a
 		// Get function return types if available
 		var resultTypes []*types.Var
 		if callExpr.Fun != nil {
-			if funcType, ok := c.pkg.TypesInfo.TypeOf(callExpr.Fun).Underlying().(*types.Signature); ok {
-				if funcType.Results() != nil && funcType.Results().Len() > 0 {
-					for i := 0; i < funcType.Results().Len(); i++ {
-						resultTypes = append(resultTypes, funcType.Results().At(i))
+			if funType := c.pkg.TypesInfo.TypeOf(callExpr.Fun); funType != nil {
+				if funcType, ok := funType.Underlying().(*types.Signature); ok {
+					if funcType.Results() != nil && funcType.Results().Len() > 0 {
+						for i := 0; i < funcType.Results().Len(); i++ {
+							resultTypes = append(resultTypes, funcType.Results().At(i))
+						}
 					}
 				}
 			}

package/compiler/type.go

@@ -447,6 +447,57 @@ func (c *GoToTSCompiler) WriteFuncType(exp *ast.FuncType, isAsync bool) {
 	}
 }
 
+// WriteFuncTypeAsArrow writes a function type using arrow function syntax.
+// This is used for type annotations where we need (params) => ReturnType format
+// instead of function(params): ReturnType format.
+// Example: (name: string, age: number) => boolean
+//
+// This helper does not perform any async detection and never wraps the
+// return type in Promise<>. The generated arrow function type reflects the
+// Go function's translated result types directly.
+func (c *GoToTSCompiler) WriteFuncTypeAsArrow(exp *ast.FuncType) {
+	c.tsw.WriteLiterally("(")
+	c.WriteFieldList(exp.Params, true) // true = arguments
+	c.tsw.WriteLiterally(")")
+	c.tsw.WriteLiterally(" => ")
+
+	if exp.Results != nil && len(exp.Results.List) > 0 {
+		// Count total number of return values
+		totalResults := 0
+		for _, field := range exp.Results.List {
+			count := len(field.Names)
+			if count == 0 {
+				count = 1
+			}
+			totalResults += count
+		}
+
+		if totalResults == 1 {
+			c.WriteTypeExpr(exp.Results.List[0].Type)
+		} else {
+			// Multiple return types -> tuple
+			c.tsw.WriteLiterally("[")
+			first := true
+			for _, field := range exp.Results.List {
+				count := len(field.Names)
+				if count == 0 {
+					count = 1
+				}
+				for j := 0; j < count; j++ {
+					if !first {
+						c.tsw.WriteLiterally(", ")
+					}
+					first = false
+					c.WriteTypeExpr(field.Type)
+				}
+			}
+			c.tsw.WriteLiterally("]")
+		}
+	} else {
+		c.tsw.WriteLiterally("void")
+	}
+}
+
 // WriteInterfaceType translates a Go interface type to its TypeScript equivalent.
 // It specially handles the error interface as $.GoError, and delegates to
 // writeInterfaceStructure for other interface types, prepending "null | ".

package/compiler/wasm/compile.go

@@ -0,0 +1,12 @@
+// Package wasm provides a WASM-friendly API for compiling Go source code to TypeScript.
+package wasm
+
+import (
+	"github.com/aperturerobotics/goscript/compiler"
+)
+
+// CompileSource compiles Go source code to TypeScript.
+// It takes the source code as a string and returns the generated TypeScript.
+func CompileSource(source string, packageName string) (string, error) {
+	return compiler.CompileSourceToTypeScript(source, packageName)
+}

package/compiler/wasm_api.go

@@ -0,0 +1,160 @@
+package compiler
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/importer"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"io"
+
+	"golang.org/x/tools/go/packages"
+)
+
+// CompileSourceToTypeScript compiles Go source code directly to TypeScript.
+// This is a WASM-friendly API that bypasses filesystem operations.
+// It takes the source code as a string and returns the generated TypeScript.
+func CompileSourceToTypeScript(source string, packageName string) (string, error) {
+	if packageName == "" {
+		packageName = "main"
+	}
+
+	// Create a new file set for position information
+	fset := token.NewFileSet()
+
+	// Parse the source code
+	astFile, err := parser.ParseFile(fset, "main.go", source, parser.ParseComments)
+	if err != nil {
+		return "", fmt.Errorf("parse error: %w", err)
+	}
+
+	// Create type checker configuration with a custom importer
+	var typeErrors []error
+	conf := types.Config{
+		Importer: &wasmImporter{
+			defaultImporter: importer.Default(),
+			cache:           make(map[string]*types.Package),
+		},
+		Error: func(err error) {
+			// Collect errors but don't fail immediately
+			typeErrors = append(typeErrors, err)
+		},
+	}
+
+	// Type check the package
+	info := &types.Info{
+		Types:      make(map[ast.Expr]types.TypeAndValue),
+		Defs:       make(map[*ast.Ident]types.Object),
+		Uses:       make(map[*ast.Ident]types.Object),
+		Implicits:  make(map[ast.Node]types.Object),
+		Selections: make(map[*ast.SelectorExpr]*types.Selection),
+		Scopes:     make(map[ast.Node]*types.Scope),
+		Instances:  make(map[*ast.Ident]types.Instance),
+	}
+
+	pkg, _ := conf.Check(packageName, fset, []*ast.File{astFile}, info)
+	// We continue even with type check errors for playground flexibility
+
+	// Create a packages.Package compatible structure
+	pkgData := &packages.Package{
+		ID:              packageName,
+		Name:            astFile.Name.Name,
+		PkgPath:         packageName,
+		Fset:            fset,
+		Syntax:          []*ast.File{astFile},
+		Types:           pkg,
+		TypesInfo:       info,
+		CompiledGoFiles: []string{"main.go"},
+	}
+
+	// Create an empty map for all packages (we only have one)
+	allPackages := map[string]*packages.Package{
+		packageName: pkgData,
+	}
+
+	// Perform package-level analysis
+	packageAnalysis := AnalyzePackageImports(pkgData)
+	analysis := AnalyzePackageFiles(pkgData, allPackages)
+
+	// Create a buffer to capture the output
+	var buf bytes.Buffer
+
+	// Create the file compiler
+	fileCompiler := &FileCompiler{
+		compilerConfig:  &Config{},
+		pkg:             pkgData,
+		ast:             astFile,
+		fullPath:        "main.go",
+		Analysis:        analysis,
+		PackageAnalysis: packageAnalysis,
+	}
+
+	// Compile to the buffer
+	if err := fileCompiler.CompileToWriter(&buf); err != nil {
+		return "", fmt.Errorf("compilation error: %w", err)
+	}
+
+	return buf.String(), nil
+}
+
+// CompileToWriter compiles the Go file and writes TypeScript to the given writer.
+// This is used for WASM compilation where we don't want file I/O.
+func (c *FileCompiler) CompileToWriter(w io.Writer) error {
+	f := c.ast
+
+	c.codeWriter = NewTSCodeWriter(w)
+
+	// Pass analysis to compiler
+	goWriter := NewGoToTSCompiler(c.codeWriter, c.pkg, c.Analysis, c.fullPath)
+
+	// Add import for the goscript runtime using namespace import and alias
+	c.codeWriter.WriteLinef("import * as $ from %q", "@goscript/builtin/index.js")
+
+	c.codeWriter.WriteLine("") // Add a newline after imports
+
+	if err := goWriter.WriteDecls(f.Decls); err != nil {
+		return fmt.Errorf("failed to write declarations: %w", err)
+	}
+
+	return nil
+}
+
+// wasmImporter provides import resolution for WASM compilation.
+// It wraps the default importer and provides stubs for common packages.
+type wasmImporter struct {
+	defaultImporter types.Importer
+	cache           map[string]*types.Package
+}
+
+func (i *wasmImporter) Import(path string) (*types.Package, error) {
+	if pkg, ok := i.cache[path]; ok {
+		return pkg, nil
+	}
+
+	// Try the default importer first (works for stdlib packages)
+	pkg, err := i.defaultImporter.Import(path)
+	if err == nil {
+		i.cache[path] = pkg
+		return pkg, nil
+	}
+
+	// For unknown packages, create an empty stub package
+	// This allows compilation to proceed even if dependencies aren't available
+	stubPkg := types.NewPackage(path, pathToName(path))
+	stubPkg.MarkComplete()
+	i.cache[path] = stubPkg
+	return stubPkg, nil
+}
+
+// pathToName extracts a package name from an import path
+func pathToName(path string) string {
+	// Find the last component of the path
+	for i := len(path) - 1; i >= 0; i-- {
+		if path[i] == '/' {
+			return path[i+1:]
+		}
+	}
+	return path
+}