@tsonic/frontend 0.0.62 → 0.0.64

package/dist/validation/imports.test.js

@@ -0,0 +1,211 @@
+import { describe, it } from "mocha";
+import { expect } from "chai";
+import * as ts from "typescript";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { validateImports } from "./imports.js";
+import { createDiagnosticsCollector } from "../types/diagnostic.js";
+import { DotnetMetadataRegistry } from "../dotnet-metadata.js";
+import { BindingRegistry } from "../program/bindings.js";
+import { createClrBindingsResolver } from "../resolver/clr-bindings-resolver.js";
+import { createBinding } from "../ir/binding/index.js";
+const createTestProgram = (source, fileName = "/test/test.ts", sourceRoot = "/test", options) => {
+    const sourceFile = ts.createSourceFile(fileName, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const compilerOptions = {
+        target: ts.ScriptTarget.ES2022,
+        module: ts.ModuleKind.NodeNext,
+        strict: true,
+        noEmit: true,
+        skipLibCheck: true,
+    };
+    const host = ts.createCompilerHost(compilerOptions);
+    const originalGetSourceFile = host.getSourceFile;
+    host.getSourceFile = (name, languageVersionOrOptions, onError, shouldCreateNewSourceFile) => {
+        if (name === fileName) {
+            return sourceFile;
+        }
+        return originalGetSourceFile.call(host, name, languageVersionOrOptions, onError, shouldCreateNewSourceFile);
+    };
+    const program = ts.createProgram([fileName], compilerOptions, host);
+    const checker = program.getTypeChecker();
+    return {
+        program,
+        checker,
+        options: {
+            projectRoot: sourceRoot,
+            sourceRoot,
+            rootNamespace: "Test",
+            surface: options?.surface,
+        },
+        sourceFiles: [sourceFile],
+        declarationSourceFiles: [],
+        metadata: new DotnetMetadataRegistry(),
+        bindings: new BindingRegistry(),
+        clrResolver: createClrBindingsResolver(sourceRoot),
+        binding: createBinding(checker),
+        sourceFile,
+    };
+};
+const runValidation = (sourceText, fileName, sourceRoot, options) => {
+    const testProgram = createTestProgram(sourceText, fileName, sourceRoot, options);
+    return validateImports(testProgram.sourceFile, testProgram, createDiagnosticsCollector());
+};
+const codes = (result) => result.diagnostics.map((diag) => diag.code);
+describe("validateImports", () => {
+    it("allows import type declarations from @tsonic/core modules", () => {
+        const result = runValidation(`
+      import type { int } from "@tsonic/core/types.js";
+      const x: int | undefined = undefined;
+      void x;
+    `);
+        expect(result.hasErrors).to.equal(false);
+        expect(codes(result)).to.deep.equal([]);
+    });
+    it("allows inline import type queries", () => {
+        const result = runValidation(`
+      type StackAlloc = import("@tsonic/core/lang.js").stackalloc;
+      const f: StackAlloc | undefined = undefined;
+      void f;
+    `);
+        expect(result.hasErrors).to.equal(false);
+        expect(codes(result)).to.deep.equal([]);
+    });
+    it("allows runtime imports from @tsonic/core modules", () => {
+        const result = runValidation(`
+      import { stackalloc } from "@tsonic/core/lang.js";
+      void stackalloc;
+    `);
+        expect(result.hasErrors).to.equal(false);
+        expect(codes(result)).to.deep.equal([]);
+    });
+    it("reports unsupported module imports with TSN1004", () => {
+        const result = runValidation(`
+      import { x } from "leftpad";
+      void x;
+    `);
+        expect(result.hasErrors).to.equal(true);
+        expect(codes(result).includes("TSN1004")).to.equal(true);
+    });
+    it("warns on default imports from local modules", () => {
+        const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "tsonic-imports-"));
+        const sourceDir = path.join(tempRoot, "src");
+        const sourceFile = path.join(sourceDir, "main.ts");
+        const importedModule = path.join(sourceDir, "module.ts");
+        fs.mkdirSync(sourceDir, { recursive: true });
+        fs.writeFileSync(importedModule, "export const value = 1;\n", "utf-8");
+        try {
+            const result = runValidation(`
+          import value from "./module.js";
+          void value;
+        `, sourceFile, tempRoot);
+            expect(result.hasErrors).to.equal(false);
+            const warningCodes = result.diagnostics
+                .filter((diag) => diag.severity === "warning")
+                .map((diag) => diag.code);
+            expect(warningCodes.includes("TSN2001")).to.equal(true);
+        }
+        finally {
+            fs.rmSync(tempRoot, { recursive: true, force: true });
+        }
+    });
+    it("allows canonical node module named imports in nodejs surface", () => {
+        const testProgram = createTestProgram(`
+        import { fs } from "node:fs";
+        void fs;
+      `, "/test/node-valid.ts", "/test", { surface: "nodejs" });
+        testProgram.bindings.addBindings("/test/node-bindings.json", {
+            bindings: {
+                "@tsonic/nodejs/index.js": {
+                    kind: "module",
+                    assembly: "nodejs",
+                    type: "nodejs.fs$instance",
+                },
+            },
+        });
+        const result = validateImports(testProgram.sourceFile, testProgram, createDiagnosticsCollector());
+        expect(result.hasErrors).to.equal(false);
+        expect(codes(result)).to.deep.equal([]);
+    });
+    it("rejects unsupported named member imports from node aliases with TSN1004", () => {
+        const testProgram = createTestProgram(`
+        import { readFileSync } from "node:fs";
+        void readFileSync;
+      `, "/test/node-invalid-member.ts", "/test", { surface: "nodejs" });
+        testProgram.bindings.addBindings("/test/node-bindings.json", {
+            bindings: {
+                "@tsonic/nodejs/index.js": {
+                    kind: "module",
+                    assembly: "nodejs",
+                    type: "nodejs.fs$instance",
+                },
+            },
+        });
+        const result = validateImports(testProgram.sourceFile, testProgram, createDiagnosticsCollector());
+        expect(result.hasErrors).to.equal(true);
+        expect(codes(result)).to.include("TSN1004");
+        expect(result.diagnostics[0]?.message).to.include("Unsupported member import");
+    });
+    it("rejects default imports from node aliases with TSN1004", () => {
+        const testProgram = createTestProgram(`
+        import fs from "node:fs";
+        void fs;
+      `, "/test/node-default-import.ts", "/test", { surface: "nodejs" });
+        testProgram.bindings.addBindings("/test/node-bindings.json", {
+            bindings: {
+                "@tsonic/nodejs/index.js": {
+                    kind: "module",
+                    assembly: "nodejs",
+                    type: "nodejs.fs$instance",
+                },
+            },
+        });
+        const result = validateImports(testProgram.sourceFile, testProgram, createDiagnosticsCollector());
+        expect(result.hasErrors).to.equal(true);
+        expect(codes(result)).to.include("TSN1004");
+        expect(result.diagnostics[0]?.message).to.include("Default import is not supported");
+    });
+    it("rejects unsupported named member imports from bare node aliases with TSN1004", () => {
+        const testProgram = createTestProgram(`
+        import { join } from "path";
+        void join;
+      `, "/test/node-bare-invalid-member.ts", "/test", { surface: "nodejs" });
+        testProgram.bindings.addBindings("/test/node-bindings.json", {
+            bindings: {
+                "@tsonic/nodejs/index.js": {
+                    kind: "module",
+                    assembly: "nodejs",
+                    type: "nodejs.path$instance",
+                },
+            },
+        });
+        const result = validateImports(testProgram.sourceFile, testProgram, createDiagnosticsCollector());
+        expect(result.hasErrors).to.equal(true);
+        expect(codes(result)).to.include("TSN1004");
+        expect(result.diagnostics[0]?.message).to.include("Unsupported member import");
+    });
+    it("reports multiple node import diagnostics in one pass", () => {
+        const testProgram = createTestProgram(`
+        import { readFileSync } from "node:fs";
+        import badPath from "node:path";
+        void readFileSync;
+        void badPath;
+      `, "/test/node-multi-diagnostics.ts", "/test", { surface: "nodejs" });
+        testProgram.bindings.addBindings("/test/node-bindings.json", {
+            bindings: {
+                "@tsonic/nodejs/index.js": {
+                    kind: "module",
+                    assembly: "nodejs",
+                    type: "nodejs.fs$instance",
+                },
+            },
+        });
+        const result = validateImports(testProgram.sourceFile, testProgram, createDiagnosticsCollector());
+        expect(result.hasErrors).to.equal(true);
+        expect(codes(result).filter((code) => code === "TSN1004").length).to.equal(2);
+        const messages = result.diagnostics.map((diag) => diag.message);
+        expect(messages.some((message) => message.includes("Unsupported member import"))).to.equal(true);
+        expect(messages.some((message) => message.includes("Default import is not supported"))).to.equal(true);
+    });
+});
+//# sourceMappingURL=imports.test.js.map

