@tsonic/frontend 0.0.1

package/src/types/nested-types.ts

@@ -0,0 +1,215 @@
+/**
+ * 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

@@ -0,0 +1,173 @@
+/**
+ * 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();
+};

package/src/types/ref-parameters.test.ts

@@ -0,0 +1,192 @@
+/**
+ * Tests for ref/out parameter handling
+ */
+
+import { describe, it } from "mocha";
+import { strict as assert } from "assert";
+import {
+  getParameterModifier,
+  requiresTSByRef,
+  generateCSharpParameter,
+  generateCSharpArgument,
+} from "./ref-parameters.js";
+import type { ParameterMetadata } from "./metadata.js";
+
+describe("Ref Parameters", () => {
+  describe("getParameterModifier", () => {
+    it("should return 'out' for out parameter", () => {
+      const param: ParameterMetadata = {
+        name: "result",
+        type: "System.Int32",
+        isRef: false,
+        isOut: true,
+        isParams: false,
+      };
+
+      const modifier = getParameterModifier(param);
+
+      assert.equal(modifier, "out");
+    });
+
+    it("should return 'ref' for ref parameter", () => {
+      const param: ParameterMetadata = {
+        name: "value",
+        type: "System.Int32",
+        isRef: true,
+        isOut: false,
+        isParams: false,
+      };
+
+      const modifier = getParameterModifier(param);
+
+      assert.equal(modifier, "ref");
+    });
+
+    it("should return 'in' for in parameter", () => {
+      const param: ParameterMetadata = {
+        name: "data",
+        type: "LargeStruct",
+        isRef: false,
+        isOut: false,
+        isIn: true,
+        isParams: false,
+      };
+
+      const modifier = getParameterModifier(param);
+
+      assert.equal(modifier, "in");
+    });
+
+    it("should return 'none' for regular parameter", () => {
+      const param: ParameterMetadata = {
+        name: "input",
+        type: "System.String",
+        isRef: false,
+        isOut: false,
+        isParams: false,
+      };
+
+      const modifier = getParameterModifier(param);
+
+      assert.equal(modifier, "none");
+    });
+
+    it("should prioritize 'out' over 'ref'", () => {
+      // This should not happen in valid metadata, but test defensive behavior
+      const param: ParameterMetadata = {
+        name: "weird",
+        type: "System.Int32",
+        isRef: true,
+        isOut: true,
+        isParams: false,
+      };
+
+      const modifier = getParameterModifier(param);
+
+      assert.equal(modifier, "out");
+    });
+  });
+
+  describe("requiresTSByRef", () => {
+    it("should return true for out parameter", () => {
+      const param: ParameterMetadata = {
+        name: "result",
+        type: "System.Int32",
+        isRef: false,
+        isOut: true,
+        isParams: false,
+      };
+
+      assert.ok(requiresTSByRef(param));
+    });
+
+    it("should return true for ref parameter", () => {
+      const param: ParameterMetadata = {
+        name: "value",
+        type: "System.Int32",
+        isRef: true,
+        isOut: false,
+        isParams: false,
+      };
+
+      assert.ok(requiresTSByRef(param));
+    });
+
+    it("should return true for in parameter", () => {
+      const param: ParameterMetadata = {
+        name: "data",
+        type: "LargeStruct",
+        isRef: false,
+        isOut: false,
+        isIn: true,
+        isParams: false,
+      };
+
+      assert.ok(requiresTSByRef(param));
+    });
+
+    it("should return false for regular parameter", () => {
+      const param: ParameterMetadata = {
+        name: "input",
+        type: "System.String",
+        isRef: false,
+        isOut: false,
+        isParams: false,
+      };
+
+      assert.ok(!requiresTSByRef(param));
+    });
+  });
+
+  describe("generateCSharpParameter", () => {
+    it("should generate out parameter", () => {
+      const param = generateCSharpParameter("out", "int", "result");
+
+      assert.equal(param, "out int result");
+    });
+
+    it("should generate ref parameter", () => {
+      const param = generateCSharpParameter("ref", "string", "value");
+
+      assert.equal(param, "ref string value");
+    });
+
+    it("should generate in parameter", () => {
+      const param = generateCSharpParameter("in", "LargeStruct", "data");
+
+      assert.equal(param, "in LargeStruct data");
+    });
+
+    it("should generate regular parameter without keyword", () => {
+      const param = generateCSharpParameter("none", "string", "input");
+
+      assert.equal(param, "string input");
+    });
+  });
+
+  describe("generateCSharpArgument", () => {
+    it("should generate out argument", () => {
+      const arg = generateCSharpArgument("out", "result");
+
+      assert.equal(arg, "out result");
+    });
+
+    it("should generate ref argument", () => {
+      const arg = generateCSharpArgument("ref", "value");
+
+      assert.equal(arg, "ref value");
+    });
+
+    it("should generate in argument", () => {
+      const arg = generateCSharpArgument("in", "data");
+
+      assert.equal(arg, "in data");
+    });
+
+    it("should generate regular argument without keyword", () => {
+      const arg = generateCSharpArgument("none", "input");
+
+      assert.equal(arg, "input");
+    });
+  });
+});