@tsonic/frontend 0.0.1

package/src/types/diagnostic.test.ts

@@ -0,0 +1,164 @@
+/**
+ * Tests for diagnostic types
+ */
+
+import { describe, it } from "mocha";
+import { expect } from "chai";
+import {
+  createDiagnostic,
+  formatDiagnostic,
+  createDiagnosticsCollector,
+  addDiagnostic,
+  mergeDiagnostics,
+  isError,
+} from "./diagnostic.js";
+
+describe("Diagnostics", () => {
+  describe("createDiagnostic", () => {
+    it("should create a diagnostic with all fields", () => {
+      const diagnostic = createDiagnostic(
+        "TSN1001",
+        "error",
+        "Test error",
+        {
+          file: "test.ts",
+          line: 10,
+          column: 5,
+          length: 10,
+        },
+        "Try this instead",
+        []
+      );
+
+      expect(diagnostic.code).to.equal("TSN1001");
+      expect(diagnostic.severity).to.equal("error");
+      expect(diagnostic.message).to.equal("Test error");
+      expect(diagnostic.location?.file).to.equal("test.ts");
+      expect(diagnostic.hint).to.equal("Try this instead");
+    });
+
+    it("should create a diagnostic without optional fields", () => {
+      const diagnostic = createDiagnostic("TSN1002", "warning", "Test warning");
+
+      expect(diagnostic.code).to.equal("TSN1002");
+      expect(diagnostic.severity).to.equal("warning");
+      expect(diagnostic.location).to.equal(undefined);
+      expect(diagnostic.hint).to.equal(undefined);
+    });
+  });
+
+  describe("formatDiagnostic", () => {
+    it("should format diagnostic with location", () => {
+      const diagnostic = createDiagnostic(
+        "TSN1001",
+        "error",
+        "Missing .ts extension",
+        {
+          file: "/src/index.ts",
+          line: 5,
+          column: 10,
+          length: 15,
+        }
+      );
+
+      const formatted = formatDiagnostic(diagnostic);
+      expect(formatted).to.equal(
+        "/src/index.ts:5:10 error TSN1001: Missing .ts extension"
+      );
+    });
+
+    it("should format diagnostic without location", () => {
+      const diagnostic = createDiagnostic(
+        "TSN2001",
+        "warning",
+        "Generic warning"
+      );
+
+      const formatted = formatDiagnostic(diagnostic);
+      expect(formatted).to.equal("warning TSN2001: Generic warning");
+    });
+
+    it("should include hint if present", () => {
+      const diagnostic = createDiagnostic(
+        "TSN1001",
+        "error",
+        "Missing extension",
+        undefined,
+        "Add .ts extension"
+      );
+
+      const formatted = formatDiagnostic(diagnostic);
+      expect(formatted).to.include("Hint: Add .ts extension");
+    });
+  });
+
+  describe("DiagnosticsCollector", () => {
+    it("should start with empty diagnostics", () => {
+      const collector = createDiagnosticsCollector();
+      expect(collector.diagnostics).to.have.length(0);
+      expect(collector.hasErrors).to.equal(false);
+    });
+
+    it("should add diagnostics immutably", () => {
+      const collector1 = createDiagnosticsCollector();
+      const diagnostic = createDiagnostic("TSN1001", "error", "Test");
+
+      const collector2 = addDiagnostic(collector1, diagnostic);
+
+      expect(collector1.diagnostics).to.have.length(0);
+      expect(collector2.diagnostics).to.have.length(1);
+      expect(collector2.hasErrors).to.equal(true);
+    });
+
+    it("should track hasErrors correctly", () => {
+      let collector = createDiagnosticsCollector();
+
+      collector = addDiagnostic(
+        collector,
+        createDiagnostic("TSN1001", "warning", "Warning")
+      );
+      expect(collector.hasErrors).to.equal(false);
+
+      collector = addDiagnostic(
+        collector,
+        createDiagnostic("TSN1002", "error", "Error")
+      );
+      expect(collector.hasErrors).to.equal(true);
+
+      collector = addDiagnostic(
+        collector,
+        createDiagnostic("TSN1003", "info", "Info")
+      );
+      expect(collector.hasErrors).to.equal(true); // Still has errors
+    });
+
+    it("should merge collectors", () => {
+      const collector1 = addDiagnostic(
+        createDiagnosticsCollector(),
+        createDiagnostic("TSN1001", "error", "Error 1")
+      );
+
+      const collector2 = addDiagnostic(
+        createDiagnosticsCollector(),
+        createDiagnostic("TSN1002", "warning", "Warning 1")
+      );
+
+      const merged = mergeDiagnostics(collector1, collector2);
+
+      expect(merged.diagnostics).to.have.length(2);
+      expect(merged.hasErrors).to.equal(true);
+    });
+  });
+
+  describe("isError", () => {
+    it("should identify error diagnostics", () => {
+      const error = createDiagnostic("TSN1001", "error", "Test");
+      const warning = createDiagnostic("TSN1002", "warning", "Test");
+      const info = createDiagnostic("TSN1003", "info", "Test");
+
+      expect(isError(error)).to.equal(true);
+      expect(isError(warning)).to.equal(false);
+      expect(isError(info)).to.equal(false);
+    });
+  });
+});

