goscript 0.1.4 → 0.2.1

package/compiler/override-parity.go

@@ -0,0 +1,122 @@
+package compiler
+
+import (
+	"io"
+	"io/fs"
+	"maps"
+	"path"
+	"strings"
+
+	jsoniter "github.com/aperturerobotics/json-iterator-lite"
+	"github.com/pkg/errors"
+)
+
+type overrideParityStatus string
+
+const (
+	overrideParityStatusReal     overrideParityStatus = "real"
+	overrideParityStatusBlocked  overrideParityStatus = "blocked"
+	overrideParityStatusDeferred overrideParityStatus = "deferred"
+)
+
+type overrideParityLedger struct {
+	SchemaVersion int                            `json:"schemaVersion"`
+	Strict        bool                           `json:"strict"`
+	Symbols       map[string]overrideParityEntry `json:"symbols"`
+}
+
+type overrideParityEntry struct {
+	Status overrideParityStatus `json:"status"`
+	Reason string               `json:"reason,omitempty"`
+}
+
+func newOverrideParityLedger() overrideParityLedger {
+	return overrideParityLedger{
+		Symbols: make(map[string]overrideParityEntry),
+	}
+}
+
+func loadOverrideParityLedger(root overridePackageRoot) (overrideParityLedger, error) {
+	ledger := newOverrideParityLedger()
+	data, err := fs.ReadFile(root.fsys, path.Join(root.dir, "parity.json"))
+	if err != nil {
+		if errors.Is(err, fs.ErrNotExist) {
+			return ledger, nil
+		}
+		return overrideParityLedger{}, err
+	}
+	iter := jsoniter.ParseBytes(data)
+	for field := iter.ReadObject(); field != ""; field = iter.ReadObject() {
+		switch field {
+		case "schemaVersion":
+			ledger.SchemaVersion = iter.ReadInt()
+		case "strict":
+			ledger.Strict = iter.ReadBool()
+		case "symbols":
+			for symbol := iter.ReadObject(); symbol != ""; symbol = iter.ReadObject() {
+				entry := overrideParityEntry{}
+				for entryField := iter.ReadObject(); entryField != ""; entryField = iter.ReadObject() {
+					switch entryField {
+					case "status":
+						entry.Status = overrideParityStatus(iter.ReadString())
+					case "reason":
+						entry.Reason = iter.ReadString()
+					default:
+						iter.Skip()
+					}
+				}
+				ledger.Symbols[symbol] = entry
+			}
+		default:
+			iter.Skip()
+		}
+	}
+	if iter.Error != nil && !errors.Is(iter.Error, io.EOF) {
+		return overrideParityLedger{}, iter.Error
+	}
+	if ledger.SchemaVersion != 1 {
+		return overrideParityLedger{}, errors.New("parity.json schemaVersion must be 1")
+	}
+	if ledger.Symbols == nil {
+		ledger.Symbols = make(map[string]overrideParityEntry)
+	}
+	for symbol, entry := range ledger.Symbols {
+		if symbol == "" {
+			return overrideParityLedger{}, errors.New("parity.json symbol names must not be empty")
+		}
+		if !entry.Status.valid() {
+			return overrideParityLedger{}, errors.New("parity.json contains an unknown status")
+		}
+		if entry.Status == overrideParityStatusBlocked && strings.TrimSpace(entry.Reason) == "" {
+			return overrideParityLedger{}, errors.New("parity.json blocked symbols must include a reason")
+		}
+	}
+	return ledger, nil
+}
+
+func (s overrideParityStatus) valid() bool {
+	switch s {
+	case overrideParityStatusReal,
+		overrideParityStatusBlocked,
+		overrideParityStatusDeferred:
+		return true
+	default:
+		return false
+	}
+}
+
+func (s overrideParityStatus) requiresExport() bool {
+	return s == overrideParityStatusReal
+}
+
+func (s overrideParityStatus) forbidsExport() bool {
+	return s == overrideParityStatusBlocked
+}
+
+func cloneOverrideParityLedger(ledger overrideParityLedger) overrideParityLedger {
+	return overrideParityLedger{
+		SchemaVersion: ledger.SchemaVersion,
+		Strict:        ledger.Strict,
+		Symbols:       maps.Clone(ledger.Symbols),
+	}
+}

