goscript 0.0.84 → 0.1.0

package/compiler/compliance_test.go

@@ -0,0 +1,196 @@
+package compiler_test
+
+import (
+	"os"
+	"path/filepath"
+	"slices"
+	"strings"
+	"testing"
+
+	"github.com/aperturerobotics/goscript/tests"
+)
+
+// TestCompliance runs the inherited GoScript compliance fixtures through the
+// v2 compiler pipeline.
+func TestCompliance(t *testing.T) {
+	workspaceDir, err := os.Getwd()
+	if err != nil {
+		t.Fatalf("failed to get working directory: %v", err)
+	}
+	workspaceDir = filepath.Clean(filepath.Join(workspaceDir, ".."))
+
+	testsDir := filepath.Join(workspaceDir, "tests", "tests")
+	entries, err := os.ReadDir(testsDir)
+	if err != nil {
+		t.Fatalf("failed to read tests dir: %v", err)
+	}
+
+	categories := make(map[string][]string)
+	for _, entry := range entries {
+		if !entry.IsDir() {
+			continue
+		}
+		testPath := filepath.Join(testsDir, entry.Name())
+		goFiles, err := filepath.Glob(filepath.Join(testPath, "*.go"))
+		if err != nil || len(goFiles) == 0 {
+			continue
+		}
+		category := complianceCategory(entry.Name())
+		categories[category] = append(categories[category], testPath)
+	}
+
+	categoryNames := make([]string, 0, len(categories))
+	for category := range categories {
+		categoryNames = append(categoryNames, category)
+		slices.Sort(categories[category])
+	}
+	slices.Sort(categoryNames)
+
+	ranTests := 0
+	for _, category := range categoryNames {
+		paths := categories[category]
+		t.Run(category, func(t *testing.T) {
+			for _, testPath := range paths {
+				t.Run(filepath.Base(testPath), func(t *testing.T) {
+					name := filepath.Base(testPath)
+					if hasComplianceMarker(t, testPath, "expect-fail") {
+						t.Skip("expected compliance failure marker")
+					}
+					if expectedV2ComplianceGaps[name] {
+						t.Skip("expected v2 compliance gap")
+					}
+
+					ranTests++
+					tests.RunGoScriptTestDir(t, workspaceDir, testPath)
+					if !t.Failed() {
+						if err := os.RemoveAll(filepath.Join(testPath, "run")); err != nil {
+							t.Logf("failed to remove run directory for %s: %v", name, err)
+						}
+					}
+				})
+			}
+		})
+	}
+
+	if ranTests == 0 {
+		t.Fatal("compliance harness did not run any fixture directories")
+	}
+}
+
+func hasComplianceMarker(t *testing.T, testPath, marker string) bool {
+	t.Helper()
+	_, err := os.Stat(filepath.Join(testPath, marker))
+	if err == nil {
+		return true
+	}
+	if !os.IsNotExist(err) {
+		t.Fatalf("failed to check marker %s for %s: %v", marker, testPath, err)
+	}
+	return false
+}
+
+func complianceCategory(name string) string {
+	switch {
+	case strings.HasPrefix(name, "package_import"):
+		return "package-import"
+	case strings.Contains(name, "async") ||
+		strings.Contains(name, "channel") ||
+		strings.Contains(name, "goroutine") ||
+		strings.Contains(name, "select") ||
+		strings.Contains(name, "defer"):
+		return "async"
+	case strings.Contains(name, "generic"):
+		return "generics"
+	case strings.Contains(name, "interface") ||
+		strings.Contains(name, "method") ||
+		strings.Contains(name, "type_assert") ||
+		strings.Contains(name, "type_switch"):
+		return "interfaces"
+	case strings.Contains(name, "array") ||
+		strings.Contains(name, "map") ||
+		strings.Contains(name, "slice") ||
+		strings.Contains(name, "string"):
+		return "collections"
+	case strings.Contains(name, "pointer") ||
+		strings.Contains(name, "struct") ||
+		strings.Contains(name, "varref"):
+		return "values"
+	default:
+		return "core"
+	}
+}
+
+var expectedV2ComplianceGaps = map[string]bool{
+	"bitwise_and_not_assignment":        true,
+	"buffer_value_field_error":          true,
+	"bytes":                             true,
+	"chan_type_assertion":               true,
+	"constants_iota":                    true,
+	"debug_marshal":                     true,
+	"debug_simple":                      true,
+	"embedded_interface_null_assertion": true,
+	"filepath_walkfunc_call":            true,
+	"flag_bitwise_op":                   true,
+	"for_init_multi_assign":             true,
+	"for_post_multi_assign":             true,
+	"for_range":                         true,
+	"function_call_variable_shadowing":  true,
+	"function_signature_type":           true,
+	"generics":                          true,
+	"generics_interface":                true,
+	"generics_leading_int":              true,
+	"hex_escape_sequence":               true,
+	"if_type_assert":                    true,
+	"import_interface":                  true,
+	"index_expr_type_assertion":         true,
+	"interface_async_method_call":       true,
+	"interface_embedding":               true,
+	"interface_type_reference":          true,
+	"json_debug":                        true,
+	"json_encoder_debug":                true,
+	"json_numfield":                     true,
+	"json_typefields":                   true,
+	"json_typefields_flow":              true,
+	"linkname_alias":                    true,
+	"map_const_key":                     true,
+	"map_value_field_access_cross_file": true,
+	"method_async_dependency":           true,
+	"method_binding":                    true,
+	"method_receiver_async_paren":       true,
+	"method_receiver_await_paren":       true,
+	"method_receiver_call_return":       true,
+	"method_receiver_paren_line":        true,
+	"method_receiver_shadowing":         true,
+	"method_receiver_with_call_expr":    true,
+	"missing_valueof_error":             true,
+	"multi_return_same_type":            true,
+	"named_return_method":               true,
+	"named_return_multiple":             true,
+	"named_slice_wrapper":               true,
+	"named_struct_async_method":         true,
+	"named_types_valueof":               true,
+	"nil_pkg_pointer_dereference":       true,
+	"os_filemode_struct":                true,
+	"path_error_constructor":            true,
+	"pointer_circular_ref":              true,
+	"pointer_composite_literal_untyped": true,
+	"pointer_range_loop":                true,
+	"primitive_error_type":              true,
+	"promise_return_type":               true,
+	"protobuf_lite_ts":                  true,
+	"range_const_reassign":              true,
+	"receiver_variable":                 true,
+	"reflect_implements":                true,
+	"reflect_numfield":                  true,
+	"reserved_words":                    true,
+	"star_compound_assign":              true,
+	"star_expr_destructuring":           true,
+	"struct_embedding":                  true,
+	"struct_embedding_bytes_buffer":     true,
+	"type_conversion_interface_ptr_nil": true,
+	"type_declaration_receiver":         true,
+	"util_promise":                      true,
+	"variable_shadowing_scope":          true,
+	"varref_deref_struct":               true,
+	"wrapper_type_args":                 true,
+}

