@tsonic/frontend 0.0.1 → 0.0.2

package/src/types/nested-types.test.ts

@@ -1,194 +0,0 @@
-/**
- * Tests for nested types handling
- */
-
-import { describe, it } from "mocha";
-import { strict as assert } from "assert";
-import {
-  parseNestedTypeName,
-  isNestedType,
-  tsCSharpNestedTypeName,
-  clrToTsNestedTypeName,
-  tsToCLRNestedTypeName,
-  getNestedTypeLevels,
-  getOutermostType,
-  getInnermostType,
-  isNestedInside,
-  getParentType,
-} from "./nested-types.js";
-
-describe("Nested Types", () => {
-  describe("isNestedType", () => {
-    it("should detect nested type with $ separator", () => {
-      assert.ok(isNestedType("List_1$Enumerator"));
-    });
-
-    it("should return false for non-nested type", () => {
-      assert.ok(!isNestedType("List_1"));
-    });
-  });
-
-  describe("parseNestedTypeName", () => {
-    it("should parse simple nested type", () => {
-      const info = parseNestedTypeName("List_1$Enumerator");
-
-      assert.ok(info);
-      assert.equal(info?.outerType, "List_1");
-      assert.equal(info?.nestedType, "Enumerator");
-      assert.equal(info?.depth, 1);
-      assert.deepEqual(info?.fullPath, ["List_1", "Enumerator"]);
-    });
-
-    it("should parse multiple nesting levels", () => {
-      const info = parseNestedTypeName("A$B$C");
-
-      assert.ok(info);
-      assert.equal(info?.outerType, "A");
-      assert.equal(info?.nestedType, "C");
-      assert.equal(info?.depth, 2);
-      assert.deepEqual(info?.fullPath, ["A", "B", "C"]);
-    });
-
-    it("should return undefined for non-nested type", () => {
-      const info = parseNestedTypeName("SimpleType");
-
-      assert.equal(info, undefined);
-    });
-  });
-
-  describe("tsCSharpNestedTypeName", () => {
-    it("should convert $ to . separator", () => {
-      const result = tsCSharpNestedTypeName("List_1$Enumerator");
-
-      assert.equal(result, "List_1.Enumerator");
-    });
-
-    it("should handle multiple levels", () => {
-      const result = tsCSharpNestedTypeName("A$B$C");
-
-      assert.equal(result, "A.B.C");
-    });
-
-    it("should leave non-nested types unchanged", () => {
-      const result = tsCSharpNestedTypeName("SimpleType");
-
-      assert.equal(result, "SimpleType");
-    });
-  });
-
-  describe("clrToTsNestedTypeName", () => {
-    it("should convert CLR name to TypeScript", () => {
-      const result = clrToTsNestedTypeName("List`1+Enumerator");
-
-      assert.equal(result, "List_1$Enumerator");
-    });
-
-    it("should handle multiple levels", () => {
-      const result = clrToTsNestedTypeName("A+B+C");
-
-      assert.equal(result, "A$B$C");
-    });
-
-    it("should handle generic nested types", () => {
-      const result = clrToTsNestedTypeName("Dictionary`2+KeyCollection`1");
-
-      assert.equal(result, "Dictionary_2$KeyCollection_1");
-    });
-  });
-
-  describe("tsToCLRNestedTypeName", () => {
-    it("should convert TypeScript name to CLR", () => {
-      const result = tsToCLRNestedTypeName("List_1$Enumerator");
-
-      assert.equal(result, "List`1+Enumerator");
-    });
-
-    it("should handle multiple levels", () => {
-      const result = tsToCLRNestedTypeName("A$B$C");
-
-      assert.equal(result, "A+B+C");
-    });
-  });
-
-  describe("getNestedTypeLevels", () => {
-    it("should return all nesting levels", () => {
-      const levels = getNestedTypeLevels("A$B$C");
-
-      assert.deepEqual(levels, ["A", "A$B", "A$B$C"]);
-    });
-
-    it("should return single level for non-nested type", () => {
-      const levels = getNestedTypeLevels("SimpleType");
-
-      assert.deepEqual(levels, ["SimpleType"]);
-    });
-  });
-
-  describe("getOutermostType", () => {
-    it("should return outermost type", () => {
-      const outermost = getOutermostType("List_1$Enumerator");
-
-      assert.equal(outermost, "List_1");
-    });
-
-    it("should return same type for non-nested", () => {
-      const outermost = getOutermostType("SimpleType");
-
-      assert.equal(outermost, "SimpleType");
-    });
-  });
-
-  describe("getInnermostType", () => {
-    it("should return innermost type", () => {
-      const innermost = getInnermostType("A$B$C");
-
-      assert.equal(innermost, "C");
-    });
-
-    it("should return same type for non-nested", () => {
-      const innermost = getInnermostType("SimpleType");
-
-      assert.equal(innermost, "SimpleType");
-    });
-  });
-
-  describe("isNestedInside", () => {
-    it("should detect type nested inside another", () => {
-      const result = isNestedInside("List_1$Enumerator", "List_1");
-
-      assert.ok(result);
-    });
-
-    it("should return false for unrelated types", () => {
-      const result = isNestedInside("Dictionary_2$KeyCollection", "List_1");
-
-      assert.ok(!result);
-    });
-
-    it("should return false for non-nested type", () => {
-      const result = isNestedInside("SimpleType", "List_1");
-
-      assert.ok(!result);
-    });
-  });
-
-  describe("getParentType", () => {
-    it("should return parent type", () => {
-      const parent = getParentType("A$B$C");
-
-      assert.equal(parent, "A$B");
-    });
-
-    it("should return parent for single nesting", () => {
-      const parent = getParentType("List_1$Enumerator");
-
-      assert.equal(parent, "List_1");
-    });
-
-    it("should return undefined for non-nested type", () => {
-      const parent = getParentType("SimpleType");
-
-      assert.equal(parent, undefined);
-    });
-  });
-});