package/compiler/override-registry_test.go

@@ -5,6 +5,7 @@ import (
 	"os"
 	"path/filepath"
 	"slices"
+	"strconv"
 	"strings"
 	"testing"
 )
@@ -80,6 +81,17 @@ func TestOverrideRegistryFactsAreImmutable(t *testing.T) {
 	if len(pkg.files) == 0 || pkg.files[0].data[0] == '!' {
 		t.Fatalf("copy file mutation leaked back into facts")
 	}
+
+	ledger := facts.parityLedger("net/http")
+	if got := ledger.Symbols["ServeFile"].Status; got != overrideParityStatusReal {
+		t.Fatalf("expected net/http ServeFile real parity, got %q", got)
+	}
+	ledger.Symbols["ServeFile"] = overrideParityEntry{Status: overrideParityStatusDeferred}
+
+	ledger = facts.parityLedger("net/http")
+	if got := ledger.Symbols["ServeFile"].Status; got != overrideParityStatusReal {
+		t.Fatalf("parity ledger mutation leaked back into facts: %q", got)
+	}
 }
 
 func TestOverrideRegistryCopiesRuntimeAndOverrides(t *testing.T) {
@@ -384,6 +396,51 @@ func TestCompilePackagesAwaitsOverrideAsyncInterfaceMethodCalls(t *testing.T) {
 	}
 }
 
+func TestCompilePackagesAwaitsNetHTTPServeHTTPOverrideMethods(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/httpserveasync\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"net/http\"",
+			"func Use(h http.Handler, hf http.HandlerFunc, mux *http.ServeMux, w http.ResponseWriter, r *http.Request) {",
+			"  h.ServeHTTP(w, r)",
+			"  hf.ServeHTTP(w, r)",
+			"  mux.ServeHTTP(w, r)",
+			"}",
+			"func main() {}",
+			"",
+		}, "\n"),
+	})
+	out := filepath.Join(t.TempDir(), "out")
+	comp, err := NewCompiler(&Config{
+		Dir:             moduleDir,
+		OutputPath:      out,
+		AllDependencies: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	content, err := os.ReadFile(filepath.Join(out, "@goscript", "example.test", "httpserveasync", "main.gs.ts"))
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	for _, want := range []string{
+		"export async function Use(",
+		"await $.pointerValue<Exclude<http.Handler, null>>(h).ServeHTTP($.pointerValueOrNil(w)!, r)",
+		"await http.HandlerFunc_ServeHTTP(hf, $.pointerValueOrNil(w)!, r)",
+		"await http.ServeMux.prototype.ServeHTTP.call($.pointerValue<http.ServeMux>(mux), $.pointerValueOrNil(w)!, r)",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing %q in generated output:\n%s", want, text)
+		}
+	}
+}
+
 func TestCompilePackagesAwaitsOverrideAsyncFunctions(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": "module example.test/overrideasyncfunc\n\ngo 1.25.3\n",
@@ -430,3 +487,505 @@ func TestCompilePackagesAwaitsOverrideAsyncFunctions(t *testing.T) {
 		t.Fatalf("walk callback was not lowered as async:\n%s", string(content))
 	}
 }