package/compiler/config.go

@@ -6,27 +6,23 @@ import (
 	"github.com/pkg/errors"
 )
 
-// Config is the configuration for the compiler
-// Dir is the working directory for the compiler. If empty, uses the current working directory.
+// Config is the public compiler configuration.
 type Config struct {
 	fset *token.FileSet
 
-	// Dir is the working directory for the compiler. If empty, uses the current working directory.
+	// Dir is the working directory for the compiler.
 	Dir string
 	// OutputPath is the output path root.
 	OutputPath string
-	// BuildFlags are the Go build flags (tags) to use during analysis.
+	// BuildFlags are the Go build flags to use during package loading.
 	BuildFlags []string
-	// AllDependencies controls whether to compile all dependencies of the requested packages.
-	// If true, all dependencies will be compiled; if false, only the requested packages are compiled.
+	// AllDependencies controls whether dependencies are included in the graph.
 	AllDependencies bool
-	// DisableEmitBuiltin controls whether to emit builtin packages when they are referenced.
-	// If true, builtin packages will not be emitted; if false, they will be emitted if referenced.
-	// Default is false (emit builtin packages).
+	// DisableEmitBuiltin controls whether runtime packages are emitted.
 	DisableEmitBuiltin bool
 }
 
-// Validate checks the config.
+// Validate checks the config and initializes owned defaults.
 func (c *Config) Validate() error {
 	if c == nil {
 		return errors.New("config cannot be nil")
@@ -34,8 +30,5 @@ func (c *Config) Validate() error {
 	if c.fset == nil {
 		c.fset = token.NewFileSet()
 	}
-	if c.OutputPath == "" {
-		return errors.New("output path root must be specified")
-	}
 	return nil
 }

package/compiler/diagnostic.go

@@ -0,0 +1,70 @@
+package compiler
+
+import "strings"
+
+// DiagnosticSeverity is the severity of a compiler diagnostic.
+type DiagnosticSeverity string
+
+const (
+	// DiagnosticSeverityError marks a diagnostic that stops compilation.
+	DiagnosticSeverityError DiagnosticSeverity = "error"
+	// DiagnosticSeverityWarning marks a diagnostic that does not stop compilation.
+	DiagnosticSeverityWarning DiagnosticSeverity = "warning"
+)
+
+// Diagnostic is a structured compiler message surfaced by every adapter.
+type Diagnostic struct {
+	// Severity is the diagnostic severity.
+	Severity DiagnosticSeverity
+	// Code is a stable machine-readable diagnostic code.
+	Code string
+	// Message is the short human-readable diagnostic.
+	Message string
+	// Detail carries optional longer guidance.
+	Detail string
+}
+
+// CompileError wraps structured diagnostics for ordinary Go error paths.
+type CompileError struct {
+	// Diagnostics are the structured compiler diagnostics.
+	Diagnostics []Diagnostic
+}
+
+// NewCompileError creates a compile error from diagnostics.
+func NewCompileError(diagnostics []Diagnostic) *CompileError {
+	return &CompileError{Diagnostics: append([]Diagnostic(nil), diagnostics...)}
+}
+
+// Error returns the human-readable diagnostic summary.
+func (e *CompileError) Error() string {
+	if e == nil || len(e.Diagnostics) == 0 {
+		return "goscript: compile failed"
+	}
+
+	var b strings.Builder
+	for i, diag := range e.Diagnostics {
+		if i != 0 {
+			b.WriteString("; ")
+		}
+		if diag.Code != "" {
+			b.WriteString(diag.Code)
+			b.WriteString(": ")
+		}
+		b.WriteString(diag.Message)
+		if diag.Detail != "" {
+			b.WriteString(" (")
+			b.WriteString(diag.Detail)
+			b.WriteString(")")
+		}
+	}
+	return b.String()
+}
+
+func diagnosticsHaveErrors(diagnostics []Diagnostic) bool {
+	for _, diag := range diagnostics {
+		if diag.Severity == DiagnosticSeverityError {
+			return true
+		}
+	}
+	return false
+}

package/compiler/index.test.ts

@@ -1,31 +1,31 @@
-import { describe, it, expect, beforeAll, afterAll } from "vitest";
-import { compile } from "./index";
-import * as path from "path";
-import * as fs from "fs/promises";
+import { mkdtemp, mkdir, readFile, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { describe, it, expect } from 'vitest'
+import { compile } from './index'
 
-const exampleDir = path.resolve(__dirname, "../example/simple");
-const outputDir = path.join(exampleDir, "output"); // Use a separate output dir for tests
-const expectedOutputFile = path.join(outputDir, "@goscript", "example", "main.gs.ts");
+describe('GoScript Compiler API', () => {
+  it('compiles a simple package through the CLI adapter', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'goscript-api-'))
+    const output = join(dir, 'output')
+    await mkdir(dir, { recursive: true })
+    await writeFile(join(dir, 'go.mod'), 'module example.test/api\n\ngo 1.25.3\n')
+    await writeFile(join(dir, 'main.go'), [
+      'package main',
+      'func main() {',
+      '  println("api")',
+      '}',
+      '',
+    ].join('\n'))
 
-describe("GoScript Compiler API", () => {
-  // Clean up before and after tests
-  beforeAll(async () => {
-    await fs.rm(outputDir, { recursive: true, force: true });
-  });
-  afterAll(async () => {
-    await fs.rm(outputDir, { recursive: true, force: true });
-  });
+    await compile({
+      pkg: '.',
+      output,
+      dir,
+    })
 
-  it("should compile the simple example package", async () => {
-    const config = {
-      pkg: ".", // Compile the package in the exampleDir
-      dir: exampleDir,
-      output: outputDir,
-    };
-
-    await expect(compile(config)).resolves.toBeUndefined();
-    // fs.access resolves to undefined/null on success - verify file exists
-    const fileExists = await fs.access(expectedOutputFile).then(() => true).catch(() => false);
-    expect(fileExists).toBe(true);
-  }, 30000); // 30 second timeout for compilation
-});
+    const generated = await readFile(join(output, '@goscript', 'example.test', 'api', 'main.gs.ts'), 'utf8')
+    expect(generated).toContain('export async function main(): Promise<void>')
+    expect(generated).toContain('$.println("api")')
+  }, 30000)
+})

