@tsonic/frontend 0.0.1 → 0.0.2

package/dist/validation/orchestrator.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Validation orchestrator - coordinates all validation functions
+ */
+import * as ts from "typescript";
+import { TsonicProgram } from "../program.js";
+import { DiagnosticsCollector } from "../types/diagnostic.js";
+/**
+ * Validate an entire Tsonic program
+ */
+export declare const validateProgram: (program: TsonicProgram) => DiagnosticsCollector;
+/**
+ * Validate a single source file
+ */
+export declare const validateSourceFile: (sourceFile: ts.SourceFile, program: TsonicProgram, collector: DiagnosticsCollector) => DiagnosticsCollector;
+//# sourceMappingURL=orchestrator.d.ts.map

package/dist/validation/orchestrator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator.d.ts","sourceRoot":"","sources":["../../src/validation/orchestrator.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EACL,oBAAoB,EAErB,MAAM,wBAAwB,CAAC;AAOhC;;GAEG;AACH,eAAO,MAAM,eAAe,GAC1B,SAAS,aAAa,KACrB,oBAOF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB,GAC7B,YAAY,EAAE,CAAC,UAAU,EACzB,SAAS,aAAa,EACtB,WAAW,oBAAoB,KAC9B,oBAaF,CAAC"}

package/dist/validation/orchestrator.js

@@ -0,0 +1,30 @@
+/**
+ * Validation orchestrator - coordinates all validation functions
+ */
+import { createDiagnosticsCollector, } from "../types/diagnostic.js";
+import { validateImports } from "./imports.js";
+import { validateExports } from "./exports.js";
+import { validateUnsupportedFeatures } from "./features.js";
+import { validateGenerics } from "./generics.js";
+import { validateStaticSafety } from "./static-safety.js";
+/**
+ * Validate an entire Tsonic program
+ */
+export const validateProgram = (program) => {
+    const collector = createDiagnosticsCollector();
+    return program.sourceFiles.reduce((acc, sourceFile) => validateSourceFile(sourceFile, program, acc), collector);
+};
+/**
+ * Validate a single source file
+ */
+export const validateSourceFile = (sourceFile, program, collector) => {
+    const validationFns = [
+        validateImports,
+        validateExports,
+        validateUnsupportedFeatures,
+        validateGenerics,
+        validateStaticSafety,
+    ];
+    return validationFns.reduce((acc, fn) => fn(sourceFile, program, acc), collector);
+};
+//# sourceMappingURL=orchestrator.js.map

package/dist/validation/orchestrator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator.js","sourceRoot":"","sources":["../../src/validation/orchestrator.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,EAEL,0BAA0B,GAC3B,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAE,2BAA2B,EAAE,MAAM,eAAe,CAAC;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAE1D;;GAEG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAC7B,OAAsB,EACA,EAAE;IACxB,MAAM,SAAS,GAAG,0BAA0B,EAAE,CAAC;IAE/C,OAAO,OAAO,CAAC,WAAW,CAAC,MAAM,CAC/B,CAAC,GAAG,EAAE,UAAU,EAAE,EAAE,CAAC,kBAAkB,CAAC,UAAU,EAAE,OAAO,EAAE,GAAG,CAAC,EACjE,SAAS,CACV,CAAC;AACJ,CAAC,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAChC,UAAyB,EACzB,OAAsB,EACtB,SAA+B,EACT,EAAE;IACxB,MAAM,aAAa,GAAG;QACpB,eAAe;QACf,eAAe;QACf,2BAA2B;QAC3B,gBAAgB;QAChB,oBAAoB;KACrB,CAAC;IAEF,OAAO,aAAa,CAAC,MAAM,CACzB,CAAC,GAAG,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,UAAU,EAAE,OAAO,EAAE,GAAG,CAAC,EACzC,SAAS,CACV,CAAC;AACJ,CAAC,CAAC"}

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

