goscript 0.0.84 → 0.1.1

package/compiler/wasm/compile.go

@@ -1,12 +1,11 @@
-// Package wasm provides a WASM-friendly API for compiling Go source code to TypeScript.
+// Package wasm provides the WASM-friendly compiler adapter surface.
 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.
+// CompileSource compiles import-free browser source strings to TypeScript.
 func CompileSource(source string, packageName string) (string, error) {
 	return compiler.CompileSourceToTypeScript(source, packageName)
 }

package/compiler/wasm/compile_test.go

@@ -0,0 +1,79 @@
+package wasm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/aperturerobotics/goscript/compiler"
+)
+
+func TestCompileSourceCompilesSingleFile(t *testing.T) {
+	output, err := CompileSource(strings.Join([]string{
+		"package main",
+		"",
+		"type Counter struct {",
+		"    value int",
+		"}",
+		"",
+		"func (c *Counter) Increment() {",
+		"    c.value++",
+		"}",
+		"",
+		"func main() {",
+		"    c := &Counter{}",
+		"    c.Increment()",
+		"    println(\"Count:\", c.value)",
+		"}",
+		"",
+	}, "\n"), "main")
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	for _, want := range []string{
+		"import * as $ from \"@goscript/builtin/index.js\"",
+		"class Counter",
+		"public Increment(): void",
+		"export async function main(): globalThis.Promise<void>",
+		"$.println(\"Count:\", $.pointerValue<Counter>(c).value)",
+		"await main()",
+	} {
+		if !strings.Contains(output, want) {
+			t.Fatalf("missing %q in generated output:\n%s", want, output)
+		}
+	}
+}
+
+func TestCompileSourceReportsParseErrors(t *testing.T) {
+	_, err := CompileSource("package main\nfunc main( {\n", "main")
+	if err == nil {
+		t.Fatal("expected compile error")
+	}
+	requireCompileDiagnostic(t, err, "goscript/wasm:parse")
+}
+
+func TestCompileSourceReportsUnsupportedImports(t *testing.T) {
+	_, err := CompileSource("package main\n\nimport \"fmt\"\n\nfunc main() { fmt.Println(\"hi\") }\n", "main")
+	if err == nil {
+		t.Fatal("expected compile error")
+	}
+	requireCompileDiagnostic(t, err, "goscript/wasm:imports-unsupported")
+}
+
+func requireCompileDiagnostic(t *testing.T, err error, code string) {
+	t.Helper()
+
+	var compileErr *compiler.CompileError
+	if !errors.As(err, &compileErr) {
+		t.Fatalf("expected CompileError, got %T: %v", err, err)
+	}
+	for _, diag := range compileErr.Diagnostics {
+		if diag.Code == code {
+			if diag.Severity != compiler.DiagnosticSeverityError {
+				t.Fatalf("expected error severity, got %s", diag.Severity)
+			}
+			return
+		}
+	}
+	t.Fatalf("missing diagnostic %q in %#v", code, compileErr.Diagnostics)
+}

package/compiler/wasm_api.go