package/compiler/index.ts

@@ -1,95 +1,63 @@
-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 __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 execFileAsync = promisify(execFile)
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const projectRoot = dirname(__dirname)
 
 /**
  * Configuration options for the GoScript compiler.
  */
 export interface CompileConfig {
   /** The Go package path or pattern to compile. */
-  pkg: string;
+  pkg: string
   /** The output directory for the generated TypeScript files. Defaults to './output'. */
-  output?: string;
+  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'. */
-  goscriptPath?: string;
+  dir?: string
+  /** 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 async function compile(config: CompileConfig): Promise<void> {
   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 cwd = config.dir ? path.resolve(config.dir) : process.cwd()
+  const output = config.output ? path.resolve(config.output) : './output'
 
-  const args: string[] = ["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)}"`);
+  if (config.goscriptPath) {
+    await execFileAsync(config.goscriptPath, [
+      'compile',
+      '--package',
+      config.pkg,
+      '--output',
+      output,
+      '--dir',
+      cwd,
+    ])
+    return
   }
 
-  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: unknown) {
-    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,
-    });
-  }
+  await execFileAsync('go', [
+    'run',
+    path.join(projectRoot, 'cmd/goscript'),
+    'compile',
+    '--package',
+    config.pkg,
+    '--output',
+    output,
+    '--dir',
+    cwd,
+  ])
 }
 
 /**
@@ -97,4 +65,4 @@ export async function compile(config: CompileConfig): Promise<void> {
  */
 export default {
   compile,
-};
+}