package/src/types/diagnostic.ts

@@ -0,0 +1,153 @@
+/**
+ * Diagnostic types for Tsonic compiler
+ */
+
+export type DiagnosticSeverity = "error" | "warning" | "info";
+
+export type DiagnosticCode =
+  | "TSN1001" // Local import missing .ts extension
+  | "TSN1002" // Circular dependency detected
+  | "TSN1003" // Case mismatch in import path
+  | "TSN1004" // Module not found
+  | "TSN1005" // Conflicting exports
+  | "TSN1006" // Invalid namespace
+  | "TSN2001" // Unsupported TypeScript feature
+  | "TSN2002" // Invalid type mapping
+  | "TSN2003" // File name conflicts with exported member name
+  | "TSN3001" // C# reserved keyword used
+  | "TSN3002" // Invalid C# identifier
+  | "TSN3011" // Promise chaining (.then/.catch/.finally) not supported
+  | "TSN4001" // .NET interop error
+  | "TSN4002" // Missing .NET type declaration
+  | "TSN5001" // NativeAOT limitation
+  | "TSN5002" // Runtime implementation missing
+  | "TSN6001" // Internal compiler error
+  | "TSN7101" // Recursive mapped types not supported
+  | "TSN7102" // Conditional types using infer not supported
+  | "TSN7103" // `this` typing not supported
+  | "TSN7104" // Generic constructor constraints with rest parameters not supported
+  | "TSN7105" // Cannot determine required type specialisations
+  | "TSN7201" // Recursive structural alias not supported
+  | "TSN7202" // Conditional alias cannot be resolved
+  | "TSN7203" // Symbol keys not supported
+  | "TSN7204" // Variadic generic interface not supported
+  | "TSN7301" // Class cannot implement nominalized interface
+  // Static/AOT safety errors (TSN7401-TSN7499)
+  | "TSN7401" // 'any' type not supported - requires explicit type
+  | "TSN7403" // Object literal requires contextual nominal type
+  | "TSN7405" // Untyped lambda parameter - requires explicit type annotation
+  | "TSN7413" // Dictionary key must be string type
+  // Metadata loading errors (TSN9001-TSN9018)
+  | "TSN9001" // Metadata file not found
+  | "TSN9002" // Failed to read metadata file
+  | "TSN9003" // Invalid JSON in metadata file
+  | "TSN9004" // Metadata file must be an object
+  | "TSN9005" // Missing or invalid 'namespace' field
+  | "TSN9006" // Missing or invalid 'contributingAssemblies' field
+  | "TSN9007" // All 'contributingAssemblies' must be strings
+  | "TSN9008" // Missing or invalid 'types' field
+  | "TSN9009" // Invalid type: must be an object
+  | "TSN9010" // Invalid type: missing or invalid field
+  | "TSN9011" // Invalid type: 'kind' must be one of ...
+  | "TSN9012" // Invalid type: 'accessibility' must be one of ...
+  | "TSN9013" // Invalid type: field must be a boolean
+  | "TSN9014" // Invalid type: 'arity' must be a non-negative number
+  | "TSN9015" // Invalid type: field must be an array
+  | "TSN9016" // Metadata directory not found
+  | "TSN9017" // Not a directory
+  | "TSN9018" // No .metadata.json files found
+  // Bindings loading errors (TSN9101-TSN9114)
+  | "TSN9101" // Bindings file not found
+  | "TSN9102" // Failed to read bindings file
+  | "TSN9103" // Invalid JSON in bindings file
+  | "TSN9104" // Bindings file must be an object
+  | "TSN9105" // Missing or invalid 'namespace' field
+  | "TSN9106" // Missing or invalid 'types' field
+  | "TSN9107" // Invalid type binding: must be an object
+  | "TSN9108" // Invalid type binding: missing or invalid field
+  | "TSN9109" // Invalid type binding: 'metadataToken' must be a number
+  | "TSN9110" // Invalid type binding: V1 field must be an array if present
+  | "TSN9111" // Invalid type binding: V2 field must be an array if present
+  | "TSN9112" // Bindings directory not found
+  | "TSN9113" // Not a directory
+  | "TSN9114"; // No .bindings.json files found
+
+export type SourceLocation = {
+  readonly file: string;
+  readonly line: number;
+  readonly column: number;
+  readonly length: number;
+};
+
+export type Diagnostic = {
+  readonly code: DiagnosticCode;
+  readonly severity: DiagnosticSeverity;
+  readonly message: string;
+  readonly location?: SourceLocation;
+  readonly hint?: string;
+  readonly relatedLocations?: readonly SourceLocation[];
+};
+
+export const createDiagnostic = (
+  code: DiagnosticCode,
+  severity: DiagnosticSeverity,
+  message: string,
+  location?: SourceLocation,
+  hint?: string,
+  relatedLocations?: readonly SourceLocation[]
+): Diagnostic => ({
+  code,
+  severity,
+  message,
+  location,
+  hint,
+  relatedLocations,
+});
+
+export const isError = (diagnostic: Diagnostic): boolean =>
+  diagnostic.severity === "error";
+
+export const formatDiagnostic = (diagnostic: Diagnostic): string => {
+  const parts: string[] = [];
+
+  if (diagnostic.location) {
+    parts.push(
+      `${diagnostic.location.file}:${diagnostic.location.line}:${diagnostic.location.column}`
+    );
+  }
+
+  parts.push(`${diagnostic.severity} ${diagnostic.code}:`);
+  parts.push(diagnostic.message);
+
+  if (diagnostic.hint) {
+    parts.push(`Hint: ${diagnostic.hint}`);
+  }
+
+  return parts.join(" ");
+};
+
+export type DiagnosticsCollector = {
+  readonly diagnostics: readonly Diagnostic[];
+  readonly hasErrors: boolean;
+};
+
+export const createDiagnosticsCollector = (): DiagnosticsCollector => ({
+  diagnostics: [],
+  hasErrors: false,
+});
+
+export const addDiagnostic = (
+  collector: DiagnosticsCollector,
+  diagnostic: Diagnostic
+): DiagnosticsCollector => ({
+  diagnostics: [...collector.diagnostics, diagnostic],
+  hasErrors: collector.hasErrors || isError(diagnostic),
+});
+
+export const mergeDiagnostics = (
+  collector1: DiagnosticsCollector,
+  collector2: DiagnosticsCollector
+): DiagnosticsCollector => ({
+  diagnostics: [...collector1.diagnostics, ...collector2.diagnostics],
+  hasErrors: collector1.hasErrors || collector2.hasErrors,
+});

