goscript 0.1.0 → 0.1.2

package/compiler/wasm/compile.go

@@ -5,7 +5,7 @@ import (
 	"github.com/aperturerobotics/goscript/compiler"
 )
 
-// CompileSource returns the v2 browser source-compilation diagnostic.
+// 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

@@ -2,28 +2,78 @@ package wasm
 
 import (
 	"errors"
+	"strings"
 	"testing"
 
 	"github.com/aperturerobotics/goscript/compiler"
 )
 
-func TestCompileSourceReportsUnsupportedSingleFile(t *testing.T) {
-	_, err := CompileSource("package main\nfunc main() {}\n", "main")
+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)
 	}
-	if len(compileErr.Diagnostics) != 1 {
-		t.Fatalf("expected one diagnostic, got %d", len(compileErr.Diagnostics))
-	}
-	diag := compileErr.Diagnostics[0]
-	if diag.Code != "goscript/wasm:single-file-unsupported" {
-		t.Fatalf("expected single-file diagnostic, got %s", diag.Code)
-	}
-	if diag.Severity != compiler.DiagnosticSeverityError {
-		t.Fatalf("expected error severity, got %s", diag.Severity)
+	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,14 +1,179 @@
 package compiler
 
+import (
+	"context"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"strconv"
+	"strings"
+
+	"golang.org/x/tools/go/packages"
+)
+
+const browserSourceFileName = "main.go"
+
 // CompileSourceToTypeScript is the WASM adapter for browser source compilation.
 func CompileSourceToTypeScript(source string, packageName string) (string, error) {
-	_ = source
-	_ = packageName
+	graph, diagnostics := browserSourceGraph(source, packageName)
+	if diagnosticsHaveErrors(diagnostics) {
+		return "", NewCompileError(diagnostics)
+	}
+
+	ctx := context.Background()
+	service := NewCompileService()
+	model, modelDiagnostics := service.semanticOwner.Build(ctx, graph)
+	diagnostics = append(diagnostics, modelDiagnostics...)
+	if diagnosticsHaveErrors(diagnostics) {
+		return "", NewCompileError(diagnostics)
+	}
+
+	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)
+	}
+
+	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)}
+	}
+
+	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),
+		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),
+	}
+	sizes := types.SizesFor("gc", "wasm")
+	if sizes == nil {
+		sizes = types.SizesFor("gc", "amd64")
+	}
+
+	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(),
+			})
+		},
+	}
+	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
+	}
+
+	node := &PackageGraphNode{
+		ID:              pkgPath,
+		PkgPath:         pkgPath,
+		Name:            file.Name.Name,
+		GoFiles:         []string{browserSourceFileName},
+		CompiledGoFiles: []string{browserSourceFileName},
+		Requested:       true,
+	}
+	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,
+	}
+	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
+}
 
-	return "", NewCompileError([]Diagnostic{{
+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:single-file-unsupported",
-		Message:  "browser source compilation is not supported by the v2 compiler",
-		Detail:   "Use goscript compile --package . from inside a Go module. The website uses precompiled examples until direct single-file compilation is scoped.",
-	}})
+		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, ", "),
+	}
 }

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

@@ -10,18 +10,23 @@ export declare function print(...args: any[]): void;
  * @param args Arguments to print
  */
 export declare function println(...args: any[]): void;
+export declare class GoPanic extends Error {
+    readonly value: unknown;
+    constructor(value: unknown);
+}
 /**
  * Implementation of Go's built-in panic function
  * @param args Arguments passed to panic
  */
-export declare function panic(...args: any[]): never;
+export declare function panic(...args: unknown[]): never;
+export declare function panicValue(value: unknown): unknown;
 /**
  * Implementation of Go's built-in clear function.
  * For slices, it sets all elements to their zero value.
  * 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
@@ -35,8 +40,40 @@ export declare function assignStruct<T>(target: T, source: T): void;
  * variable's address.
  */
 export declare function pointerValue<T>(value: T | VarRef<T> | null | undefined): T;
+export declare function pointerValueOrNil<T>(value: T | VarRef<T> | null | undefined): T | null;
+export declare function arrayEqual(a: unknown, b: unknown): boolean;
+export declare function comparableEqual(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 int64Shl(value: number | bigint, shift: number | bigint): number;
+export declare function int64Shr(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 int64Mul(left: number | bigint, right: number | bigint): number;
+export declare function uint64Div(left: number | bigint, right: number | bigint): number;
+export declare function int64Div(left: number | bigint, right: number | bigint): number;
+export declare function uint64Mod(left: number | bigint, right: number | bigint): number;
+export declare function int64Mod(left: number | bigint, right: number | bigint): number;
+export declare function uint64Add(left: number | bigint, right: number | bigint): number;
+export declare function int64Add(left: number | bigint, right: number | bigint): number;
+export declare function uint64Sub(left: number | bigint, right: number | bigint): number;
+export declare function int64Sub(left: number | bigint, right: number | bigint): number;
+export declare function uint64And(left: number | bigint, right: number | bigint): number;
+export declare function int64And(left: number | bigint, right: number | bigint): number;
+export declare function uint64Or(left: number | bigint, right: number | bigint): number;
+export declare function int64Or(left: number | bigint, right: number | bigint): number;
+export declare function uint64Xor(left: number | bigint, right: number | bigint): number;
+export declare function int64Xor(left: number | bigint, right: number | bigint): number;
 /**
  * Normalizes various byte representations into a `Uint8Array` for protobuf compatibility.
  *