@@ -0,0 +1,23 @@
+/**
+ * Static Safety Validation
+ *
+ * Detects patterns that violate static typing requirements:
+ * - TSN7401: 'any' type usage
+ * - TSN7403: Object literal without contextual nominal type
+ * - TSN7405: Untyped function/arrow/lambda parameter
+ * - TSN7413: Dictionary key must be string type
+ *
+ * This ensures NativeAOT-compatible, predictable-performance output.
+ *
+ * Note: We intentionally do NOT validate JS built-in usage (arr.map, str.length)
+ * or dictionary dot-access patterns. These will fail naturally in C# if used
+ * incorrectly, which is an acceptable failure mode.
+ */
+import * as ts from "typescript";
+import { TsonicProgram } from "../program.js";
+import { DiagnosticsCollector } from "../types/diagnostic.js";
+/**
+ * Validate a source file for static safety violations.
+ */
+export declare const validateStaticSafety: (sourceFile: ts.SourceFile, program: TsonicProgram, collector: DiagnosticsCollector) => DiagnosticsCollector;
+//# sourceMappingURL=static-safety.d.ts.map

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

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

package/dist/validation/static-safety.js

@@ -0,0 +1,165 @@
+/**
+ * Static Safety Validation
+ *
+ * Detects patterns that violate static typing requirements:
+ * - TSN7401: 'any' type usage
+ * - TSN7403: Object literal without contextual nominal type
+ * - TSN7405: Untyped function/arrow/lambda parameter
+ * - TSN7413: Dictionary key must be string type
+ *
+ * This ensures NativeAOT-compatible, predictable-performance output.
+ *
+ * Note: We intentionally do NOT validate JS built-in usage (arr.map, str.length)
+ * or dictionary dot-access patterns. These will fail naturally in C# if used
+ * incorrectly, which is an acceptable failure mode.
+ */
+import * as ts from "typescript";
+import { addDiagnostic, createDiagnostic, } from "../types/diagnostic.js";
+import { getNodeLocation } from "./helpers.js";
+/**
+ * Validate a source file for static safety violations.
+ */
+export const validateStaticSafety = (sourceFile, program, collector) => {
+    const checker = program.checker;
+    const visitor = (node, accCollector) => {
+        let currentCollector = accCollector;
+        // TSN7401: Check for explicit 'any' type annotations
+        if (node.kind === ts.SyntaxKind.AnyKeyword) {
+            currentCollector = addDiagnostic(currentCollector, createDiagnostic("TSN7401", "error", "'any' type is not supported. Provide a concrete type, use 'unknown', or define a nominal type.", getNodeLocation(sourceFile, node), "Replace 'any' with a specific type like 'unknown', 'object', or a custom interface."));
+        }
+        // TSN7401: Check for 'as any' type assertions
+        if (ts.isAsExpression(node) &&
+            node.type.kind === ts.SyntaxKind.AnyKeyword) {
+            currentCollector = addDiagnostic(currentCollector, createDiagnostic("TSN7401", "error", "'as any' type assertion is not supported. Use a specific type assertion.", getNodeLocation(sourceFile, node), "Replace 'as any' with a specific type like 'as unknown' or 'as YourType'."));
+        }
+        // TSN7405: Check for untyped function parameters
+        // Covers: function declarations, methods, constructors, arrow functions, function expressions
+        if (ts.isParameter(node) && !node.type) {
+            const parent = node.parent;
+            const isFunctionLike = ts.isFunctionDeclaration(parent) ||
+                ts.isMethodDeclaration(parent) ||
+                ts.isConstructorDeclaration(parent) ||
+                ts.isArrowFunction(parent) ||
+                ts.isFunctionExpression(parent) ||
+                ts.isGetAccessorDeclaration(parent) ||
+                ts.isSetAccessorDeclaration(parent);
+            if (isFunctionLike) {
+                const paramName = ts.isIdentifier(node.name) ? node.name.text : "param";
+                currentCollector = addDiagnostic(currentCollector, createDiagnostic("TSN7405", "error", `Parameter '${paramName}' must have an explicit type annotation.`, getNodeLocation(sourceFile, node), "Add a type annotation to this parameter."));
+            }
+        }
+        // TSN7403: Check for object literals without contextual nominal type
+        if (ts.isObjectLiteralExpression(node)) {
+            const contextualType = checker.getContextualType(node);
+            // Must have a contextual type that resolves to a nominal type or dictionary
+            if (!contextualType ||
+                !isNominalOrDictionaryType(contextualType, checker)) {
+                currentCollector = addDiagnostic(currentCollector, createDiagnostic("TSN7403", "error", "Object literal requires a contextual nominal type (interface, type alias, or class). Anonymous object types are not supported.", getNodeLocation(sourceFile, node), "Add a type annotation like 'const x: MyInterface = { ... }' or define an interface/type alias."));
+            }
+        }
+        // TSN7413: Check for non-string dictionary keys
+        // Record<K, V> where K is not string
+        if (ts.isTypeReferenceNode(node)) {
+            const typeName = node.typeName;
+            if (ts.isIdentifier(typeName) && typeName.text === "Record") {
+                const typeArgs = node.typeArguments;
+                if (typeArgs && typeArgs.length >= 1) {
+                    const keyTypeNode = typeArgs[0];
+                    if (!isStringKeyType(keyTypeNode)) {
+                        currentCollector = addDiagnostic(currentCollector, createDiagnostic("TSN7413", "error", "Dictionary key type must be 'string'. Non-string key types are not supported for NativeAOT compatibility.", getNodeLocation(sourceFile, keyTypeNode), "Use Record<string, V> instead of Record<number, V> or other key types."));
+                    }
+                }
+            }
+        }
+        // TSN7413: Check for non-string index signatures
+        // { [k: number]: V } is not allowed
+        if (ts.isIndexSignatureDeclaration(node)) {
+            const keyParam = node.parameters[0];
+            if (keyParam?.type && !isStringKeyType(keyParam.type)) {
+                currentCollector = addDiagnostic(currentCollector, createDiagnostic("TSN7413", "error", "Index signature key type must be 'string'. Non-string key types are not supported for NativeAOT compatibility.", getNodeLocation(sourceFile, keyParam.type), "Use { [key: string]: V } instead of { [key: number]: V }."));
+            }
+        }
+        // Continue visiting children
+        ts.forEachChild(node, (child) => {
+            currentCollector = visitor(child, currentCollector);
+        });
+        return currentCollector;
+    };
+    return visitor(sourceFile, collector);
+};
+/**
+ * Check if a contextual type is a nominal type (interface, type alias, class)
+ * or a dictionary type that we can emit.
+ *
+ * Returns false for anonymous object types like `{ x: number }` without a name.
+ */
+const isNominalOrDictionaryType = (type, checker) => {
+    // Check if it's a dictionary type (Record<K,V> or index signature)
+    if (isTsDictionaryType(type)) {
+        return true;
+    }
+    // Check if the type has a symbol with a declaration (named type)
+    const symbol = type.getSymbol() ?? type.aliasSymbol;
+    if (symbol) {
+        const declarations = symbol.getDeclarations();
+        if (declarations && declarations.length > 0) {
+            const decl = declarations[0];
+            // Accept: interface, type alias, class
+            if (ts.isInterfaceDeclaration(decl) ||
+                ts.isTypeAliasDeclaration(decl) ||
+                ts.isClassDeclaration(decl)) {
+                return true;
+            }
+        }
+    }
+    // Check for primitive types (allowed)
+    if (type.flags & ts.TypeFlags.String ||
+        type.flags & ts.TypeFlags.Number ||
+        type.flags & ts.TypeFlags.Boolean ||
+        type.flags & ts.TypeFlags.Null ||
+        type.flags & ts.TypeFlags.Undefined ||
+        type.flags & ts.TypeFlags.Void) {
+        return true;
+    }
+    // Check for array types (allowed)
+    if (checker.isArrayType(type) || checker.isTupleType(type)) {
+        return true;
+    }
+    return false;
+};
+/**
+ * Check if a type is a TS dictionary type (Record<K,V> or index signature).
+ *
+ * TS dictionary types:
+ * - Record<string, T> → has aliasSymbol named "Record"
+ * - { [k: string]: T } → has string index signature
+ */
+const isTsDictionaryType = (type) => {
+    // Check for Record<K,V> utility type
+    if (type.aliasSymbol?.name === "Record") {
+        return true;
+    }
+    // Check for index signature type like { [k: string]: T }
+    const stringIndexType = type.getStringIndexType();
+    const numberIndexType = type.getNumberIndexType();
+    return !!(stringIndexType || numberIndexType);
+};
+/**
+ * Check if a type node represents a string key type.
+ * Only `string` keyword is allowed for dictionary keys.
+ */
+const isStringKeyType = (typeNode) => {
+    // Direct string keyword
+    if (typeNode.kind === ts.SyntaxKind.StringKeyword) {
+        return true;
+    }
+    // Type reference to "string"
+    if (ts.isTypeReferenceNode(typeNode)) {
+        const typeName = typeNode.typeName;
+        if (ts.isIdentifier(typeName) && typeName.text === "string") {
+            return true;
+        }
+    }
+    return false;
+};
+//# sourceMappingURL=static-safety.js.map