package/dist/validation/imports.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"imports.test.js","sourceRoot":"","sources":["../../src/validation/imports.test.ts"],"names":[],"mappings":"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"}

package/dist/validation/static-safety.d.ts

@@ -5,12 +5,12 @@
  * - TSN7401: 'any' type usage
  * - TSN7403: Object literal without contextual nominal type
  * - TSN7405: Untyped function/arrow/lambda parameter
- * - TSN7406: Mapped types not supported
- * - TSN7407: Conditional types not supported
- * - TSN7408: Mixed variadic tuples not supported
- * - TSN7409: 'infer' keyword not supported
- * - TSN7410: Intersection types not supported
- * - TSN7413: Dictionary key must be string or number
+ * - TSN7406: Mapped types not supported (retired)
+ * - TSN7407: Conditional types not supported (retired)
+ * - TSN7408: Mixed variadic tuples not supported (retired)
+ * - TSN7409: 'infer' keyword not supported (retired)
+ * - TSN7410: Intersection types not supported (retired)
+ * - TSN7413: Dictionary key must be string, number, or symbol
  * - TSN7430: Arrow function requires explicit types (escape hatch)
  *
  * This ensures NativeAOT-compatible, predictable-performance output.

package/dist/validation/static-safety.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"static-safety.d.ts","sourceRoot":"","sources":["../../src/validation/static-safety.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EACL,oBAAoB,EAGrB,MAAM,wBAAwB,CAAC;AAwShC;;GAEG;AACH,eAAO,MAAM,oBAAoB,GAC/B,YAAY,EAAE,CAAC,UAAU,EACzB,SAAS,aAAa,EACtB,WAAW,oBAAoB,KAC9B,oBAgaF,CAAC"}
+{"version":3,"file":"static-safety.d.ts","sourceRoot":"","sources":["../../src/validation/static-safety.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EACL,oBAAoB,EAGrB,MAAM,wBAAwB,CAAC;AAyZhC;;GAEG;AACH,eAAO,MAAM,oBAAoB,GAC/B,YAAY,EAAE,CAAC,UAAU,EACzB,SAAS,aAAa,EACtB,WAAW,oBAAoB,KAC9B,oBAkUF,CAAC"}

package/dist/validation/static-safety.js

@@ -5,12 +5,12 @@
  * - TSN7401: 'any' type usage
  * - TSN7403: Object literal without contextual nominal type
  * - TSN7405: Untyped function/arrow/lambda parameter
- * - TSN7406: Mapped types not supported
- * - TSN7407: Conditional types not supported
- * - TSN7408: Mixed variadic tuples not supported
- * - TSN7409: 'infer' keyword not supported
- * - TSN7410: Intersection types not supported
- * - TSN7413: Dictionary key must be string or number
+ * - TSN7406: Mapped types not supported (retired)
+ * - TSN7407: Conditional types not supported (retired)
+ * - TSN7408: Mixed variadic tuples not supported (retired)
+ * - TSN7409: 'infer' keyword not supported (retired)
+ * - TSN7410: Intersection types not supported (retired)
+ * - TSN7413: Dictionary key must be string, number, or symbol
  * - TSN7430: Arrow function requires explicit types (escape hatch)
  *
  * This ensures NativeAOT-compatible, predictable-performance output.
@@ -22,17 +22,35 @@
 import * as ts from "typescript";
 import { addDiagnostic, createDiagnostic, } from "../types/diagnostic.js";
 import { getNodeLocation } from "./helpers.js";
-import { UNSUPPORTED_MAPPED_UTILITY_TYPES, UNSUPPORTED_CONDITIONAL_UTILITY_TYPES, } from "./unsupported-utility-types.js";
+import { collectWrittenSymbols, collectSupportedGenericFunctionValueSymbols, getSupportedGenericFunctionDeclarationSymbol, getSupportedGenericFunctionValueSymbol, isGenericFunctionDeclarationNode, isGenericFunctionValueNode, } from "../generic-function-values.js";
 /**
  * Check basic structural eligibility for object literal synthesis.
  *
  * This is a simplified check that doesn't require TypeSystem access.
- * It validates structural constraints (no computed keys, no method shorthand, etc.)
+ * It validates structural constraints (no computed keys, no dynamic receiver method shorthand, etc.)
  * but does NOT validate spread type annotations (that requires TypeSystem).
  *
  * Full eligibility check happens during IR conversion.
  */
 const checkBasicSynthesisEligibility = (node) => {
+    const usesDynamicReceiverSemantics = (method) => {
+        let found = false;
+        const visit = (current) => {
+            if (found)
+                return;
+            if (current.kind === ts.SyntaxKind.ThisKeyword ||
+                current.kind === ts.SyntaxKind.SuperKeyword ||
+                (ts.isIdentifier(current) && current.text === "arguments")) {
+                found = true;
+                return;
+            }
+            ts.forEachChild(current, visit);
+        };
+        if (method.body) {
+            visit(method.body);
+        }
+        return found;
+    };
     for (const prop of node.properties) {
         // Property assignment: check key type
         if (ts.isPropertyAssignment(prop)) {
@@ -69,12 +87,31 @@ const checkBasicSynthesisEligibility = (node) => {
             }
             continue;
         }
-        // Method declaration: reject (use arrow functions instead)
+        // Method declarations are valid only when they can be represented as
+        // function-valued properties without dynamic receiver semantics.
         if (ts.isMethodDeclaration(prop)) {
-            return {
-                eligible: false,
-                reason: `Method shorthand is not supported. Use arrow function syntax: 'name: () => ...'`,
-            };
+            if (ts.isComputedPropertyName(prop.name)) {
+                const expr = prop.name.expression;
+                if (!ts.isStringLiteral(expr)) {
+                    return {
+                        eligible: false,
+                        reason: `Computed property key is not a string literal`,
+                    };
+                }
+            }
+            if (ts.isPrivateIdentifier(prop.name)) {
+                return {
+                    eligible: false,
+                    reason: `Private identifier (symbol) keys are not supported`,
+                };
+            }
+            if (usesDynamicReceiverSemantics(prop)) {
+                return {
+                    eligible: false,
+                    reason: "Method shorthand cannot reference this/super/arguments in synthesized types",
+                };
+            }
+            continue;
         }
         // Getter/setter: reject
         if (ts.isGetAccessorDeclaration(prop) ||
@@ -186,16 +223,6 @@ const findContainingFunction = (node) => {
     }
     return undefined;
 };
-const isArrayLikeType = (checker, type) => {
-    if (!type)
-        return false;
-    if (checker.isArrayType(type) || checker.isTupleType(type))
-        return true;
-    if (type.isUnion()) {
-        return type.types.every((t) => isArrayLikeType(checker, t));
-    }
-    return false;
-};
 /**
  * DETERMINISTIC IR TYPING (INV-0 compliant):
  * Check if an object literal is in a position where expected types are available.
@@ -261,10 +288,74 @@ const objectLiteralHasContextualType = (node) => {
     }
     return false;
 };
+const isAllowedGenericFunctionValueIdentifierUse = (node, checker) => {
+    const parent = node.parent;
+    if (ts.isFunctionDeclaration(parent) && parent.name === node)
+        return true;
+    if (ts.isVariableDeclaration(parent) && parent.name === node)
+        return true;
+    if (ts.isImportSpecifier(parent) && parent.name === node)
+        return true;
+    if (ts.isVariableDeclaration(parent) &&
+        parent.initializer === node &&
+        ts.isIdentifier(parent.name)) {
+        const declarationList = parent.parent;
+        if (ts.isVariableDeclarationList(declarationList)) {
+            const isConst = (declarationList.flags & ts.NodeFlags.Const) !== 0;
+            const isLet = (declarationList.flags & ts.NodeFlags.Let) !== 0;
+            if (isConst || isLet)
+                return true;
+        }
+    }
+    if (ts.isCallExpression(parent) && parent.expression === node)
+        return true;
+    if (ts.isTypeQueryNode(parent) && parent.exprName === node)
+        return true;
+    if (ts.isExportSpecifier(parent))
+        return true;
+    if (ts.isExportAssignment(parent) && parent.expression === node)
+        return true;
+    const contextualType = checker.getContextualType(node);
+    if (contextualType) {
+        const isNullishOnly = (type) => {
+            const flags = type.getFlags();
+            return ((flags &
+                (ts.TypeFlags.Null |
+                    ts.TypeFlags.Undefined |
+                    ts.TypeFlags.Void |
+                    ts.TypeFlags.Never)) !==
+                0);
+        };
+        const isMonomorphicCallableType = (type) => {
+            if (type.isUnion()) {
+                return type.types.every((member) => isNullishOnly(member) || isMonomorphicCallableType(member));
+            }
+            if (type.isIntersection()) {
+                return type.types.every((member) => isMonomorphicCallableType(member));
+            }
+            const signatures = checker.getSignaturesOfType(type, ts.SignatureKind.Call);
+            if (signatures.length === 0)
+                return false;
+            return signatures.every((sig) => !sig.typeParameters || sig.typeParameters.length === 0);
+        };
+        if (isMonomorphicCallableType(contextualType))
+            return true;
+    }
+    return false;
+};
+const getReferencedIdentifierSymbol = (checker, node) => {
+    const parent = node.parent;
+    if (ts.isShorthandPropertyAssignment(parent) && parent.name === node) {
+        return checker.getShorthandAssignmentValueSymbol(parent) ?? undefined;
+    }
+    return checker.getSymbolAtLocation(node);
+};
 /**
  * Validate a source file for static safety violations.
  */
 export const validateStaticSafety = (sourceFile, program, collector) => {
+    const writtenSymbols = collectWrittenSymbols(sourceFile, program.checker);
+    const supportedGenericFunctionValueSymbols = collectSupportedGenericFunctionValueSymbols(sourceFile, program.checker, writtenSymbols);
     const visitor = (node, accCollector) => {
         let currentCollector = accCollector;
         // TSN7401: Check for explicit 'any' type annotations
@@ -350,111 +441,73 @@ export const validateStaticSafety = (sourceFile, program, collector) => {
                     node.typeArguments?.some((a) => a.kind === ts.SyntaxKind.NeverKeyword)) {
                     currentCollector = addDiagnostic(currentCollector, createDiagnostic("TSN7419", "error", "'never' cannot be used as a generic type argument.", getNodeLocation(sourceFile, node), "Rewrite the type to avoid never. For Result-like types, model explicit variants (Ok<T> | Err<E>) and have helpers return the specific variant type."));
                 }
-                // TSN7406: Mapped-type utility types (these expand to mapped types internally)
-                // Only check when type arguments are present to avoid false positives for
-                // user-defined types named "Partial", etc.
-                if (hasTypeArgs && UNSUPPORTED_MAPPED_UTILITY_TYPES.has(name)) {
-                    currentCollector = addDiagnostic(currentCollector, createDiagnostic("TSN7406", "error", `Utility type '${name}' is not supported (it uses mapped types internally).`, getNodeLocation(sourceFile, node), `Replace '${name}' with an explicit interface that has the desired properties.`));
-                }
-                // TSN7407: Conditional-type utility types (these expand to conditional types internally)
-                // Only check when type arguments are present
-                if (hasTypeArgs && UNSUPPORTED_CONDITIONAL_UTILITY_TYPES.has(name)) {
-                    currentCollector = addDiagnostic(currentCollector, createDiagnostic("TSN7407", "error", `Utility type '${name}' is not supported (it uses conditional types internally).`, getNodeLocation(sourceFile, node), `Replace '${name}' with an explicit type definition.`));
-                }
                 // TSN7413: Record<K, V> where K is not an allowed key type
                 if (name === "Record") {
                     const typeArgs = node.typeArguments;
                     const keyTypeNode = typeArgs?.[0];
                     if (keyTypeNode !== undefined) {
                         if (!isAllowedKeyType(keyTypeNode)) {
-                            currentCollector = addDiagnostic(currentCollector, createDiagnostic("TSN7413", "error", "Dictionary key type must be 'string' or 'number'. Other key types are not supported.", getNodeLocation(sourceFile, keyTypeNode), "Use Record<string, V> or Record<number, V>."));
+                            currentCollector = addDiagnostic(currentCollector, createDiagnostic("TSN7413", "error", "Dictionary key type must be 'string', 'number', or 'symbol'. Other key types are not supported.", getNodeLocation(sourceFile, keyTypeNode), "Use Record<string, V>, Record<number, V>, or Record<symbol, V>."));
                         }
                     }
                 }
             }
         }
         // TSN7413: Check for unsupported index signature key types
-        // Only string and number are allowed (matches TypeScript's index signature constraints)
+        // string, number, and symbol are allowed (matches TypeScript's PropertyKey constraint)
         if (ts.isIndexSignatureDeclaration(node)) {
             const keyParam = node.parameters[0];
             if (keyParam?.type && !isAllowedKeyType(keyParam.type)) {
-                currentCollector = addDiagnostic(currentCollector, createDiagnostic("TSN7413", "error", "Index signature key type must be 'string' or 'number'. Other key types are not supported.", getNodeLocation(sourceFile, keyParam.type), "Use { [key: string]: V } or { [key: number]: V }."));
+                currentCollector = addDiagnostic(currentCollector, createDiagnostic("TSN7413", "error", "Index signature key type must be 'string', 'number', or 'symbol'. Other key types are not supported.", getNodeLocation(sourceFile, keyParam.type), "Use { [key: string]: V }, { [key: number]: V }, or { [key: symbol]: V }."));
             }
         }
-        // TSN7406: Check for mapped types (e.g., { [P in keyof T]: ... })
-        if (ts.isMappedTypeNode(node)) {
-            currentCollector = addDiagnostic(currentCollector, createDiagnostic("TSN7406", "error", "Mapped types are not supported. Write an explicit interface or class instead.", getNodeLocation(sourceFile, node), "Replace mapped types like Partial<T>, Required<T>, or { [P in keyof T]: ... } with explicit interface definitions."));
-        }
-        // TSN7407: Check for conditional types (e.g., T extends U ? X : Y)
-        if (ts.isConditionalTypeNode(node)) {
-            currentCollector = addDiagnostic(currentCollector, createDiagnostic("TSN7407", "error", "Conditional types are not supported. Use explicit union types or overloads instead.", getNodeLocation(sourceFile, node), "Replace conditional types like Extract<T, U> or T extends X ? Y : Z with explicit type definitions."));
-        }
-        // TSN7408: Check for variadic tuple types with mixed elements (e.g., [string, ...number[]])
-        // Pure variadic tuples like [...T[]] are OK (converted to arrays), fixed tuples are OK
-        // Mixed tuples with both fixed and rest elements are not supported
-        if (ts.isTupleTypeNode(node)) {
-            const hasRest = node.elements.some((el) => ts.isRestTypeNode(el));
-            const hasFixed = node.elements.some((el) => !ts.isRestTypeNode(el));
-            if (hasRest && hasFixed) {
-                currentCollector = addDiagnostic(currentCollector, createDiagnostic("TSN7408", "error", "Variadic tuple types with mixed fixed and rest elements are not supported.", getNodeLocation(sourceFile, node), "Use a fixed-length tuple like [T1, T2] or an array like T[] instead."));
+        // TSN7406 retired:
+        // Mapped types are handled by type conversion + specialization.
+        // TSN7407 retired:
+        // Conditional types are handled by utility expansion and type conversion.
+        // TSN7408 retired:
+        // Mixed variadic tuples are now lowered to array types in the converter.
+        // TSN7409 retired:
+        // infer clauses are handled by conditional/type evaluator paths.
+        // TSN7410 retired:
+        // Intersection types are lowered by the type emitter.
+        // TSN7416 retired:
+        // new Array() without explicit type argument is lowered by the emitter.
+        // TSN7417 retired:
+        // Empty arrays are inferred/erased deterministically by array conversion rules.
+        // TSN7432:
+        // Generic function values are supported for deterministic declaration/alias
+        // forms that can be lowered to C# generic method declarations:
+        // - direct generic function value declarations (`const` + never-reassigned `let`)
+        // - direct generic function declarations (`function f<T>(...) { ... }`)
+        // - deterministic alias declarations that point at supported symbols
+        //   (`const` aliases + never-reassigned `let` aliases).
+        // Non-deterministic or non-transpilable value-level usages remain hard errors.
+        if (isGenericFunctionValueNode(node)) {
+            const symbol = getSupportedGenericFunctionValueSymbol(node, program.checker, writtenSymbols);
+            const isSupported = symbol !== undefined &&
+                supportedGenericFunctionValueSymbols.has(symbol);
+            if (!isSupported) {
+                currentCollector = addDiagnostic(currentCollector, createDiagnostic("TSN7432", "error", "Generic function values are only supported in deterministic declaration/alias forms that can lower to C# generic methods.", getNodeLocation(sourceFile, node), "Use `const f = <T>(...) => ...`, `let f = <T>(...) => ...` with no reassignments, or deterministic aliases like `const g = f`."));
             }
         }
-        // TSN7409: Check for 'infer' keyword in conditional types
-        if (ts.isInferTypeNode(node)) {
-            currentCollector = addDiagnostic(currentCollector, createDiagnostic("TSN7409", "error", "The 'infer' keyword is not supported. Use explicit type parameters instead.", getNodeLocation(sourceFile, node), "Replace infer patterns with explicit generic type parameters."));
-        }
-        // TSN7410: Check for intersection types (e.g., A & B)
-        if (ts.isIntersectionTypeNode(node)) {
-            const isTypeParamConstraint = ts.isTypeParameterDeclaration(node.parent) &&
-                node.parent.constraint === node;
-            // Intersection constraints are representable as multiple C# generic constraints:
-            // `T extends A & B` -> `where T : A, B`.
-            if (!isTypeParamConstraint) {
-                currentCollector = addDiagnostic(currentCollector, createDiagnostic("TSN7410", "error", "Intersection types (A & B) are not supported. Use a nominal type that explicitly includes all required members.", getNodeLocation(sourceFile, node), "Replace the intersection with an interface or class that combines the members, or a type alias to an object type with explicit members."));
+        if (isGenericFunctionDeclarationNode(node)) {
+            const symbol = getSupportedGenericFunctionDeclarationSymbol(node, program.checker);
+            const isSupported = symbol !== undefined &&
+                supportedGenericFunctionValueSymbols.has(symbol);
+            if (!isSupported) {
+                currentCollector = addDiagnostic(currentCollector, createDiagnostic("TSN7432", "error", "Generic function declarations are only supported when their symbol remains deterministic in value positions and lowers to a C# generic method.", getNodeLocation(sourceFile, node), "Use a direct generic call (e.g., `f<T>(...)`) or deterministic const/never-reassigned let aliases."));
             }
         }
-        // TSN7416: Check for new Array() without explicit type argument
-        // new Array<T>(n) is valid, new Array() or new Array(n) without type arg is not
-        if (ts.isNewExpression(node)) {
-            const callee = node.expression;
-            if (ts.isIdentifier(callee) && callee.text === "Array") {
-                const hasTypeArgs = node.typeArguments && node.typeArguments.length > 0;
-                if (!hasTypeArgs) {
-                    currentCollector = addDiagnostic(currentCollector, createDiagnostic("TSN7416", "error", "'new Array()' requires an explicit type argument. Use 'new Array<T>(size)' instead.", getNodeLocation(sourceFile, node), "Add a type argument: new Array<int>(10), new Array<string>(5), etc."));
-                }
+        if (ts.isIdentifier(node)) {
+            const symbol = getReferencedIdentifierSymbol(program.checker, node);
+            if (symbol &&
+                supportedGenericFunctionValueSymbols.has(symbol) &&
+                !isAllowedGenericFunctionValueIdentifierUse(node, program.checker)) {
+                const name = node.text;
+                currentCollector = addDiagnostic(currentCollector, createDiagnostic("TSN7432", "error", `Generic function value '${name}' is only supported in direct call or monomorphic callable-context position where lowering is deterministic.`, getNodeLocation(sourceFile, node), "Call the function directly (e.g., `name<T>(...)`), or use it where a concrete callable type is contextually known (e.g., function argument typed as `(x: number) => number`)."));
             }
         }
-        // TSN7417: Check for empty array literal without type annotation
-        // const x = [] is invalid, const x: T[] = [] is valid
-        if (ts.isArrayLiteralExpression(node) && node.elements.length === 0) {
-            const hasContextualType = program.checker.getContextualType(node) !== undefined;
-            const parent = node.parent;
-            const hasConditionalArrayContext = ts.isConditionalExpression(parent) &&
-                isArrayLikeType(program.checker, program.checker.getTypeAtLocation(parent));
-            // Check if parent provides type context
-            const hasTypeAnnotation = (ts.isVariableDeclaration(parent) && parent.type !== undefined) ||
-                (ts.isPropertyDeclaration(parent) && parent.type !== undefined) ||
-                (ts.isParameter(parent) && parent.type !== undefined) ||
-                ts.isReturnStatement(parent) || // return type from function
-                ts.isCallExpression(parent) || // passed as argument (has contextual type)
-                ts.isPropertyAssignment(parent) || // object property (has contextual type)
-                hasConditionalArrayContext ||
-                hasContextualType;
-            if (!hasTypeAnnotation) {
-                currentCollector = addDiagnostic(currentCollector, createDiagnostic("TSN7417", "error", "Empty array literal requires a type annotation. Use 'const x: T[] = []' instead.", getNodeLocation(sourceFile, node), "Add a type annotation: const x: number[] = []; or const x: string[] = [];"));
-            }
-        }
-        // TSN7432: Generic function values are not supported.
-        //
-        // Generic methods exist in CLR, but generic functions as first-class values do not.
-        // For airplane-grade emission, we require generic functions to be declared as
-        // named function declarations (which become CLR methods), not arrow/function
-        // expressions assigned to values.
-        if ((ts.isArrowFunction(node) || ts.isFunctionExpression(node)) &&
-            node.typeParameters &&
-            node.typeParameters.length > 0) {
-            currentCollector = addDiagnostic(currentCollector, createDiagnostic("TSN7432", "error", "Generic arrow/functions are not supported as values. Use a named function declaration instead.", getNodeLocation(sourceFile, node), "Rewrite: `export function f<T>(x: T): ... { ... }`"));
-        }
         // TSN7430: Arrow function escape hatch validation
         // Non-simple arrows must have explicit type annotations
         if (ts.isArrowFunction(node)) {
@@ -470,15 +523,16 @@ export const validateStaticSafety = (sourceFile, program, collector) => {
 };
 /**
  * Check if a type node represents an allowed dictionary key type.
- * Allowed: string, number (matches TypeScript's PropertyKey constraint)
+ * Allowed: string, number, symbol (matches TypeScript's PropertyKey constraint)
  *
  * Note: TypeScript's Record<K, V> only allows K extends keyof any (string | number | symbol).
- * We support string and number. Symbol is rejected via TSN7203.
+ * We support all three PropertyKey primitives.
  */
 const isAllowedKeyType = (typeNode) => {
     // Direct keywords
     if (typeNode.kind === ts.SyntaxKind.StringKeyword ||
-        typeNode.kind === ts.SyntaxKind.NumberKeyword) {
+        typeNode.kind === ts.SyntaxKind.NumberKeyword ||
+        typeNode.kind === ts.SyntaxKind.SymbolKeyword) {
         return true;
     }
     // String literal types (e.g., "a", "b")
@@ -499,7 +553,7 @@ const isAllowedKeyType = (typeNode) => {
         const typeName = typeNode.typeName;
         if (ts.isIdentifier(typeName)) {
             const name = typeName.text;
-            if (name === "string" || name === "number") {
+            if (name === "string" || name === "number" || name === "symbol") {
                 return true;
             }
         }