package/src/types/explicit-views.test.ts

@@ -0,0 +1,113 @@
+/**
+ * Tests for explicit interface views handling
+ */
+
+import { describe, it } from "mocha";
+import { strict as assert } from "assert";
+import {
+  isExplicitViewProperty,
+  extractInterfaceNameFromView,
+  buildViewPropertyName,
+  generateInterfaceCast,
+  generateGenericInterfaceCast,
+} from "./explicit-views.js";
+
+describe("Explicit Interface Views", () => {
+  describe("isExplicitViewProperty", () => {
+    it("should detect As_IInterface pattern", () => {
+      assert.ok(isExplicitViewProperty("As_ICollection"));
+      assert.ok(isExplicitViewProperty("As_IEnumerable"));
+    });
+
+    it("should return false for non-view properties", () => {
+      assert.ok(!isExplicitViewProperty("Length"));
+      assert.ok(!isExplicitViewProperty("Count"));
+    });
+  });
+
+  describe("extractInterfaceNameFromView", () => {
+    it("should extract interface name from As_ prefix", () => {
+      const name = extractInterfaceNameFromView("As_ICollection");
+
+      assert.equal(name, "ICollection");
+    });
+
+    it("should handle generic interface names", () => {
+      const name = extractInterfaceNameFromView("As_IEnumerable_1");
+
+      assert.equal(name, "IEnumerable_1");
+    });
+
+    it("should return undefined for invalid pattern", () => {
+      const name = extractInterfaceNameFromView("InvalidProperty");
+
+      assert.equal(name, undefined);
+    });
+  });
+
+  describe("buildViewPropertyName", () => {
+    it("should build As_ property name from interface", () => {
+      const name = buildViewPropertyName("ICollection");
+
+      assert.equal(name, "As_ICollection");
+    });
+
+    it("should handle generic interfaces", () => {
+      const name = buildViewPropertyName("IEnumerable_1");
+
+      assert.equal(name, "As_IEnumerable_1");
+    });
+  });
+
+  describe("generateInterfaceCast", () => {
+    it("should generate C# cast expression", () => {
+      const cast = generateInterfaceCast(
+        "list",
+        "System.Collections.ICollection"
+      );
+
+      assert.equal(cast, "((ICollection)list)");
+    });
+
+    it("should extract short name from qualified name", () => {
+      const cast = generateInterfaceCast(
+        "obj",
+        "System.Collections.Generic.IEnumerable"
+      );
+
+      assert.equal(cast, "((IEnumerable)obj)");
+    });
+  });
+
+  describe("generateGenericInterfaceCast", () => {
+    it("should generate generic cast with type arguments", () => {
+      const cast = generateGenericInterfaceCast(
+        "list",
+        "System.Collections.Generic.ICollection`1",
+        ["string"]
+      );
+
+      assert.equal(cast, "((ICollection<string>)list)");
+    });
+
+    it("should handle multiple type arguments", () => {
+      const cast = generateGenericInterfaceCast(
+        "dict",
+        "System.Collections.Generic.IDictionary`2",
+        ["string", "int"]
+      );
+
+      assert.equal(cast, "((IDictionary<string, int>)dict)");
+    });
+
+    it("should handle empty type arguments", () => {
+      const cast = generateGenericInterfaceCast(
+        "obj",
+        "System.Collections.ICollection",
+        []
+      );
+
+      assert.equal(cast, "((ICollection)obj)");
+    });
+  });
+});

