@tsonic/frontend 0.0.1 → 0.0.2

package/src/validator.test.ts

@@ -1,468 +0,0 @@
-/**
- * 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 { TsonicProgram } from "./program.js";
-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: string,
-  fileName = "test.ts"
-): TsonicProgram => {
-  const sourceFile = ts.createSourceFile(
-    fileName,
-    source,
-    ts.ScriptTarget.Latest,
-    true,
-    ts.ScriptKind.TS
-  );
-
-  const compilerOptions: ts.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: string,
-    languageVersionOrOptions: ts.ScriptTarget | ts.CreateSourceFileOptions,
-    onError?: (message: string) => void,
-    shouldCreateNewSourceFile?: boolean
-  ) => {
-    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);
-    });
-  });
-});

package/src/validator.ts

@@ -1,15 +0,0 @@
-/**
- * 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";

package/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "composite": true,
-    "declaration": true,
-    "declarationMap": true,
-    "tsBuildInfoFile": "./dist/.tsbuildinfo"
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["node_modules", "dist"]
-}