package/src/types/nested-types.ts

@@ -1,215 +0,0 @@
-/**
- * Nested Types Handling - Parse and transform nested type names.
- *
- * C# supports nested types (types inside types). TypeScript doesn't have true nested
- * type syntax, so tsbindgen flattens them using a dollar sign separator:
- *
- * CLR:        Outer+Nested (reflection uses +)
- * TypeScript: Outer$Nested ($ separator)
- * C#:         Outer.Nested (dot in source code)
- *
- * @see spec/nested-types.md for complete documentation
- */
-
-/**
- * Information about a nested type name.
- */
-export type NestedTypeInfo = {
-  readonly isNested: boolean;
-  readonly outerType: string;
-  readonly nestedType: string;
-  readonly fullPath: readonly string[];
-  readonly depth: number;
-};
-
-/**
- * Parse a TypeScript type name to check if it represents a nested type.
- *
- * @param tsEmitName - TypeScript emit name (e.g., "List_1$Enumerator")
- * @returns Nested type info if nested, undefined if not nested
- */
-export const parseNestedTypeName = (
-  tsEmitName: string
-): NestedTypeInfo | undefined => {
-  // Check if name contains $ separator
-  if (!tsEmitName.includes("$")) {
-    return undefined;
-  }
-
-  // Split on $ to get nesting path
-  const parts = tsEmitName.split("$");
-  if (parts.length < 2) {
-    return undefined;
-  }
-
-  const outerType = parts[0];
-  const nestedType = parts[parts.length - 1];
-
-  if (!outerType || !nestedType) {
-    return undefined;
-  }
-
-  return {
-    isNested: true,
-    outerType,
-    nestedType,
-    fullPath: parts,
-    depth: parts.length - 1,
-  };
-};
-
-/**
- * Check if a TypeScript emit name represents a nested type.
- *
- * @param tsEmitName - TypeScript emit name
- * @returns True if nested type
- */
-export const isNestedType = (tsEmitName: string): boolean => {
-  return tsEmitName.includes("$");
-};
-
-/**
- * Convert TypeScript nested type name to C# nested type name.
- *
- * TypeScript: List_1$Enumerator
- * C#:         List<T>.Enumerator
- *
- * Note: This only converts the separator ($  → .). Generic arity substitution
- * (_1 → <T>) is handled separately by generic type processing.
- *
- * @param tsEmitName - TypeScript emit name with $ separator
- * @returns C# name with dot separator (generic arity not substituted)
- */
-export const tsCSharpNestedTypeName = (tsEmitName: string): string => {
-  return tsEmitName.replace(/\$/g, ".");
-};
-
-/**
- * Convert CLR reflection name to TypeScript emit name.
- *
- * CLR uses + for nested types (reflection metadata).
- * TypeScript uses $.
- *
- * CLR:        List`1+Enumerator
- * TypeScript: List_1$Enumerator
- *
- * @param clrName - CLR reflection name with + separator and ` for generics
- * @returns TypeScript emit name with $ separator and _ for generics
- */
-export const clrToTsNestedTypeName = (clrName: string): string => {
-  // First replace backticks with underscores for generic arity
-  let tsName = clrName.replace(/`/g, "_");
-
-  // Then replace plus signs with dollar signs for nesting
-  tsName = tsName.replace(/\+/g, "$");
-
-  return tsName;
-};
-
-/**
- * Convert TypeScript emit name to CLR reflection name.
- *
- * Reverse of clrToTsNestedTypeName.
- *
- * TypeScript: List_1$Enumerator
- * CLR:        List`1+Enumerator
- *
- * @param tsEmitName - TypeScript emit name
- * @returns CLR reflection name
- */
-export const tsToCLRNestedTypeName = (tsEmitName: string): string => {
-  // Replace dollar signs with plus signs for nesting
-  let clrName = tsEmitName.replace(/\$/g, "+");
-
-  // Replace underscores with backticks for generic arity
-  // Note: This is a simple replacement. In practice, we need to be careful
-  // not to replace underscores that are part of the actual type name.
-  // For now, we assume _N pattern at end of each segment indicates arity.
-  clrName = clrName.replace(/_(\d+)/g, "`$1");
-
-  return clrName;
-};
-
-/**
- * Get all nesting levels from a nested type name.
- *
- * @param tsEmitName - TypeScript emit name (e.g., "A$B$C")
- * @returns Array of type names at each level ["A", "A$B", "A$B$C"]
- */
-export const getNestedTypeLevels = (tsEmitName: string): readonly string[] => {
-  if (!isNestedType(tsEmitName)) {
-    return [tsEmitName];
-  }
-
-  const parts = tsEmitName.split("$");
-  const levels: string[] = [];
-
-  for (let i = 0; i < parts.length; i++) {
-    levels.push(parts.slice(0, i + 1).join("$"));
-  }
-
-  return levels;
-};
-
-/**
- * Get the outermost type name from a nested type.
- *
- * @param tsEmitName - TypeScript emit name (e.g., "List_1$Enumerator")
- * @returns Outermost type name (e.g., "List_1")
- */
-export const getOutermostType = (tsEmitName: string): string => {
-  const dollarIndex = tsEmitName.indexOf("$");
-  if (dollarIndex === -1) {
-    return tsEmitName;
-  }
-  return tsEmitName.substring(0, dollarIndex);
-};
-
-/**
- * Get the innermost type name from a nested type.
- *
- * @param tsEmitName - TypeScript emit name (e.g., "A$B$C")
- * @returns Innermost type name (e.g., "C")
- */
-export const getInnermostType = (tsEmitName: string): string => {
-  const parts = tsEmitName.split("$");
-  const innermost = parts[parts.length - 1];
-  return innermost || tsEmitName;
-};
-
-/**
- * Check if one type is nested inside another.
- *
- * @param innerType - Potentially nested type (e.g., "List_1$Enumerator")
- * @param outerType - Potentially containing type (e.g., "List_1")
- * @returns True if innerType is nested inside outerType
- */
-export const isNestedInside = (
-  innerType: string,
-  outerType: string
-): boolean => {
-  if (!isNestedType(innerType)) {
-    return false;
-  }
-
-  return innerType.startsWith(outerType + "$");
-};
-
-/**
- * Get parent type name from a nested type.
- *
- * @param tsEmitName - TypeScript emit name (e.g., "A$B$C")
- * @returns Parent type name (e.g., "A$B"), or undefined if not nested
- */
-export const getParentType = (tsEmitName: string): string | undefined => {
-  const info = parseNestedTypeName(tsEmitName);
-  if (!info) {
-    return undefined;
-  }
-
-  if (info.fullPath.length < 2) {
-    return undefined;
-  }
-
-  return info.fullPath.slice(0, -1).join("$");
-};

package/src/types/parameter-modifiers.ts

@@ -1,173 +0,0 @@
-/**
- * Parameter Modifier Tracking - Track ref/out/in types from @tsonic/types
- *
- * This module tracks which ref, out, and In types are legitimately imported
- * from @tsonic/types to ensure we only apply parameter modifiers to the
- * correct types (not user-defined types with the same names).
- */
-
-import * as ts from "typescript";
-
-/**
- * Registry for tracking trusted parameter modifier types
- */
-export class ParameterModifierRegistry {
-  private static instance: ParameterModifierRegistry | null = null;
-
-  // Track which symbols are imported from @tsonic/types
-  private trustedSymbols = new Set<string>();
-
-  // Track aliases (e.g., import { ref as myRef })
-  private aliasMap = new Map<string, string>();
-
-  private constructor() {}
-
-  /**
-   * Get singleton instance
-   */
-  static getInstance(): ParameterModifierRegistry {
-    if (!ParameterModifierRegistry.instance) {
-      ParameterModifierRegistry.instance = new ParameterModifierRegistry();
-    }
-    return ParameterModifierRegistry.instance;
-  }
-
-  /**
-   * Reset the registry (useful for testing)
-   */
-  static reset(): void {
-    if (ParameterModifierRegistry.instance) {
-      ParameterModifierRegistry.instance.trustedSymbols.clear();
-      ParameterModifierRegistry.instance.aliasMap.clear();
-    }
-  }
-
-  /**
-   * Process an import declaration to track ref/out/In from @tsonic/types
-   */
-  processImport(importDecl: ts.ImportDeclaration): void {
-    // Check if this is an import from @tsonic/types
-    if (!ts.isStringLiteral(importDecl.moduleSpecifier)) {
-      return;
-    }
-
-    const moduleSpecifier = importDecl.moduleSpecifier.text;
-    if (moduleSpecifier !== "@tsonic/types") {
-      return;
-    }
-
-    // Extract named imports
-    if (importDecl.importClause?.namedBindings) {
-      if (ts.isNamedImports(importDecl.importClause.namedBindings)) {
-        for (const spec of importDecl.importClause.namedBindings.elements) {
-          const importedName = (spec.propertyName ?? spec.name).text;
-          const localName = spec.name.text;
-
-          // Check if this is ref, out, or In
-          if (
-            importedName === "ref" ||
-            importedName === "out" ||
-            importedName === "In"
-          ) {
-            this.trustedSymbols.add(localName);
-
-            // Track alias if different from imported name
-            if (importedName !== localName) {
-              this.aliasMap.set(localName, importedName);
-            }
-          }
-        }
-      }
-    }
-  }
-
-  /**
-   * Check if a type name is a trusted parameter modifier type
-   */
-  isTrustedParameterModifier(typeName: string): boolean {
-    return this.trustedSymbols.has(typeName);
-  }
-
-  /**
-   * Get the parameter modifier kind for a trusted type
-   * @returns 'ref', 'out', 'in', or null if not a parameter modifier
-   */
-  getParameterModifierKind(typeName: string): "ref" | "out" | "in" | null {
-    if (!this.isTrustedParameterModifier(typeName)) {
-      return null;
-    }
-
-    // Check if it's an alias
-    const originalName = this.aliasMap.get(typeName) ?? typeName;
-
-    switch (originalName) {
-      case "ref":
-        return "ref";
-      case "out":
-        return "out";
-      case "In":
-        return "in";
-      default:
-        return null;
-    }
-  }
-
-  /**
-   * Check if a TypeScript type is a parameter modifier type from @tsonic/types
-   * This checks both the type name and verifies it was imported from @tsonic/types
-   */
-  isParameterModifierType(type: ts.Type, _checker: ts.TypeChecker): boolean {
-    // Get the symbol name
-    const symbol = type.aliasSymbol || type.symbol;
-    if (!symbol) {
-      return false;
-    }
-
-    const typeName = symbol.getName();
-    return this.isTrustedParameterModifier(typeName);
-  }
-
-  /**
-   * Get parameter modifier info from a type
-   */
-  getParameterModifierInfo(
-    type: ts.Type,
-    _checker: ts.TypeChecker
-  ): { kind: "ref" | "out" | "in"; wrappedType: ts.Type } | null {
-    const symbol = type.aliasSymbol || type.symbol;
-    if (!symbol) {
-      return null;
-    }
-
-    const typeName = symbol.getName();
-    const kind = this.getParameterModifierKind(typeName);
-    if (!kind) {
-      return null;
-    }
-
-    // Extract the wrapped type (T in ref<T>, out<T>, or In<T>)
-    let wrappedType: ts.Type | undefined;
-
-    if (type.aliasTypeArguments && type.aliasTypeArguments.length > 0) {
-      wrappedType = type.aliasTypeArguments[0];
-    } else if (
-      (type as any).typeArguments &&
-      (type as any).typeArguments.length > 0
-    ) {
-      wrappedType = (type as any).typeArguments[0];
-    }
-
-    if (!wrappedType) {
-      return null;
-    }
-
-    return { kind, wrappedType };
-  }
-}
-
-/**
- * Get the global parameter modifier registry instance
- */
-export const getParameterModifierRegistry = (): ParameterModifierRegistry => {
-  return ParameterModifierRegistry.getInstance();
-};