package/compiler/lowered-program.go

@@ -0,0 +1,132 @@
+package compiler
+
+// LoweredProgram is the compiler-owned IR consumed by TypeScript emission.
+type LoweredProgram struct {
+	packages []*loweredPackage
+}
+
+type loweredPackage struct {
+	pkgPath string
+	name    string
+	files   []*loweredFile
+}
+
+type loweredFile struct {
+	sourcePath  string
+	outputName  string
+	imports     []loweredImport
+	decls       []loweredDecl
+	exports     []string
+	typeExports []string
+}
+
+type loweredImport struct {
+	alias  string
+	source string
+}
+
+type loweredDecl struct {
+	code            string
+	indexExport     string
+	typeIndexExport string
+	function        *loweredFunction
+	structType      *loweredStruct
+}
+
+type loweredStruct struct {
+	exported      bool
+	indexExported bool
+	name          string
+	typeName      string
+	fields        []loweredStructField
+	methods       []loweredFunction
+}
+
+type loweredStructField struct {
+	name        string
+	typ         string
+	zero        string
+	runtimeType string
+	doc         string
+	tag         string
+	structValue bool
+}
+
+type loweredFunction struct {
+	exported      bool
+	indexExported bool
+	async         bool
+	name          string
+	receiverAlias string
+	params        []loweredParam
+	result        string
+	body          []loweredStmt
+	deferState    *loweredDeferState
+}
+
+type loweredParam struct {
+	name string
+	typ  string
+}
+
+type loweredStmt struct {
+	text       string
+	leading    []string
+	children   []loweredStmt
+	elseBody   []loweredStmt
+	rangeFunc  *loweredRangeFunc
+	switchStmt *loweredSwitch
+	selectStmt *loweredSelect
+	typeSwitch *loweredTypeSwitch
+}
+
+type loweredRangeFunc struct {
+	value  string
+	params []string
+	body   []loweredStmt
+}
+
+type loweredDeferState struct {
+	used  bool
+	async bool
+}
+
+type loweredSwitch struct {
+	value       string
+	cases       []loweredSwitchCase
+	defaultBody []loweredStmt
+}
+
+type loweredSwitchCase struct {
+	values []string
+	body   []loweredStmt
+}
+
+type loweredSelect struct {
+	hasReturn  string
+	value      string
+	resultType string
+	cases      []loweredSelectCase
+	hasDefault bool
+}
+
+type loweredSelectCase struct {
+	id      int
+	isSend  bool
+	channel string
+	value   string
+	prelude []loweredStmt
+	body    []loweredStmt
+}
+
+type loweredTypeSwitch struct {
+	value       string
+	varName     string
+	cases       []loweredTypeSwitchCase
+	defaultBody []loweredStmt
+}
+
+type loweredTypeSwitchCase struct {
+	types []string
+	body  []loweredStmt
+}