refactor: simplify C# RPC class tracking

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: 2 people

scripts/codegen/csharp.ts

@@ -701,7 +701,6 @@ export async function generateSessionEvents(schemaPath?: string): Promise<void>
 // RPC TYPES
 // ══════════════════════════════════════════════════════════════════════════════
 
-let emittedRpcClasses = new Set<string>();
 let emittedRpcClassSchemas = new Map<string, string>();
 let experimentalRpcTypes = new Set<string>();
 let rpcKnownTypes = new Map<string, string>();
@@ -734,20 +733,6 @@ function stableStringify(value: unknown): string {
     return JSON.stringify(value);
 }
 
-function chooseRpcClassName(preferredName: string, fallbackName: string, schema: JSONSchema7): string {
-    const schemaKey = stableStringify(schema);
-    const existingPreferred = emittedRpcClassSchemas.get(preferredName);
-    if (!existingPreferred || existingPreferred === schemaKey) return preferredName;
-
-    let candidate = fallbackName;
-    let suffix = 2;
-    while (true) {
-        const existing = emittedRpcClassSchemas.get(candidate);
-        if (!existing || existing === schemaKey) return candidate;
-        candidate = `${fallbackName}${suffix++}`;
-    }
-}
-
 function resolveRpcType(schema: JSONSchema7, isRequired: boolean, parentClassName: string, propName: string, classes: string[]): string {
     // Handle anyOf: [T, null] → T? (nullable typed property)
     if (schema.anyOf) {
@@ -770,32 +755,39 @@ function resolveRpcType(schema: JSONSchema7, isRequired: boolean, parentClassNam
     if (schema.type === "array" && schema.items) {
         const items = schema.items as JSONSchema7;
         if (items.type === "object" && items.properties) {
-            const defaultName = (items.title as string) ?? singularPascal(propName);
-            const contextualName = `${parentClassName}${defaultName}`;
-            const itemClass = chooseRpcClassName(defaultName, contextualName, items);
-            if (!emittedRpcClasses.has(itemClass)) classes.push(emitRpcClass(itemClass, items, "public", classes));
-            return isRequired ? `IList<${itemClass}>` : `IList<${itemClass}>?`;
+            const itemClass = (items.title as string) ?? singularPascal(propName);
+            classes.push(emitRpcClass(itemClass, items, "public", classes));
+            return isRequired ? `List<${itemClass}>` : `List<${itemClass}>?`;
         }
         const itemType = schemaTypeToCSharp(items, true, rpcKnownTypes);
-        return isRequired ? `IList<${itemType}>` : `IList<${itemType}>?`;
+        return isRequired ? `List<${itemType}>` : `List<${itemType}>?`;
     }
     if (schema.type === "object" && schema.additionalProperties && typeof schema.additionalProperties === "object") {
         const vs = schema.additionalProperties as JSONSchema7;
         if (vs.type === "object" && vs.properties) {
             const valClass = `${parentClassName}${propName}Value`;
             classes.push(emitRpcClass(valClass, vs, "public", classes));
-            return isRequired ? `IDictionary<string, ${valClass}>` : `IDictionary<string, ${valClass}>?`;
+            return isRequired ? `Dictionary<string, ${valClass}>` : `Dictionary<string, ${valClass}>?`;
         }
         const valueType = schemaTypeToCSharp(vs, true, rpcKnownTypes);
-        return isRequired ? `IDictionary<string, ${valueType}>` : `IDictionary<string, ${valueType}>?`;
+        return isRequired ? `Dictionary<string, ${valueType}>` : `Dictionary<string, ${valueType}>?`;
     }
     return schemaTypeToCSharp(schema, isRequired, rpcKnownTypes);
 }
 
 function emitRpcClass(className: string, schema: JSONSchema7, visibility: "public" | "internal", extraClasses: string[]): string {
-    if (emittedRpcClasses.has(className)) return "";
-    emittedRpcClasses.add(className);
-    emittedRpcClassSchemas.set(className, stableStringify(schema));
+    const schemaKey = stableStringify(schema);
+    const existingSchema = emittedRpcClassSchemas.get(className);
+    if (existingSchema) {
+        if (existingSchema !== schemaKey) {
+            throw new Error(
+                `Conflicting RPC class name "${className}" for different schemas. Add a schema title/withTypeName to disambiguate.`
+            );
+        }
+        return "";
+    }
+
+    emittedRpcClassSchemas.set(className, schemaKey);
 
     const requiredSet = new Set(schema.required || []);
     const lines: string[] = [];
@@ -824,12 +816,9 @@ function emitRpcClass(className: string, schema: JSONSchema7, visibility: "publi
         if (isReq && !csharpType.endsWith("?")) {
             if (csharpType === "string") defaultVal = " = string.Empty;";
             else if (csharpType === "object") defaultVal = " = null!;";
-            else if (csharpType.startsWith("IList<")) {
+            else if (csharpType.startsWith("List<") || csharpType.startsWith("Dictionary<")) {
                 propAccessors = "{ get => field ??= []; set; }";
-            } else if (csharpType.startsWith("IDictionary<")) {
-                const concreteType = csharpType.replace("IDictionary<", "Dictionary<");
-                propAccessors = `{ get => field ??= new ${concreteType}(); set; }`;
-            } else if (emittedRpcClasses.has(csharpType)) {
+            } else if (emittedRpcClassSchemas.has(csharpType)) {
                 propAccessors = "{ get => field ??= new(); set; }";
             }
         }
@@ -1200,7 +1189,6 @@ function emitClientSessionApiRegistration(clientSchema: Record<string, unknown>,
 }
 
 function generateRpcCode(schema: ApiSchema): string {
-    emittedRpcClasses.clear();
     emittedRpcClassSchemas.clear();
     experimentalRpcTypes.clear();
     rpcKnownTypes.clear();
@@ -1246,7 +1234,7 @@ internal static class Diagnostics
     if (clientSessionParts.length > 0) lines.push(...clientSessionParts, "");
 
     // Add JsonSerializerContext for AOT/trimming support
-    const typeNames = [...emittedRpcClasses].sort();
+    const typeNames = [...emittedRpcClassSchemas.keys()].sort();
     if (typeNames.length > 0) {
         lines.push(`[JsonSourceGenerationOptions(`);
         lines.push(`    JsonSerializerDefaults.Web,`);