package/dist/validation/static-safety.js.map

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

package/dist/validator.d.ts

@@ -0,0 +1,6 @@
+/**
+ * ESM and TypeScript validation rules
+ * Main dispatcher - re-exports from validation/ subdirectory
+ */
+export { validateProgram, validateSourceFile, validateImports, validateImportDeclaration, validateExports, validateUnsupportedFeatures, validateGenerics, getNodeLocation, } from "./validation/index.js";
+//# sourceMappingURL=validator.d.ts.map

package/dist/validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.d.ts","sourceRoot":"","sources":["../src/validator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,eAAe,EACf,kBAAkB,EAClB,eAAe,EACf,yBAAyB,EACzB,eAAe,EACf,2BAA2B,EAC3B,gBAAgB,EAChB,eAAe,GAChB,MAAM,uBAAuB,CAAC"}

package/dist/validator.js

@@ -0,0 +1,6 @@
+/**
+ * ESM and TypeScript validation rules
+ * Main dispatcher - re-exports from validation/ subdirectory
+ */
+export { validateProgram, validateSourceFile, validateImports, validateImportDeclaration, validateExports, validateUnsupportedFeatures, validateGenerics, getNodeLocation, } from "./validation/index.js";
+//# sourceMappingURL=validator.js.map

package/dist/validator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.js","sourceRoot":"","sources":["../src/validator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,eAAe,EACf,kBAAkB,EAClB,eAAe,EACf,yBAAyB,EACzB,eAAe,EACf,2BAA2B,EAC3B,gBAAgB,EAChB,eAAe,GAChB,MAAM,uBAAuB,CAAC"}