@@ -1,49 +1,94 @@
 package compiler
 
 import (
-	"bytes"
-	"fmt"
+	"context"
 	"go/ast"
-	"go/importer"
 	"go/parser"
 	"go/token"
 	"go/types"
-	"io"
+	"strconv"
+	"strings"
 
 	"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.
+const browserSourceFileName = "main.go"
+
+// CompileSourceToTypeScript is the WASM adapter for browser source compilation.
 func CompileSourceToTypeScript(source string, packageName string) (string, error) {
-	if packageName == "" {
-		packageName = "main"
+	graph, diagnostics := browserSourceGraph(source, packageName)
+	if diagnosticsHaveErrors(diagnostics) {
+		return "", NewCompileError(diagnostics)
 	}
 
-	// Create a new file set for position information
-	fset := token.NewFileSet()
+	ctx := context.Background()
+	service := NewCompileService()
+	model, modelDiagnostics := service.semanticOwner.Build(ctx, graph)
+	diagnostics = append(diagnostics, modelDiagnostics...)
+	if diagnosticsHaveErrors(diagnostics) {
+		return "", NewCompileError(diagnostics)
+	}
 
-	// Parse the source code
-	astFile, err := parser.ParseFile(fset, "main.go", source, parser.ParseComments)
-	if err != nil {
-		return "", fmt.Errorf("parse error: %w", err)
+	program, loweringDiagnostics := service.loweringOwner.Build(ctx, model)
+	diagnostics = append(diagnostics, loweringDiagnostics...)
+	if diagnosticsHaveErrors(diagnostics) {
+		return "", NewCompileError(diagnostics)
+	}
+	if program == nil || len(program.packages) != 1 || len(program.packages[0].files) != 1 {
+		diagnostics = append(diagnostics, Diagnostic{
+			Severity: DiagnosticSeverityError,
+			Code:     "goscript/wasm:invalid-output",
+			Message:  "browser source compilation produced an invalid output shape",
+		})
+		return "", NewCompileError(diagnostics)
 	}
 
-	// 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)
-		},
+	files, emitDiagnostics := service.emitterOwner.EmitToMemory(ctx, program)
+	diagnostics = append(diagnostics, emitDiagnostics...)
+	if diagnosticsHaveErrors(diagnostics) {
+		return "", NewCompileError(diagnostics)
+	}
+	filePath := "@goscript/" + program.packages[0].pkgPath + "/" + program.packages[0].files[0].outputName
+	output, ok := files[filePath]
+	if !ok {
+		diagnostics = append(diagnostics, Diagnostic{
+			Severity: DiagnosticSeverityError,
+			Code:     "goscript/wasm:missing-output",
+			Message:  "browser source compilation did not emit the expected TypeScript file",
+			Detail:   filePath,
+		})
+		return "", NewCompileError(diagnostics)
+	}
+	return output, nil
+}
+
+func browserSourceGraph(source string, packageName string) (*PackageGraph, []Diagnostic) {
+	if strings.TrimSpace(source) == "" {
+		return nil, []Diagnostic{{
+			Severity: DiagnosticSeverityError,
+			Code:     "goscript/wasm:empty-source",
+			Message:  "browser source compilation requires Go source code",
+		}}
+	}
+
+	fset := token.NewFileSet()
+	file, err := parser.ParseFile(fset, browserSourceFileName, source, parser.ParseComments)
+	if err != nil {
+		return nil, []Diagnostic{{
+			Severity: DiagnosticSeverityError,
+			Code:     "goscript/wasm:parse",
+			Message:  "browser source compilation failed to parse Go source",
+			Detail:   err.Error(),
+		}}
+	}
+	if len(file.Imports) != 0 {
+		return nil, []Diagnostic{browserImportsUnsupportedDiagnostic(file)}
 	}
 
-	// Type check the package
+	pkgPath := strings.TrimSpace(packageName)
+	if pkgPath == "" {
+		pkgPath = file.Name.Name
+	}
 	info := &types.Info{
 		Types:      make(map[ast.Expr]types.TypeAndValue),
 		Defs:       make(map[*ast.Ident]types.Object),
@@ -51,113 +96,84 @@ func CompileSourceToTypeScript(source string, packageName string) (string, error
 		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,
+	sizes := types.SizesFor("gc", "wasm")
+	if sizes == nil {
+		sizes = types.SizesFor("gc", "amd64")
 	}
 
-	// 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)
+	var typeDiagnostics []Diagnostic
+	config := types.Config{
+		Sizes: sizes,
+		Error: func(err error) {
+			typeDiagnostics = append(typeDiagnostics, Diagnostic{
+				Severity: DiagnosticSeverityError,
+				Code:     "goscript/wasm:typecheck",
+				Message:  "browser source compilation failed to type-check Go source",
+				Detail:   err.Error(),
+			})
+		},
 	}
-
-	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",
-		translateTypescriptModulePathToIndexImportPath("@goscript/builtin"),
-	)
-
-	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)
+	typedPkg, err := config.Check(pkgPath, fset, []*ast.File{file}, info)
+	if err != nil {
+		if len(typeDiagnostics) == 0 {
+			typeDiagnostics = append(typeDiagnostics, Diagnostic{
+				Severity: DiagnosticSeverityError,
+				Code:     "goscript/wasm:typecheck",
+				Message:  "browser source compilation failed to type-check Go source",
+				Detail:   err.Error(),
+			})
+		}
+		return nil, typeDiagnostics
 	}
 
-	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
+	node := &PackageGraphNode{
+		ID:              pkgPath,
+		PkgPath:         pkgPath,
+		Name:            file.Name.Name,
+		GoFiles:         []string{browserSourceFileName},
+		CompiledGoFiles: []string{browserSourceFileName},
+		Requested:       true,
 	}
-
-	// 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
+	pkg := &packages.Package{
+		ID:              pkgPath,
+		Name:            file.Name.Name,
+		PkgPath:         pkgPath,
+		GoFiles:         []string{browserSourceFileName},
+		CompiledGoFiles: []string{browserSourceFileName},
+		Imports:         make(map[string]*packages.Package),
+		Types:           typedPkg,
+		Fset:            fset,
+		Syntax:          []*ast.File{file},
+		TypesInfo:       info,
+		TypesSizes:      sizes,
 	}
-
-	// 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
+	return &PackageGraph{
+		RequestedPatterns:     []string{pkgPath},
+		RequestedPackagePaths: []string{pkgPath},
+		Nodes:                 []*PackageGraphNode{node},
+		NodesByPackagePath: map[string]*PackageGraphNode{
+			pkgPath: node,
+		},
+		packagesByPath: map[string]*packages.Package{
+			pkgPath: pkg,
+		},
+	}, 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:]
+func browserImportsUnsupportedDiagnostic(file *ast.File) Diagnostic {
+	imports := make([]string, 0, len(file.Imports))
+	for _, spec := range file.Imports {
+		importPath := spec.Path.Value
+		if unquoted, err := strconv.Unquote(importPath); err == nil {
+			importPath = unquoted
 		}
+		imports = append(imports, importPath)
+	}
+	return Diagnostic{
+		Severity: DiagnosticSeverityError,
+		Code:     "goscript/wasm:imports-unsupported",
+		Message:  "browser source compilation does not support imports yet",
+		Detail:   "Use goscript compile --package . from inside a Go module for imported packages. Imports: " + strings.Join(imports, ", "),
 	}
-	return path
 }

package/dist/compiler/index.d.ts

@@ -8,13 +8,11 @@ export interface CompileConfig {
     output?: string;
     /** The working directory for the compiler. Defaults to the current working directory. */
     dir?: string;
-    /** The path to the goscript executable. Defaults to 'go run github.com/aperturerobotics/goscript/cmd/goscript'. */
+    /** The path to the goscript executable. Defaults to `go run ./cmd/goscript`. */
     goscriptPath?: string;
 }
 /**
  * Compiles a Go package to TypeScript using the goscript compiler.
- * @param config - The compilation configuration.
- * @returns A promise that resolves when compilation is complete, or rejects on error.
  */
 export declare function compile(config: CompileConfig): Promise<void>;
 /**

package/dist/compiler/index.js

@@ -1,68 +1,44 @@
-import * as path from "path";
-import { dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-import { exec } from "node:child_process";
-import { promisify } from "node:util";
+import * as path from 'node:path';
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
 const __filename = fileURLToPath(import.meta.url);
-const execAsync = promisify(exec);
 const __dirname = dirname(__filename);
-const projectRoot = dirname(__dirname); // Go up one level from src/ to the project root
+const projectRoot = dirname(__dirname);
 /**
  * Compiles a Go package to TypeScript using the goscript compiler.
- * @param config - The compilation configuration.
- * @returns A promise that resolves when compilation is complete, or rejects on error.
  */
 export async function compile(config) {
     if (!config.pkg) {
-        throw new Error("Package path (pkg) must be specified.");
+        throw new Error('Package path (pkg) must be specified.');
     }
-    // Construct the go run command with the absolute path to the goscript executable
-    const goscriptCmd = config.goscriptPath ??
-        `go run "${path.join(projectRoot, "./cmd/goscript")}"`;
-    const args = ["compile", "--package", `"${config.pkg}"`];
-    if (config.output) {
-        args.push("--output", `"${path.resolve(config.output)}"`);
-    }
-    else {
-        // Default output path if not specified, relative to the working directory
-        args.push("--output", `"./output"`);
-    }
-    // Pass the working directory to the goscript command
-    if (config.dir) {
-        args.push("--dir", `"${path.resolve(config.dir)}"`);
-    }
-    const command = `${goscriptCmd} ${args.join(" ")}`;
-    // Execute go run from the specified working directory (or current)
     const cwd = config.dir ? path.resolve(config.dir) : process.cwd();
-    try {
-        const { stdout, stderr } = await execAsync(command, { cwd });
-        if (stdout) {
-            console.log(`GoScript stdout:\n${stdout}`);
-        }
-        if (stderr) {
-            // Go compiler often prints status messages to stderr, treat as info unless exit code is non-zero
-            console.info(`GoScript stderr:\n${stderr}`);
-        }
-    }
-    catch (error) {
-        const compileErr = error instanceof Error ? error : new Error(String(error));
-        console.error(`GoScript compilation failed: ${compileErr.message}`);
-        if (typeof error === "object" &&
-            error !== null &&
-            "stderr" in error &&
-            typeof error.stderr === "string") {
-            console.error(`GoScript stderr:\n${error.stderr}`);
-        }
-        if (typeof error === "object" &&
-            error !== null &&
-            "stdout" in error &&
-            typeof error.stdout === "string") {
-            console.error(`GoScript stdout:\n${error.stdout}`);
-        }
-        throw new Error(`GoScript compilation failed: ${compileErr.message}`, {
-            cause: error,
-        });
+    const output = config.output ? path.resolve(config.output) : './output';
+    if (config.goscriptPath) {
+        await execFileAsync(config.goscriptPath, [
+            'compile',
+            '--package',
+            config.pkg,
+            '--output',
+            output,
+            '--dir',
+            cwd,
+        ]);
+        return;
     }
+    await execFileAsync('go', [
+        'run',
+        path.join(projectRoot, 'cmd/goscript'),
+        'compile',
+        '--package',
+        config.pkg,
+        '--output',
+        output,
+        '--dir',
+        cwd,
+    ]);
 }
 /**
  * Default export for convenience.

package/dist/compiler/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../compiler/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../compiler/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AACjC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACnC,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AACxC,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAA;AAC7C,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAErC,MAAM,aAAa,GAAG,SAAS,CAAC,QAAQ,CAAC,CAAA;AACzC,MAAM,UAAU,GAAG,aAAa,CAAC,OAAO,IAAI,CAAC,GAAG,CAAC,CAAA;AACjD,MAAM,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,CAAA;AACrC,MAAM,WAAW,GAAG,OAAO,CAAC,SAAS,CAAC,CAAA;AAgBtC;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,OAAO,CAAC,MAAqB;IACjD,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC;QAChB,MAAM,IAAI,KAAK,CAAC,uCAAuC,CAAC,CAAA;IAC1D,CAAC;IAED,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE,CAAA;IACjE,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,UAAU,CAAA;IAEvE,IAAI,MAAM,CAAC,YAAY,EAAE,CAAC;QACxB,MAAM,aAAa,CAAC,MAAM,CAAC,YAAY,EAAE;YACvC,SAAS;YACT,WAAW;YACX,MAAM,CAAC,GAAG;YACV,UAAU;YACV,MAAM;YACN,OAAO;YACP,GAAG;SACJ,CAAC,CAAA;QACF,OAAM;IACR,CAAC;IAED,MAAM,aAAa,CAAC,IAAI,EAAE;QACxB,KAAK;QACL,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,cAAc,CAAC;QACtC,SAAS;QACT,WAAW;QACX,MAAM,CAAC,GAAG;QACV,UAAU;QACV,MAAM;QACN,OAAO;QACP,GAAG;KACJ,CAAC,CAAA;AACJ,CAAC;AAED;;GAEG;AACH,eAAe;IACb,OAAO;CACR,CAAA"}

package/dist/gs/builtin/builtin.d.ts

@@ -1,4 +1,10 @@
 import type { Slice } from './slice.js';
+import { type VarRef } from './varRef.js';
+/**
+ * Implementation of Go's built-in print function
+ * @param args Arguments to print
+ */
+export declare function print(...args: any[]): void;
 /**
  * Implementation of Go's built-in println function
  * @param args Arguments to print
@@ -15,15 +21,40 @@ export declare function panic(...args: any[]): never;
  * For maps, it deletes all entries.
  * @param v The slice or map to clear
  */
-export declare function clear<T>(v: T[] | Map<unknown, unknown> | null): void;
+export declare function clear<T>(v: Slice<T> | Map<unknown, unknown> | null): void;
 /**
  * assignStruct copies all field values from source struct to target struct.
  * Used for pointer dereference assignment: *p = value
  * Copies the _fields contents from source to target.
  */
 export declare function assignStruct<T>(target: T, source: T): void;
+/**
+ * pointerValue unwraps a Go pointer value for generated field, method, and
+ * dereference access. Struct pointers may be represented directly as class
+ * instances or indirectly as VarRef values when the pointer came from taking a
+ * variable's address.
+ */
+export declare function pointerValue<T>(value: T | VarRef<T> | null | undefined): T;
+export declare function arrayEqual(a: unknown, b: unknown): boolean;
+export interface Complex {
+    real: number;
+    imag: number;
+}
+export declare function complex(real: number, imag: number): Complex;
+export declare function real(value: number | Complex | null | undefined): number;
+export declare function imag(value: number | Complex | null | undefined): number;
 export type Bytes = Uint8Array | Slice<number>;
-export declare function int(value: number): number;
+export declare function int(value: number | bigint, bits?: number): number;
+export declare function uint(value: number | bigint, bits?: number): number;
+export declare function uint64Shl(value: number | bigint, shift: number | bigint): number;
+export declare function uint64Shr(value: number | bigint, shift: number | bigint): number;
+export declare function uintShr(value: number | bigint, shift: number | bigint, bits?: number): number;
+export declare function uint64Mul(left: number | bigint, right: number | bigint): number;
+export declare function uint64Add(left: number | bigint, right: number | bigint): number;
+export declare function uint64Sub(left: number | bigint, right: number | bigint): number;
+export declare function uint64And(left: number | bigint, right: number | bigint): number;
+export declare function uint64Or(left: number | bigint, right: number | bigint): number;
+export declare function uint64Xor(left: number | bigint, right: number | bigint): number;
 /**
  * Normalizes various byte representations into a `Uint8Array` for protobuf compatibility.
  *