goscript 0.2.5 → 0.2.7

package/compiler/lowering_bench_test.go

@@ -92,6 +92,7 @@ func BenchmarkLoweringFile(b *testing.B) {
 			make(map[*types.Func]bool),
 			make(runtimeMethodSetCache),
 			false,
+			false,
 			"",
 		); diagnosticsHaveErrors(diagnostics) {
 			b.Fatal(diagnostics)

package/compiler/override-facts.go

@@ -4,12 +4,16 @@ import (
 	"bytes"
 	"context"
 	"errors"
+	"go/ast"
+	"go/parser"
+	"go/token"
 	"io"
 	"io/fs"
 	"maps"
 	"os"
 	"path"
 	"path/filepath"
+	"regexp"
 	"slices"
 	"strings"
 
@@ -17,16 +21,23 @@ import (
 	gs "github.com/s4wave/goscript"
 )
 
+var (
+	overrideBehaviorTestIdentifierPattern      = regexp.MustCompile(`\b[A-Za-z_$][A-Za-z0-9_$]*\b`)
+	overrideBehaviorTestNamedImportPattern     = regexp.MustCompile(`(?s)import\s+(type\s+)?\{([^}]*)\}\s+from\s+['"]\.[^'"]*['"]`)
+	overrideBehaviorTestNamespaceImportPattern = regexp.MustCompile(`import\s+\*\s+as\s+([A-Za-z_$][A-Za-z0-9_$]*)\s+from\s+['"]\.[^'"]*['"]`)
+)
+
 // OverrideFacts is the immutable compiler-visible view of GoScript overrides.
 type OverrideFacts struct {
 	packages map[string]overridePackageFacts
 }
 
 type overridePackageFacts struct {
-	metadata     OverrideMetadata
-	parity       overrideParityLedger
-	copyPackage  overrideCopyPackage
-	dependencies []string
+	metadata            OverrideMetadata
+	parity              overrideParityLedger
+	behaviorTestSymbols map[string]bool
+	copyPackage         overrideCopyPackage
+	dependencies        []string
 }
 
 type overridePackageRoot struct {
@@ -61,6 +72,14 @@ func (f *OverrideFacts) parityLedger(pkgPath string) overrideParityLedger {
 	return cloneOverrideParityLedger(pkg.parity)
 }
 
+func (f *OverrideFacts) behaviorTestSymbols(pkgPath string) map[string]bool {
+	if f == nil {
+		return nil
+	}
+	pkg := f.packages[pkgPath]
+	return cloneBoolMap(pkg.behaviorTestSymbols)
+}
+
 // IsMethodAsync returns true when override metadata marks a method async.
 func (f *OverrideFacts) IsMethodAsync(pkgPath, method string) bool {
 	if f == nil {
@@ -122,6 +141,7 @@ func buildOverrideFacts(ctx context.Context, overrideDirs []string) (*OverrideFa
 	slices.Sort(paths)
 
 	facts := &OverrideFacts{packages: make(map[string]overridePackageFacts, len(paths))}
+	goldenBehaviorTests := loadGoldenBehaviorTests()
 	for _, pkgPath := range paths {
 		if err := ctx.Err(); err != nil {
 			return facts, []Diagnostic{contextCanceledDiagnostic(err)}
@@ -141,11 +161,18 @@ func buildOverrideFacts(ctx context.Context, overrideDirs []string) (*OverrideFa
 		if diagnosticsHaveErrors(packageDiagnostics) {
 			continue
 		}
+		behaviorTests, err := loadOverrideBehaviorTests(roots[pkgPath], roots)
+		if err != nil {
+			diagnostics = append(diagnostics, overrideError("read override behavior tests", pkgPath, err))
+			continue
+		}
+		maps.Copy(behaviorTests, goldenBehaviorTests[pkgPath])
 		facts.packages[pkgPath] = overridePackageFacts{
-			metadata:     cloneOverrideMetadata(metadata),
-			parity:       cloneOverrideParityLedger(parity),
-			copyPackage:  copyPackage,
-			dependencies: dependencies,
+			metadata:            cloneOverrideMetadata(metadata),
+			parity:              cloneOverrideParityLedger(parity),
+			behaviorTestSymbols: behaviorTests,
+			copyPackage:         copyPackage,
+			dependencies:        dependencies,
 		}
 	}
 	if diagnosticsHaveErrors(diagnostics) {
@@ -336,6 +363,280 @@ func loadOverrideCopyPackage(
 	return copyPackage, dependencies, nil
 }
 
+func loadOverrideBehaviorTests(
+	root overridePackageRoot,
+	roots map[string]overridePackageRoot,
+) (map[string]bool, error) {
+	symbols := make(map[string]bool)
+	err := fs.WalkDir(root.fsys, root.dir, func(filePath string, entry fs.DirEntry, walkErr error) error {
+		if walkErr != nil {
+			return walkErr
+		}
+		if entry.IsDir() {
+			nestedPkg := strings.TrimPrefix(filePath, root.dir+"/")
+			if root.dir == "." {
+				nestedPkg = filePath
+			} else if nestedPkg != filePath {
+				nestedPkg = path.Join(root.pkgPath, nestedPkg)
+			}
+			if _, ok := roots[nestedPkg]; nestedPkg != root.pkgPath && ok {
+				return fs.SkipDir
+			}
+			return nil
+		}
+		if !strings.HasSuffix(filePath, ".test.ts") {
+			return nil
+		}
+		data, readErr := fs.ReadFile(root.fsys, filePath)
+		if readErr != nil {
+			return readErr
+		}
+		maps.Copy(symbols, scanOverrideBehaviorTestSymbols(string(data)))
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+	return symbols, nil
+}
+
+func scanOverrideBehaviorTestSymbols(data string) map[string]bool {
+	body := stripTypeScriptCommentsAndStrings(typeScriptBodyWithoutImports(data))
+	bodyIdentifiers := make(map[string]bool)
+	for _, match := range overrideBehaviorTestIdentifierPattern.FindAllString(body, -1) {
+		bodyIdentifiers[match] = true
+	}
+
+	symbols := make(map[string]bool)
+	for _, match := range overrideBehaviorTestNamedImportPattern.FindAllStringSubmatch(data, -1) {
+		if match[1] != "" {
+			continue
+		}
+		for _, namedImport := range parseNamedTypeScriptExports(match[2], false) {
+			if bodyIdentifiers[namedImport.target] {
+				symbols[namedImport.source] = true
+			}
+		}
+	}
+	for _, match := range overrideBehaviorTestNamespaceImportPattern.FindAllStringSubmatch(data, -1) {
+		namespaceSelectorPattern := regexp.MustCompile(`\b` + regexp.QuoteMeta(match[1]) + `\.([A-Za-z_$][A-Za-z0-9_$]*)\b`)
+		for _, selector := range namespaceSelectorPattern.FindAllStringSubmatch(body, -1) {
+			symbols[selector[1]] = true
+		}
+	}
+	return symbols
+}
+
+func typeScriptBodyWithoutImports(data string) string {
+	var body strings.Builder
+	inImport := false
+	for line := range strings.SplitAfterSeq(data, "\n") {
+		trimmed := strings.TrimSpace(line)
+		if !inImport && strings.HasPrefix(trimmed, "import ") {
+			if !strings.Contains(trimmed, " from ") &&
+				!strings.HasPrefix(trimmed, `import "`) &&
+				!strings.HasPrefix(trimmed, `import '`) {
+				inImport = true
+			}
+			body.WriteByte('\n')
+			continue
+		}
+		if inImport {
+			if strings.Contains(trimmed, " from ") {
+				inImport = false
+			}
+			body.WriteByte('\n')
+			continue
+		}
+		body.WriteString(line)
+	}
+	return body.String()
+}
+
+func stripTypeScriptCommentsAndStrings(data string) string {
+	var body strings.Builder
+	const (
+		modeCode = iota
+		modeLineComment
+		modeBlockComment
+		modeSingleString
+		modeDoubleString
+		modeTemplateString
+	)
+	mode := modeCode
+	escaped := false
+	for i := 0; i < len(data); i++ {
+		ch := data[i]
+		next := byte(0)
+		if i+1 < len(data) {
+			next = data[i+1]
+		}
+		switch mode {
+		case modeCode:
+			switch {
+			case ch == '/' && next == '/':
+				body.WriteByte(' ')
+				body.WriteByte(' ')
+				i++
+				mode = modeLineComment
+			case ch == '/' && next == '*':
+				body.WriteByte(' ')
+				body.WriteByte(' ')
+				i++
+				mode = modeBlockComment
+			case ch == '\'':
+				body.WriteByte(' ')
+				mode = modeSingleString
+			case ch == '"':
+				body.WriteByte(' ')
+				mode = modeDoubleString
+			case ch == '`':
+				body.WriteByte(' ')
+				mode = modeTemplateString
+			default:
+				body.WriteByte(ch)
+			}
+		case modeLineComment:
+			if ch == '\n' {
+				body.WriteByte(ch)
+				mode = modeCode
+				continue
+			}
+			body.WriteByte(' ')
+		case modeBlockComment:
+			if ch == '*' && next == '/' {
+				body.WriteByte(' ')
+				body.WriteByte(' ')
+				i++
+				mode = modeCode
+				continue
+			}
+			if ch == '\n' {
+				body.WriteByte(ch)
+				continue
+			}
+			body.WriteByte(' ')
+		case modeSingleString, modeDoubleString, modeTemplateString:
+			quote := byte('\'')
+			if mode == modeDoubleString {
+				quote = '"'
+			}
+			if mode == modeTemplateString {
+				quote = '`'
+			}
+			if ch == '\n' {
+				body.WriteByte(ch)
+				escaped = false
+				if mode != modeTemplateString {
+					mode = modeCode
+				}
+				continue
+			}
+			body.WriteByte(' ')
+			if escaped {
+				escaped = false
+				continue
+			}
+			if ch == '\\' {
+				escaped = true
+				continue
+			}
+			if ch == quote {
+				mode = modeCode
+			}
+		}
+	}
+	return body.String()
+}
+
+func loadGoldenBehaviorTests() map[string]map[string]bool {
+	testsDir, ok := findGoldenTestsDir()
+	if !ok {
+		return nil
+	}
+	result := make(map[string]map[string]bool)
+	_ = filepath.WalkDir(testsDir, func(filePath string, entry fs.DirEntry, err error) error {
+		if err != nil || entry.IsDir() || filepath.Ext(filePath) != ".go" {
+			return nil
+		}
+		file, parseErr := parser.ParseFile(token.NewFileSet(), filePath, nil, parser.SkipObjectResolution)
+		if parseErr != nil {
+			return nil
+		}
+		importAliases := make(map[string]string)
+		dotImports := make(map[string]bool)
+		for _, spec := range file.Imports {
+			if spec.Path == nil {
+				continue
+			}
+			pkgPath := strings.Trim(spec.Path.Value, `"`)
+			if spec.Name != nil {
+				switch spec.Name.Name {
+				case ".":
+					dotImports[pkgPath] = true
+				case "_":
+				default:
+					importAliases[spec.Name.Name] = pkgPath
+				}
+				continue
+			}
+			importAliases[path.Base(pkgPath)] = pkgPath
+		}
+		if len(importAliases) == 0 && len(dotImports) == 0 {
+			return nil
+		}
+		ast.Inspect(file, func(node ast.Node) bool {
+			switch expr := node.(type) {
+			case *ast.SelectorExpr:
+				ident, ok := expr.X.(*ast.Ident)
+				if !ok {
+					return true
+				}
+				pkgPath, ok := importAliases[ident.Name]
+				if !ok {
+					return true
+				}
+				addBehaviorTestSymbol(result, pkgPath, expr.Sel.Name)
+			case *ast.Ident:
+				for pkgPath := range dotImports {
+					addBehaviorTestSymbol(result, pkgPath, expr.Name)
+				}
+			}
+			return true
+		})
+		return nil
+	})
+	return result
+}
+
+func findGoldenTestsDir() (string, bool) {
+	wd, err := os.Getwd()
+	if err != nil {
+		return "", false
+	}
+	for {
+		candidate := filepath.Join(wd, "tests", "tests")
+		if info, statErr := os.Stat(candidate); statErr == nil && info.IsDir() {
+			return candidate, true
+		}
+		parent := filepath.Dir(wd)
+		if parent == wd {
+			return "", false
+		}
+		wd = parent
+	}
+}
+
+func addBehaviorTestSymbol(index map[string]map[string]bool, pkgPath, symbol string) {
+	if pkgPath == "" || symbol == "" {
+		return
+	}
+	if index[pkgPath] == nil {
+		index[pkgPath] = make(map[string]bool)
+	}
+	index[pkgPath][symbol] = true
+}
+
 func newOverrideMetadata() OverrideMetadata {
 	return OverrideMetadata{
 		AsyncFunctions: make(map[string]bool),

package/compiler/override-parity-verifier.go

@@ -90,12 +90,41 @@ func (v *OverrideParityVerifier) Verify(
 			})
 			continue
 		}
-		diagnostics = append(diagnostics, verifyOverrideParityPackage(node.PkgPath, pkg.Types, ledger, exports)...)
+		diagnostics = append(diagnostics, verifyOverrideParityPackage(
+			node.PkgPath,
+			pkg.Types,
+			ledger,
+			exports,
+			facts.behaviorTestSymbols(node.PkgPath),
+		)...)
 	}
 	diagnostics = append(diagnostics, verifyBlockedOverrideUses(graph, facts)...)
 	return diagnostics
 }
 
+func overrideParityRequiresTypedGraph(graph *PackageGraph, facts *OverrideFacts) bool {
+	if graph == nil || facts == nil {
+		return false
+	}
+	for _, node := range graph.Nodes {
+		if node == nil || !node.OverrideCandidate {
+			continue
+		}
+		ledger := facts.parityLedger(node.PkgPath)
+		if ledger.Strict || len(ledger.Symbols) != 0 {
+			return true
+		}
+	}
+	for _, pkg := range facts.packages {
+		for _, entry := range pkg.parity.Symbols {
+			if entry.Status == overrideParityStatusBlocked {
+				return true
+			}
+		}
+	}
+	return false
+}
+
 // VerifyNoDeferred reports transient parity entries that remain in packages
 // whose parity surface is expected to be closed.
 func (v *OverrideParityVerifier) VerifyNoDeferred(facts *OverrideFacts, pkgPaths ...string) []Diagnostic {
@@ -131,12 +160,14 @@ func verifyOverrideParityPackage(
 	goPkg *types.Package,
 	ledger overrideParityLedger,
 	tsExports map[string]typeScriptExport,
+	behaviorTests map[string]bool,
 ) []Diagnostic {
 	goExports := exportedPackageSymbols(goPkg)
 	goExportSet := make(map[string]bool, len(goExports))
 	var diagnostics []Diagnostic
 	for _, symbol := range goExports {
 		goExportSet[symbol.name] = true
+		obj := goPkg.Scope().Lookup(symbol.name)
 		entry, ok := ledger.Symbols[symbol.name]
 		if ledger.Strict && !ok {
 			diagnostics = append(diagnostics, Diagnostic{
@@ -158,6 +189,14 @@ func verifyOverrideParityPackage(
 				Detail:   pkgPath + "." + symbol.name + " is classified as " + string(entry.Status),
 			})
 		}
+		if entry.Status == overrideParityStatusReal && isPackageLevelFunc(obj) && !behaviorTests[symbol.name] {
+			diagnostics = append(diagnostics, Diagnostic{
+				Severity: DiagnosticSeverityWarning,
+				Code:     "goscript/overrides:parity-missing-behavior-test",
+				Message:  "real override function is missing a locatable behavior test",
+				Detail:   pkgPath + "." + symbol.name,
+			})
+		}
 		if entry.Status.forbidsExport() && tsExports[symbol.name].present() {
 			diagnostics = append(diagnostics, Diagnostic{
 				Severity: DiagnosticSeverityError,
@@ -180,6 +219,11 @@ func verifyOverrideParityPackage(
 	return diagnostics
 }
 
+func isPackageLevelFunc(obj types.Object) bool {
+	_, ok := obj.(*types.Func)
+	return ok
+}
+
 func (symbol goPackageExport) satisfiedBy(export typeScriptExport) bool {
 	if symbol.requiresValue {
 		return export.value

package/compiler/override-parity-verifier_test.go

@@ -0,0 +1,100 @@
+package compiler
+
+import (
+	"context"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestOverrideParityVerifierWarnsForMissingBehaviorTest(t *testing.T) {
+	result, err := compileBehaviorParityFixture(t, "")
+	if err != nil {
+		t.Fatalf("expected compile without behavior test to warn, not fail: %v\n%#v", err, result.Diagnostics)
+	}
+	requireDiagnosticCode(t, result.Diagnostics, "goscript/overrides:parity-missing-behavior-test")
+	requireDiagnosticSeverity(t, result.Diagnostics, "goscript/overrides:parity-missing-behavior-test", DiagnosticSeverityWarning)
+
+	result, err = compileBehaviorParityFixture(t, strings.Join([]string{
+		"import { Present } from './index.js'",
+		"Present()",
+		"",
+	}, "\n"))
+	if err != nil {
+		t.Fatalf("expected compile with behavior test to pass: %v\n%#v", err, result.Diagnostics)
+	}
+}
+
+func TestOverrideParityVerifierIgnoresImportOnlyBehaviorReference(t *testing.T) {
+	result, err := compileBehaviorParityFixture(t, strings.Join([]string{
+		"import { Present } from './index.js'",
+		"const name = 'Present'",
+		"void name",
+		"",
+	}, "\n"))
+	if err != nil {
+		t.Fatalf("expected import-only behavior test to warn, not fail: %v\n%#v", err, result.Diagnostics)
+	}
+	requireDiagnosticCode(t, result.Diagnostics, "goscript/overrides:parity-missing-behavior-test")
+	requireDiagnosticSeverity(t, result.Diagnostics, "goscript/overrides:parity-missing-behavior-test", DiagnosticSeverityWarning)
+}
+
+func TestOverrideParityVerifierAcceptsNamespaceBehaviorReference(t *testing.T) {
+	result, err := compileBehaviorParityFixture(t, strings.Join([]string{
+		"import * as lib from './index.js'",
+		"lib.Present()",
+		"",
+	}, "\n"))
+	if err != nil {
+		t.Fatalf("expected namespace behavior test to pass: %v\n%#v", err, result.Diagnostics)
+	}
+}
+
+func compileBehaviorParityFixture(t *testing.T, behaviorTest string) (*CompilationResult, error) {
+	t.Helper()
+
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/behaviorparity\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"example.test/behaviorparity/lib\"",
+			"func main() { lib.Present() }",
+			"",
+		}, "\n"),
+		"lib/lib.go": strings.Join([]string{
+			"package lib",
+			"func Present() {}",
+			"",
+		}, "\n"),
+	})
+	overrideDir := filepath.Join(t.TempDir(), "gs")
+	writeFixtureFile(t, overrideDir, "example.test/behaviorparity/lib/index.ts", "export function Present(): void {}\n")
+	if behaviorTest != "" {
+		writeFixtureFile(t, overrideDir, "example.test/behaviorparity/lib/index.test.ts", behaviorTest)
+	}
+	writeFixtureFile(t, overrideDir, "example.test/behaviorparity/lib/parity.json", parityFixtureJSON(t, map[string]overrideParityEntry{
+		"Present": {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())
+	}
+	return comp.CompilePackages(context.Background(), ".")
+}
+
+func requireDiagnosticSeverity(t *testing.T, diagnostics []Diagnostic, code string, severity DiagnosticSeverity) {
+	t.Helper()
+
+	for _, diagnostic := range diagnostics {
+		if diagnostic.Code == code && diagnostic.Severity == severity {
+			return
+		}
+	}
+	t.Fatalf("missing diagnostic %q with severity %q in %#v", code, severity, diagnostics)
+}

package/compiler/override-registry_test.go

@@ -1123,6 +1123,7 @@ func compileParityFixture(
 	})
 	overrideDir := filepath.Join(t.TempDir(), "gs")
 	writeFixtureFile(t, overrideDir, "example.test/parity/lib/index.ts", index)
+	writeFixtureFile(t, overrideDir, "example.test/parity/lib/index.test.ts", "import { Present } from './index.js'\nPresent()\n")
 	writeFixtureFile(t, overrideDir, "example.test/parity/lib/parity.json", parityFixtureJSON(t, symbols))
 
 	comp, err := NewCompiler(&Config{

package/compiler/package-graph.go

@@ -56,6 +56,13 @@ type PackageGraphOwner struct {
 	overrideOwner *OverrideRegistryOwner
 }
 
+type packageGraphLoadShape int
+
+const (
+	packageGraphLoadFull packageGraphLoadShape = iota
+	packageGraphLoadIdentity
+)
+
 // NewPackageGraphOwner creates the package graph owner.
 func NewPackageGraphOwner(overrideOwners ...*OverrideRegistryOwner) *PackageGraphOwner {
 	overrideOwner := NewOverrideRegistryOwner()
@@ -67,6 +74,15 @@ func NewPackageGraphOwner(overrideOwners ...*OverrideRegistryOwner) *PackageGrap
 
 // Load builds the package graph for a validated request.
 func (o *PackageGraphOwner) Load(ctx context.Context, req *CompileRequest) (*PackageGraph, []Diagnostic) {
+	return o.load(ctx, req, packageGraphLoadFull)
+}
+
+// LoadIdentity builds the package identity graph needed for cache lookup.
+func (o *PackageGraphOwner) LoadIdentity(ctx context.Context, req *CompileRequest) (*PackageGraph, []Diagnostic) {
+	return o.load(ctx, req, packageGraphLoadIdentity)
+}
+
+func (o *PackageGraphOwner) load(ctx context.Context, req *CompileRequest, shape packageGraphLoadShape) (*PackageGraph, []Diagnostic) {
 	if err := ctx.Err(); err != nil {
 		return nil, []Diagnostic{{
 			Severity: DiagnosticSeverityError,
@@ -81,18 +97,7 @@ func (o *PackageGraphOwner) Load(ctx context.Context, req *CompileRequest) (*Pac
 		Env:        append(os.Environ(), "GOOS=js", "GOARCH=wasm"),
 		BuildFlags: goScriptBuildFlags(req.BuildFlags),
 		Tests:      req.Tests,
-		Mode: packages.NeedName |
-			packages.NeedFiles |
-			packages.NeedCompiledGoFiles |
-			packages.NeedImports |
-			packages.NeedDeps |
-			packages.NeedExportFile |
-			packages.NeedTypes |
-			packages.NeedSyntax |
-			packages.NeedTypesInfo |
-			packages.NeedTypesSizes |
-			packages.NeedForTest |
-			packages.NeedModule,
+		Mode:       packageGraphLoadMode(shape),
 	}
 	pkgs, err := packages.Load(cfg, req.Patterns...)
 	if err != nil {
@@ -170,6 +175,25 @@ func (o *PackageGraphOwner) Load(ctx context.Context, req *CompileRequest) (*Pac
 	return graph, diagnostics
 }
 
+func packageGraphLoadMode(shape packageGraphLoadShape) packages.LoadMode {
+	mode := packages.NeedName |
+		packages.NeedFiles |
+		packages.NeedCompiledGoFiles |
+		packages.NeedImports |
+		packages.NeedDeps |
+		packages.NeedForTest |
+		packages.NeedModule
+	if shape == packageGraphLoadIdentity {
+		return mode
+	}
+	return mode |
+		packages.NeedExportFile |
+		packages.NeedTypes |
+		packages.NeedSyntax |
+		packages.NeedTypesInfo |
+		packages.NeedTypesSizes
+}
+
 func (o *PackageGraphOwner) collect(
 	graph *PackageGraph,
 	pkg *packages.Package,
@@ -326,6 +350,10 @@ func packageBlocklistChain(graph *PackageGraph, blocklist []string) []string {
 	return nil
 }
 
+func packageGraphContainsPackage(graph *PackageGraph, packagePath string) bool {
+	return len(packageBlocklistChain(graph, []string{packagePath})) != 0
+}
+
 func packagePathBlocklisted(path string, blocklist []string) bool {
 	for _, blocked := range blocklist {
 		// Match the package exactly or any subpackage, on a path-segment

package/compiler/package-graph_test.go

@@ -466,6 +466,35 @@ func TestPackageGraphOverrideCandidatesRequirePackageIndex(t *testing.T) {
 	}
 }
 
+func TestPackageGraphLoadIdentityOmitsTypedFacts(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod":  "module example.test/identitygraph\n\ngo 1.25.3\n",
+		"main.go": "package identitygraph\nconst Value = 1\n",
+	})
+	graph, diagnostics := NewPackageGraphOwner().LoadIdentity(context.Background(), &CompileRequest{
+		Dir:        moduleDir,
+		OutputPath: filepath.Join(t.TempDir(), "out"),
+		Patterns:   []string{"."},
+	})
+	if diagnosticsHaveErrors(diagnostics) {
+		t.Fatalf("identity graph load failed: %#v", diagnostics)
+	}
+	node := graph.NodesByPackagePath["example.test/identitygraph"]
+	if node == nil {
+		t.Fatalf("missing identity graph node: %#v", graph.NodesByPackagePath)
+	}
+	if len(node.CompiledGoFiles) != 1 || filepath.Base(node.CompiledGoFiles[0]) != "main.go" {
+		t.Fatalf("compiled files = %#v, want main.go", node.CompiledGoFiles)
+	}
+	pkg := graph.packagesByPath["example.test/identitygraph"]
+	if pkg == nil {
+		t.Fatal("missing loaded package")
+	}
+	if pkg.Types != nil || pkg.TypesInfo != nil || len(pkg.Syntax) != 0 {
+		t.Fatalf("identity graph loaded typed facts: Types=%v TypesInfo=%v Syntax=%d", pkg.Types, pkg.TypesInfo, len(pkg.Syntax))
+	}
+}
+
 func loadPackageGraph(t *testing.T, req *CompileRequest) *PackageGraph {
 	t.Helper()