+
+func TestCompilePackagesAwaitsReflectValueCall(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/reflectcallasync\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"reflect\"",
+			"func Use(fn func()) []reflect.Value {",
+			"  return reflect.ValueOf(fn).Call(nil)",
+			"}",
+			"func UseSlice(fn func(...int), args []reflect.Value) []reflect.Value {",
+			"  return reflect.ValueOf(fn).CallSlice(args)",
+			"}",
+			"",
+		}, "\n"),
+	})
+	out := filepath.Join(t.TempDir(), "out")
+	comp, err := NewCompiler(&Config{
+		Dir:             moduleDir,
+		OutputPath:      out,
+		AllDependencies: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	content, err := os.ReadFile(filepath.Join(out, "@goscript", "example.test", "reflectcallasync", "main.gs.ts"))
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "export async function Use") {
+		t.Fatalf("reflect.Value.Call caller was not marked async:\n%s", text)
+	}
+	if !strings.Contains(text, "return await ") || !strings.Contains(text, ".Call(null)") {
+		t.Fatalf("reflect.Value.Call was not awaited:\n%s", text)
+	}
+	if !strings.Contains(text, "export async function UseSlice") {
+		t.Fatalf("reflect.Value.CallSlice caller was not marked async:\n%s", text)
+	}
+	if !strings.Contains(text, "return await ") || !strings.Contains(text, ".CallSlice(args)") {
+		t.Fatalf("reflect.Value.CallSlice was not awaited:\n%s", text)
+	}
+}
+
+func TestOverrideParityVerifierResolvesEffectiveTypeScriptExports(t *testing.T) {
+	files := map[string]string{
+		"example.test/lib/index.ts": strings.Join([]string{
+			"export { RenamedSource as Renamed } from './named.js'",
+			"export type { TypeShape } from './types.js'",
+			"export * from './star.js'",
+			"",
+		}, "\n"),
+		"example.test/lib/named.ts": "export function RenamedSource(): void {}\n",
+		"example.test/lib/star.ts":  "export class Star {}\n",
+		"example.test/lib/types.ts": "export interface TypeShape {}\n",
+	}
+	exports := make(map[string]typeScriptExport)
+	if err := collectTypeScriptExports("example.test/lib/index.ts", files, exports, make(map[string]bool)); err != nil {
+		t.Fatal(err.Error())
+	}
+	for _, name := range []string{"Renamed", "TypeShape", "Star"} {
+		if !exports[name].present() {
+			t.Fatalf("effective TypeScript exports missing %s: %v", name, exports)
+		}
+	}
+	if exports["RenamedSource"].present() {
+		t.Fatalf("named re-export source leaked into effective exports: %v", exports)
+	}
+	if !exports["Renamed"].value || exports["Renamed"].typ {
+		t.Fatalf("renamed function export should be value-only: %#v", exports["Renamed"])
+	}
+	if !exports["TypeShape"].typ || exports["TypeShape"].value {
+		t.Fatalf("type re-export should be type-only: %#v", exports["TypeShape"])
+	}
+	if !exports["Star"].value || !exports["Star"].typ {
+		t.Fatalf("class star export should carry value and type shapes: %#v", exports["Star"])
+	}
+}
+
+func TestOverrideParityVerifierValidatesNamedReExportSources(t *testing.T) {
+	files := map[string]string{
+		"example.test/lib/index.ts": "export { Missing } from './named.js'\n",
+		"example.test/lib/named.ts": "export function Present(): void {}\n",
+	}
+	err := collectTypeScriptExports("example.test/lib/index.ts", files, make(map[string]typeScriptExport), make(map[string]bool))
+	if err == nil {
+		t.Fatalf("expected missing named re-export source to fail")
+	}
+	if !strings.Contains(err.Error(), "re-exports missing symbol Missing") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestOverrideParityVerifierValidatesLocalNamedExportSources(t *testing.T) {
+	files := map[string]string{
+		"example.test/lib/index.ts": "export { Missing }\n",
+	}
+	err := collectTypeScriptExports("example.test/lib/index.ts", files, make(map[string]typeScriptExport), make(map[string]bool))
+	if err == nil {
+		t.Fatalf("expected missing local named export source to fail")
+	}
+	if !strings.Contains(err.Error(), "exports missing local value symbol Missing") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestOverrideParityVerifierReportsStrictUnclassifiedSymbol(t *testing.T) {
+	result, err := compileParityFixture(t, map[string]overrideParityEntry{
+		"Present": {Status: overrideParityStatusReal},
+	}, "export function Present(): void {}\n")
+	if err == nil {
+		t.Fatalf("expected compile to fail")
+	}
+	requireDiagnosticCode(t, result.Diagnostics, "goscript/overrides:parity-unclassified")
+}
+
+func TestOverrideParityVerifierReportsMissingTypeScriptExport(t *testing.T) {
+	result, err := compileParityFixture(t, map[string]overrideParityEntry{
+		"Present": {Status: overrideParityStatusReal},
+		"Missing": {Status: overrideParityStatusReal},
+	}, "export function Present(): void {}\n")
+	if err == nil {
+		t.Fatalf("expected compile to fail")
+	}
+	requireDiagnosticCode(t, result.Diagnostics, "goscript/overrides:parity-missing-export")
+}
+
+func TestOverrideParityVerifierRejectsTypeOnlyValueExport(t *testing.T) {
+	result, err := compileParityFixture(t, map[string]overrideParityEntry{
+		"Present": {Status: overrideParityStatusReal},
+		"Missing": {Status: overrideParityStatusReal},
+	}, strings.Join([]string{
+		"export function Present(): void {}",
+		"export type Missing = unknown",
+		"",
+	}, "\n"))
+	if err == nil {
+		t.Fatalf("expected compile to fail")
+	}
+	requireDiagnosticCode(t, result.Diagnostics, "goscript/overrides:parity-missing-export")
+}
+
+func TestOverrideParityVerifierRejectsTypeOnlyStructExport(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/structparity\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"example.test/structparity/lib\"",
+			"func main() { _ = lib.StructExport{} }",
+			"",
+		}, "\n"),
+		"lib/lib.go": strings.Join([]string{
+			"package lib",
+			"type StructExport struct{}",
+			"",
+		}, "\n"),
+	})
+	overrideDir := filepath.Join(t.TempDir(), "gs")
+	writeFixtureFile(t, overrideDir, "example.test/structparity/lib/index.ts", "export type StructExport = {}\n")
+	writeFixtureFile(t, overrideDir, "example.test/structparity/lib/parity.json", parityFixtureJSON(t, map[string]overrideParityEntry{
+		"StructExport": {Status: overrideParityStatusReal},
+	}))
+
+	comp, err := NewCompiler(&Config{
+		Dir:             moduleDir,
+		OutputPath:      filepath.Join(t.TempDir(), "out"),
+		OverrideDirs:    []string{overrideDir},
+		AllDependencies: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	result, err := comp.CompilePackages(context.Background(), ".")
+	if err == nil {
+		t.Fatalf("expected compile to fail")
+	}
+	requireDiagnosticCode(t, result.Diagnostics, "goscript/overrides:parity-missing-export")
+}
+
+func TestOverrideParityVerifierReportsBlockedTypeScriptExport(t *testing.T) {
+	result, err := compileParityFixture(t, map[string]overrideParityEntry{
+		"Present": {Status: overrideParityStatusReal},
+		"Missing": {Status: overrideParityStatusBlocked, Reason: "blocked by fixture"},
+	}, strings.Join([]string{
+		"export function Present(): void {}",
+		"export function Missing(): void {}",
+		"",
+	}, "\n"))
+	if err == nil {
+		t.Fatalf("expected compile to fail")
+	}
+	requireDiagnosticCode(t, result.Diagnostics, "goscript/overrides:parity-unexpected-export")
+}
+
+func TestOverrideParityVerifierReportsBlockedGoUse(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/blockeduse\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"example.test/blockeduse/lib\"",
+			"func main() { lib.Missing() }",
+			"",
+		}, "\n"),
+		"lib/lib.go": strings.Join([]string{
+			"package lib",
+			"func Present() {}",
+			"func Missing() {}",
+			"",
+		}, "\n"),
+	})
+	overrideDir := filepath.Join(t.TempDir(), "gs")
+	writeFixtureFile(t, overrideDir, "example.test/blockeduse/lib/index.ts", "export function Present(): void {}\n")
+	writeFixtureFile(t, overrideDir, "example.test/blockeduse/lib/parity.json", parityFixtureJSON(t, map[string]overrideParityEntry{
+		"Present": {Status: overrideParityStatusReal},
+		"Missing": {Status: overrideParityStatusBlocked, Reason: "blocked by fixture"},
+	}))
+
+	comp, err := NewCompiler(&Config{
+		Dir:             moduleDir,
+		OutputPath:      filepath.Join(t.TempDir(), "out"),
+		OverrideDirs:    []string{overrideDir},
+		AllDependencies: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	result, err := comp.CompilePackages(context.Background(), ".")
+	if err == nil {
+		t.Fatalf("expected compile to fail")
+	}
+	requireDiagnosticCode(t, result.Diagnostics, "goscript/overrides:parity-blocked-use")
+}
+
+func TestOverrideParityVerifierAllowsDeferredMissingExports(t *testing.T) {
+	result, err := compileParityFixture(t, map[string]overrideParityEntry{
+		"Present": {Status: overrideParityStatusReal},
+		"Missing": {Status: overrideParityStatusDeferred},
+	}, "export function Present(): void {}\n")
+	if err != nil {
+		t.Fatalf("compile failed: %v\n%#v", err, result.Diagnostics)
+	}
+}
+
+func TestOverrideParityVerifierReportsDeferredAtPhaseClose(t *testing.T) {
+	owner := NewOverrideRegistryOwner()
+	facts, diagnostics := owner.Facts(context.Background())
+	if diagnosticsHaveErrors(diagnostics) {
+		t.Fatalf("override facts failed: %#v", diagnostics)
+	}
+
+	diagnostics = NewOverrideParityVerifier().VerifyNoDeferred(facts,
+		"net/http",
+		"net/http/httptest",
+		"encoding/json",
+		"mime",
+		"time",
+		"reflect",
+		"math/bits",
+		"strings",
+		"strconv",
+		"compress/zlib",
+		"io",
+		"go/scanner",
+		"hash",
+		"internal/goarch",
+		"os",
+		"runtime",
+		"runtime/pprof",
+		"runtime/trace",
+	)
+	if diagnosticsHaveErrors(diagnostics) {
+		t.Fatalf("override ledgers still contain deferred entries: %#v", diagnostics)
+	}
+}
+
+func TestOverrideParityVerifierAcceptsPhase4Ledgers(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/phase4parity\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import (",
+			"  \"compress/zlib\"",
+			"  \"encoding/json\"",
+			"  \"go/scanner\"",
+			"  \"hash\"",
+			"  \"io\"",
+			"  \"math/bits\"",
+			"  \"mime\"",
+			"  \"os\"",
+			"  \"reflect\"",
+			"  \"strconv\"",
+			"  \"strings\"",
+			"  \"time\"",
+			")",
+			"var _ = json.Valid",
+			"var _ = mime.TypeByExtension",
+			"var _ = time.RFC1123",
+			"var _ = reflect.VisibleFields",
+			"var _ = bits.Rem32",
+			"var _ = strings.ToValidUTF8",
+			"var _ = strconv.FormatComplex",
+			"var _ = zlib.NoCompression",
+			"var _ io.ReadSeekCloser",
+			"var _ = scanner.PrintError",
+			"var _ hash.XOF",
+			"var _ = os.ErrNoHandle",
+			"func main() {}",
+			"",
+		}, "\n"),
+	})
+	comp, err := NewCompiler(&Config{
+		Dir:             moduleDir,
+		OutputPath:      filepath.Join(t.TempDir(), "out"),
+		AllDependencies: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	result, err := comp.CompilePackages(context.Background(), ".")
+	if err != nil {
+		t.Fatalf("compile failed: %v\n%#v", err, result.Diagnostics)
+	}
+}
+
+func TestOverrideParityVerifierAllowsRealFuncOfUse(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/funcparity\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"reflect\"",
+			"func main() {",
+			"  _ = reflect.FuncOf(nil, nil, false)",
+			"}",
+			"",
+		}, "\n"),
+	})
+	comp, err := NewCompiler(&Config{
+		Dir:             moduleDir,
+		OutputPath:      filepath.Join(t.TempDir(), "out"),
+		AllDependencies: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	result, err := comp.CompilePackages(context.Background(), ".")
+	if err != nil {
+		t.Fatalf("expected reflect.FuncOf use to compile: %v\n%#v", err, result.Diagnostics)
+	}
+}
+
+func TestOverrideParityVerifierAllowsRealMakeFuncUse(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/makefuncparity\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"reflect\"",
+			"func main() {",
+			"  typ := reflect.FuncOf(nil, nil, false)",
+			"  _ = reflect.MakeFunc(typ, func(args []reflect.Value) []reflect.Value { return nil })",
+			"}",
+			"",
+		}, "\n"),
+	})
+	comp, err := NewCompiler(&Config{
+		Dir:             moduleDir,
+		OutputPath:      filepath.Join(t.TempDir(), "out"),
+		AllDependencies: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	result, err := comp.CompilePackages(context.Background(), ".")
+	if err != nil {
+		t.Fatalf("expected reflect.MakeFunc use to compile: %v\n%#v", err, result.Diagnostics)
+	}
+}
+
+func TestOverrideParityVerifierAllowsRealStructOfUse(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/structofparity\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"reflect\"",
+			"func main() {",
+			"  _ = reflect.StructOf([]reflect.StructField{{Name: \"Count\", Type: reflect.TypeFor[int]()}})",
+			"}",
+			"",
+		}, "\n"),
+	})
+	comp, err := NewCompiler(&Config{
+		Dir:             moduleDir,
+		OutputPath:      filepath.Join(t.TempDir(), "out"),
+		AllDependencies: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	result, err := comp.CompilePackages(context.Background(), ".")
+	if err != nil {
+		t.Fatalf("expected reflect.StructOf use to compile: %v\n%#v", err, result.Diagnostics)
+	}
+}
+
+func TestOverrideParityVerifierAllowsRealSliceAtUse(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/sliceatparity\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import (",
+			"  \"reflect\"",
+			"  \"unsafe\"",
+			")",
+			"func main() {",
+			"  buf := []byte{1, 2, 3}",
+			"  _ = reflect.SliceAt(reflect.TypeFor[byte](), unsafe.Pointer(&buf[0]), len(buf))",
+			"}",
+			"",
+		}, "\n"),
+	})
+	comp, err := NewCompiler(&Config{
+		Dir:             moduleDir,
+		OutputPath:      filepath.Join(t.TempDir(), "out"),
+		AllDependencies: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	result, err := comp.CompilePackages(context.Background(), ".")
+	if err != nil {
+		t.Fatalf("expected reflect.SliceAt use to compile: %v\n%#v", err, result.Diagnostics)
+	}
+}
+
+func compileParityFixture(
+	t *testing.T,
+	symbols map[string]overrideParityEntry,
+	index string,
+) (*CompilationResult, error) {
+	t.Helper()
+
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/parity\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"example.test/parity/lib\"",
+			"func main() { lib.Present() }",
+			"",
+		}, "\n"),
+		"lib/lib.go": strings.Join([]string{
+			"package lib",
+			"func Present() {}",
+			"func Missing() {}",
+			"",
+		}, "\n"),
+	})
+	overrideDir := filepath.Join(t.TempDir(), "gs")
+	writeFixtureFile(t, overrideDir, "example.test/parity/lib/index.ts", index)
+	writeFixtureFile(t, overrideDir, "example.test/parity/lib/parity.json", parityFixtureJSON(t, symbols))
+
+	comp, err := NewCompiler(&Config{
+		Dir:             moduleDir,
+		OutputPath:      filepath.Join(t.TempDir(), "out"),
+		OverrideDirs:    []string{overrideDir},
+		AllDependencies: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	return comp.CompilePackages(context.Background(), ".")
+}
+
+func parityFixtureJSON(t *testing.T, symbols map[string]overrideParityEntry) string {
+	t.Helper()
+
+	var b strings.Builder
+	b.WriteString("{\"schemaVersion\":1,\"strict\":true,\"symbols\":{")
+	names := make([]string, 0, len(symbols))
+	for name := range symbols {
+		names = append(names, name)
+	}
+	slices.Sort(names)
+	for idx, name := range names {
+		if idx != 0 {
+			b.WriteByte(',')
+		}
+		entry := symbols[name]
+		b.WriteString(strconv.Quote(name))
+		b.WriteString(":{\"status\":")
+		b.WriteString(strconv.Quote(string(entry.Status)))
+		if entry.Reason != "" {
+			b.WriteString(",\"reason\":")
+			b.WriteString(strconv.Quote(entry.Reason))
+		}
+		b.WriteString("}")
+	}
+	b.WriteString("}}\n")
+	return b.String()
+}