package/src/types/explicit-views.ts

@@ -0,0 +1,218 @@
+/**
+ * Explicit Interface Views - Handle As_IInterface pattern for explicit implementations.
+ *
+ * C# supports explicit interface implementation (EII), where a class implements
+ * an interface member explicitly. TypeScript doesn't support EII, so tsbindgen
+ * generates special As_IInterface properties that return views of the object.
+ *
+ * Example:
+ * TypeScript: list.As_ICollection.CopyTo(array, 0)
+ * C#:         ((ICollection<T>)list).CopyTo(array, 0)
+ *
+ * @see spec/explicit-interface-views.md for complete documentation
+ */
+
+import type { ExplicitView } from "./metadata.ts";
+
+/**
+ * Pattern for explicit interface view property names.
+ * Format: As_IInterfaceName
+ */
+const VIEW_PROPERTY_PREFIX = "As_";
+const VIEW_PROPERTY_PATTERN = /^As_(.+)$/;
+
+/**
+ * Check if a property name matches the explicit view pattern (As_IInterface).
+ *
+ * @param propertyName - Property name to check
+ * @returns True if matches As_IInterface pattern
+ */
+export const isExplicitViewProperty = (propertyName: string): boolean => {
+  return propertyName.startsWith(VIEW_PROPERTY_PREFIX);
+};
+
+/**
+ * Extract interface name from an explicit view property name.
+ *
+ * @param viewPropertyName - Property name (e.g., "As_ICollection")
+ * @returns Interface name (e.g., "ICollection"), or undefined if not a view property
+ */
+export const extractInterfaceNameFromView = (
+  viewPropertyName: string
+): string | undefined => {
+  const match = viewPropertyName.match(VIEW_PROPERTY_PATTERN);
+  if (!match) {
+    return undefined;
+  }
+  return match[1];
+};
+
+/**
+ * Build explicit view property name from interface name.
+ *
+ * @param interfaceName - Interface name (e.g., "ICollection")
+ * @returns View property name (e.g., "As_ICollection")
+ */
+export const buildViewPropertyName = (interfaceName: string): string => {
+  return `${VIEW_PROPERTY_PREFIX}${interfaceName}`;
+};
+
+/**
+ * Find explicit view for a given interface in type metadata.
+ *
+ * @param explicitViews - Array of explicit views from metadata
+ * @param interfaceName - CLR interface name to find (e.g., "System.Collections.ICollection")
+ * @returns Explicit view if found, undefined otherwise
+ */
+export const findExplicitView = (
+  explicitViews: readonly ExplicitView[] | undefined,
+  interfaceName: string
+): ExplicitView | undefined => {
+  if (!explicitViews) {
+    return undefined;
+  }
+
+  return explicitViews.find((view) => view.interfaceName === interfaceName);
+};
+
+/**
+ * Check if a member is in an explicit view (view-only member).
+ *
+ * @param explicitViews - Array of explicit views from metadata
+ * @param memberName - CLR member name to check
+ * @returns True if member appears in any view
+ */
+export const isMemberInExplicitView = (
+  explicitViews: readonly ExplicitView[] | undefined,
+  memberName: string
+): boolean => {
+  if (!explicitViews) {
+    return false;
+  }
+
+  for (const view of explicitViews) {
+    if (view.members.some((m) => m.clrName === memberName)) {
+      return true;
+    }
+  }
+
+  return false;
+};
+
+/**
+ * Get all interface names that have explicit views.
+ *
+ * @param explicitViews - Array of explicit views from metadata
+ * @returns Array of interface CLR names
+ */
+export const getExplicitViewInterfaces = (
+  explicitViews: readonly ExplicitView[] | undefined
+): readonly string[] => {
+  if (!explicitViews) {
+    return [];
+  }
+
+  return explicitViews.map((view) => view.interfaceName);
+};
+
+/**
+ * Information about an explicit view member access.
+ */
+export type ExplicitViewAccess = {
+  readonly interfaceName: string;
+  readonly interfaceTsName: string;
+  readonly memberName: string;
+  readonly memberKind: "Method" | "Property" | "Event";
+};
+
+/**
+ * Parse an explicit view member access expression.
+ *
+ * Example: obj.As_ICollection.CopyTo
+ * Returns: { interfaceName: "ICollection", memberName: "CopyTo", ... }
+ *
+ * @param viewPropertyName - View property name (e.g., "As_ICollection")
+ * @param memberName - Member being accessed (e.g., "CopyTo")
+ * @param explicitViews - Array of explicit views from metadata
+ * @returns View access info if valid, undefined if invalid
+ */
+export const parseExplicitViewAccess = (
+  viewPropertyName: string,
+  memberName: string,
+  explicitViews: readonly ExplicitView[] | undefined
+): ExplicitViewAccess | undefined => {
+  // Extract interface name from view property
+  const interfaceTsName = extractInterfaceNameFromView(viewPropertyName);
+  if (!interfaceTsName) {
+    return undefined;
+  }
+
+  // Find the explicit view in metadata
+  if (!explicitViews) {
+    return undefined;
+  }
+
+  // Look for view that matches the property name
+  const view = explicitViews.find((v) => v.tsPropertyName === viewPropertyName);
+  if (!view) {
+    return undefined;
+  }
+
+  // Find the member in the view
+  const member = view.members.find((m) => m.name === memberName);
+  if (!member) {
+    return undefined;
+  }
+
+  return {
+    interfaceName: view.interfaceName,
+    interfaceTsName,
+    memberName: member.name,
+    memberKind: member.kind,
+  };
+};
+
+/**
+ * Generate C# interface cast expression for explicit view access.
+ *
+ * @param objectExpression - C# expression for the object
+ * @param interfaceName - CLR interface name (e.g., "System.Collections.ICollection")
+ * @returns C# cast expression (e.g., "((ICollection)obj)")
+ */
+export const generateInterfaceCast = (
+  objectExpression: string,
+  interfaceName: string
+): string => {
+  // Extract short name from fully-qualified name
+  const shortName = interfaceName.split(".").pop() || interfaceName;
+
+  return `((${shortName})${objectExpression})`;
+};
+
+/**
+ * Generate C# interface cast with generics.
+ *
+ * @param objectExpression - C# expression for the object
+ * @param interfaceName - CLR interface name (e.g., "System.Collections.Generic.ICollection`1")
+ * @param genericArguments - Generic type arguments in C# syntax (e.g., ["string"])
+ * @returns C# cast expression (e.g., "((ICollection<string>)obj)")
+ */
+export const generateGenericInterfaceCast = (
+  objectExpression: string,
+  interfaceName: string,
+  genericArguments: readonly string[]
+): string => {
+  // Extract short name from fully-qualified name
+  const shortName = interfaceName.split(".").pop() || interfaceName;
+
+  // Remove generic arity suffix (`1, `2, etc.)
+  const nameWithoutArity = shortName.replace(/`\d+$/, "");
+
+  // Build generic type
+  const genericType =
+    genericArguments.length > 0
+      ? `${nameWithoutArity}<${genericArguments.join(", ")}>`
+      : nameWithoutArity;
+
+  return `((${genericType})${objectExpression})`;
+};