package/dist/validator.test.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Tests for validator - now only checks truly unsupported features
+ *
+ * Most generic constructs are now handled via:
+ * - Monomorphisation
+ * - CRTP pattern
+ * - Tuple specialisations
+ * - Structural adapters
+ */
+export {};
+//# sourceMappingURL=validator.test.d.ts.map

package/dist/validator.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.test.d.ts","sourceRoot":"","sources":["../src/validator.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG"}

package/dist/validator.test.js

@@ -0,0 +1,340 @@
+/**
+ * Tests for validator - now only checks truly unsupported features
+ *
+ * Most generic constructs are now handled via:
+ * - Monomorphisation
+ * - CRTP pattern
+ * - Tuple specialisations
+ * - Structural adapters
+ */
+import { describe, it } from "mocha";
+import { expect } from "chai";
+import * as ts from "typescript";
+import { validateProgram } from "./validator.js";
+import { DotnetMetadataRegistry } from "./dotnet-metadata.js";
+import { BindingRegistry } from "./program/bindings.js";
+import { createDotNetImportResolver } from "./resolver/dotnet-import-resolver.js";
+/**
+ * Helper to create a test program from source code
+ */
+const createTestProgram = (source, fileName = "test.ts") => {
+    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,
+    };
+    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);
+    return {
+        program,
+        checker: program.getTypeChecker(),
+        options: {
+            sourceRoot: "/test",
+            rootNamespace: "Test",
+        },
+        sourceFiles: [sourceFile],
+        metadata: new DotnetMetadataRegistry(),
+        bindings: new BindingRegistry(),
+        dotnetResolver: createDotNetImportResolver("/test"),
+    };
+};
+describe("Generic Validation", () => {
+    describe("TSN7203 - Symbol Index Signatures (still blocked)", () => {
+        it("should detect symbol index signatures", () => {
+            const source = `
+        export interface WithSymbolIndex {
+          [key: symbol]: string;
+        }
+      `;
+            const program = createTestProgram(source);
+            const diagnostics = validateProgram(program);
+            const symbolDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7203");
+            expect(symbolDiag).not.to.equal(undefined);
+            expect(symbolDiag?.message).to.include("Symbol keys are not supported in C#");
+        });
+        it("should not flag string index signatures", () => {
+            const source = `
+        interface WithStringIndex {
+          [key: string]: number;
+        }
+      `;
+            const program = createTestProgram(source);
+            const diagnostics = validateProgram(program);
+            const symbolDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7203");
+            expect(symbolDiag).to.equal(undefined);
+        });
+        it("should not flag number index signatures", () => {
+            const source = `
+        interface WithNumberIndex {
+          [key: number]: string;
+        }
+      `;
+            const program = createTestProgram(source);
+            const diagnostics = validateProgram(program);
+            const symbolDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7203");
+            expect(symbolDiag).to.equal(undefined);
+        });
+    });
+    describe("Previously-blocked constructs (now ALLOWED)", () => {
+        it("should allow recursive mapped types (handled via monomorphisation)", () => {
+            const source = `
+        type RecursiveMapped<T> = {
+          [K in keyof T]: RecursiveMapped<T[K]>
+        };
+      `;
+            const program = createTestProgram(source);
+            const diagnostics = validateProgram(program);
+            // Should NOT have TSN7101 error anymore
+            const recursiveDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7101");
+            expect(recursiveDiag).to.equal(undefined);
+        });
+        it("should allow conditional types with infer (handled via monomorphisation)", () => {
+            const source = `
+        type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;
+      `;
+            const program = createTestProgram(source);
+            const diagnostics = validateProgram(program);
+            // Should NOT have TSN7102 error anymore
+            const inferDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7102");
+            expect(inferDiag).to.equal(undefined);
+        });
+        it("should allow this typing (handled via CRTP pattern)", () => {
+            const source = `
+        interface Chainable {
+          add(value: number): this;
+        }
+      `;
+            const program = createTestProgram(source);
+            const diagnostics = validateProgram(program);
+            // Should NOT have TSN7103 error anymore
+            const thisDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7103");
+            expect(thisDiag).to.equal(undefined);
+        });
+        it("should allow variadic type parameters (handled via tuple specialisations)", () => {
+            const source = `
+        type VariadicFunction<T extends unknown[]> = (...args: T) => void;
+      `;
+            const program = createTestProgram(source);
+            const diagnostics = validateProgram(program);
+            // Should NOT have TSN7104 error anymore
+            const variadicDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7104");
+            expect(variadicDiag).to.equal(undefined);
+        });
+        it("should allow recursive structural aliases (emit as C# classes)", () => {
+            const source = `
+        type Node = {
+          name: string;
+          children: Node[];
+        };
+      `;
+            const program = createTestProgram(source);
+            const diagnostics = validateProgram(program);
+            // Should NOT have TSN7201 error anymore
+            const recursiveDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7201");
+            expect(recursiveDiag).to.equal(undefined);
+        });
+        it("should allow complex generic code without errors", () => {
+            const source = `
+        // Conditional type with infer
+        type ReturnType<T> = T extends (...args: any[]) => infer R ? R : never;
+
+        // This typing
+        interface Builder {
+          set(key: string, value: any): this;
+        }
+
+        // Variadic parameters
+        function concat<T extends any[]>(...arrays: T): T {
+          return arrays;
+        }
+
+        // Recursive structural alias
+        type Tree = {
+          value: number;
+          left?: Tree;
+          right?: Tree;
+        };
+      `;
+            const program = createTestProgram(source);
+            const diagnostics = validateProgram(program);
+            // Should have NO generic-specific diagnostics (TSN71xx, TSN72xx)
+            // Note: TSN74xx (static safety) may fire due to 'any' in test code, but that's expected
+            const genericDiags = diagnostics.diagnostics.filter((d) => d.code.startsWith("TSN71") || d.code.startsWith("TSN72"));
+            expect(genericDiags).to.have.lengthOf(0);
+        });
+    });
+});
+describe("Static Safety Validation", () => {
+    describe("TSN7401 - 'any' type banned", () => {
+        it("should reject explicit any type annotation", () => {
+            const source = `
+        export const x: any = 1;
+      `;
+            const program = createTestProgram(source);
+            const diagnostics = validateProgram(program);
+            const anyDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7401");
+            expect(anyDiag).not.to.equal(undefined);
+            expect(anyDiag?.message).to.include("'any' type is not supported");
+        });
+        it("should reject 'as any' type assertion", () => {
+            const source = `
+        export const x = (123 as any);
+      `;
+            const program = createTestProgram(source);
+            const diagnostics = validateProgram(program);
+            const anyDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7401");
+            expect(anyDiag).not.to.equal(undefined);
+            expect(anyDiag?.message).to.include("'as any'");
+        });
+        it("should allow unknown type", () => {
+            const source = `
+        export function process(data: unknown): void {
+          console.log(data);
+        }
+      `;
+            const program = createTestProgram(source);
+            const diagnostics = validateProgram(program);
+            const anyDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7401");
+            expect(anyDiag).to.equal(undefined);
+        });
+    });
+    describe("TSN7403 - Object literal requires nominal type", () => {
+        it("should reject object literal without contextual type", () => {
+            const source = `
+        const a = { x: 1 };
+      `;
+            const program = createTestProgram(source);
+            const diagnostics = validateProgram(program);
+            const objDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7403");
+            expect(objDiag).not.to.equal(undefined);
+            expect(objDiag?.message).to.include("contextual nominal type");
+        });
+        it("should allow object literal with interface type", () => {
+            const source = `
+        interface Point { x: number; y: number }
+        const p: Point = { x: 1, y: 2 };
+      `;
+            const program = createTestProgram(source);
+            const diagnostics = validateProgram(program);
+            const objDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7403");
+            expect(objDiag).to.equal(undefined);
+        });
+        it("should allow object literal with Record type", () => {
+            const source = `
+        const d: Record<string, number> = { a: 1, b: 2 };
+      `;
+            const program = createTestProgram(source);
+            const diagnostics = validateProgram(program);
+            const objDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7403");
+            expect(objDiag).to.equal(undefined);
+        });
+    });
+    describe("TSN7405 - Untyped function parameters", () => {
+        it("should reject untyped function parameter", () => {
+            const source = `
+        export function greet(name): void {
+          console.log(name);
+        }
+      `;
+            const program = createTestProgram(source);
+            const diagnostics = validateProgram(program);
+            const paramDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7405");
+            expect(paramDiag).not.to.equal(undefined);
+            expect(paramDiag?.message).to.include("explicit type annotation");
+        });
+        it("should reject untyped arrow function parameter", () => {
+            const source = `
+        const fn = (x) => x + 1;
+      `;
+            const program = createTestProgram(source);
+            const diagnostics = validateProgram(program);
+            const paramDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7405");
+            expect(paramDiag).not.to.equal(undefined);
+            expect(paramDiag?.message).to.include("explicit type annotation");
+        });
+        it("should reject untyped function expression parameter", () => {
+            const source = `
+        const fn = function(x) { return x + 1; };
+      `;
+            const program = createTestProgram(source);
+            const diagnostics = validateProgram(program);
+            const paramDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7405");
+            expect(paramDiag).not.to.equal(undefined);
+            expect(paramDiag?.message).to.include("explicit type annotation");
+        });
+        it("should allow typed function parameter", () => {
+            const source = `
+        export function greet(name: string): void {
+          console.log(name);
+        }
+      `;
+            const program = createTestProgram(source);
+            const diagnostics = validateProgram(program);
+            const paramDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7405");
+            expect(paramDiag).to.equal(undefined);
+        });
+        it("should allow typed arrow function parameter", () => {
+            const source = `
+        const fn = (x: number): number => x + 1;
+      `;
+            const program = createTestProgram(source);
+            const diagnostics = validateProgram(program);
+            const paramDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7405");
+            expect(paramDiag).to.equal(undefined);
+        });
+    });
+    describe("TSN7413 - Dictionary key must be string", () => {
+        it("should reject Record with number key", () => {
+            const source = `
+        const d: Record<number, string> = {};
+      `;
+            const program = createTestProgram(source);
+            const diagnostics = validateProgram(program);
+            const keyDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7413");
+            expect(keyDiag).not.to.equal(undefined);
+            expect(keyDiag?.message).to.include("string");
+        });
+        it("should reject index signature with number key", () => {
+            const source = `
+        interface NumIndexed {
+          [key: number]: string;
+        }
+      `;
+            const program = createTestProgram(source);
+            const diagnostics = validateProgram(program);
+            const keyDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7413");
+            expect(keyDiag).not.to.equal(undefined);
+            expect(keyDiag?.message).to.include("string");
+        });
+        it("should allow Record with string key", () => {
+            const source = `
+        const d: Record<string, number> = {};
+      `;
+            const program = createTestProgram(source);
+            const diagnostics = validateProgram(program);
+            const keyDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7413");
+            expect(keyDiag).to.equal(undefined);
+        });
+        it("should allow index signature with string key", () => {
+            const source = `
+        interface StringIndexed {
+          [key: string]: number;
+        }
+      `;
+            const program = createTestProgram(source);
+            const diagnostics = validateProgram(program);
+            const keyDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7413");
+            expect(keyDiag).to.equal(undefined);
+        });
+    });
+});
+//# sourceMappingURL=validator.test.js.map