@alloy-js/csharp 0.23.0-dev.7 → 0.23.0

package/src/name-policy.test.ts

@@ -0,0 +1,210 @@
+import { describe, expect, it } from "vitest";
+import {
+  isValidCSharpIdentifier,
+  sanitizeCSharpIdentifier,
+} from "./identifier-utils.js";
+import {
+  csharpContextualKeywords,
+  csharpKeywords,
+  isCSharpContextualKeyword,
+  isCSharpKeyword,
+} from "./keywords.js";
+import { createCSharpNamePolicy } from "./name-policy.js";
+
+describe("isCSharpKeyword", () => {
+  it("recognizes reserved keywords", () => {
+    expect(isCSharpKeyword("class")).toBe(true);
+    expect(isCSharpKeyword("interface")).toBe(true);
+    expect(isCSharpKeyword("string")).toBe(true);
+    expect(isCSharpKeyword("int")).toBe(true);
+    expect(isCSharpKeyword("void")).toBe(true);
+    expect(isCSharpKeyword("return")).toBe(true);
+  });
+
+  it("does not match contextual keywords", () => {
+    expect(isCSharpKeyword("async")).toBe(false);
+    expect(isCSharpKeyword("value")).toBe(false);
+    expect(isCSharpKeyword("var")).toBe(false);
+    expect(isCSharpKeyword("record")).toBe(false);
+  });
+
+  it("is case-sensitive — PascalCase versions are not keywords", () => {
+    expect(isCSharpKeyword("Class")).toBe(false);
+    expect(isCSharpKeyword("String")).toBe(false);
+    expect(isCSharpKeyword("Int")).toBe(false);
+    expect(isCSharpKeyword("Void")).toBe(false);
+  });
+
+  it("rejects non-keywords", () => {
+    expect(isCSharpKeyword("MyClass")).toBe(false);
+    expect(isCSharpKeyword("foo")).toBe(false);
+  });
+
+  it("keyword sets are non-empty", () => {
+    expect(csharpKeywords.size).toBeGreaterThan(70);
+    expect(csharpContextualKeywords.size).toBeGreaterThan(30);
+  });
+});
+
+describe("isCSharpContextualKeyword", () => {
+  it("recognizes contextual keywords", () => {
+    expect(isCSharpContextualKeyword("async")).toBe(true);
+    expect(isCSharpContextualKeyword("await")).toBe(true);
+    expect(isCSharpContextualKeyword("value")).toBe(true);
+    expect(isCSharpContextualKeyword("var")).toBe(true);
+    expect(isCSharpContextualKeyword("record")).toBe(true);
+    expect(isCSharpContextualKeyword("required")).toBe(true);
+  });
+
+  it("does not match reserved keywords", () => {
+    expect(isCSharpContextualKeyword("class")).toBe(false);
+    expect(isCSharpContextualKeyword("int")).toBe(false);
+  });
+});
+
+describe("isValidCSharpIdentifier", () => {
+  it("accepts valid identifiers", () => {
+    expect(isValidCSharpIdentifier("MyClass")).toBe(true);
+    expect(isValidCSharpIdentifier("_private")).toBe(true);
+    expect(isValidCSharpIdentifier("name123")).toBe(true);
+    expect(isValidCSharpIdentifier("a")).toBe(true);
+    expect(isValidCSharpIdentifier("_")).toBe(true);
+  });
+
+  it("rejects invalid identifiers", () => {
+    expect(isValidCSharpIdentifier("123start")).toBe(false);
+    expect(isValidCSharpIdentifier("has-dash")).toBe(false);
+    expect(isValidCSharpIdentifier("has space")).toBe(false);
+    expect(isValidCSharpIdentifier("")).toBe(false);
+    expect(isValidCSharpIdentifier("foo.bar")).toBe(false);
+  });
+
+  it("does not check for keywords (only character rules)", () => {
+    // "class" has valid characters, even though it's a keyword
+    expect(isValidCSharpIdentifier("class")).toBe(true);
+  });
+});
+
+describe("sanitizeCSharpIdentifier", () => {
+  it("passes through valid identifiers unchanged", () => {
+    expect(sanitizeCSharpIdentifier("ValidName")).toBe("ValidName");
+    expect(sanitizeCSharpIdentifier("_private")).toBe("_private");
+    expect(sanitizeCSharpIdentifier("name123")).toBe("name123");
+  });
+
+  it("prefixes underscore when first char is a digit", () => {
+    expect(sanitizeCSharpIdentifier("1foo")).toBe("_1foo");
+  });
+
+  it("replaces non-word characters with underscore", () => {
+    expect(sanitizeCSharpIdentifier("foo-bar")).toBe("foo_bar");
+    expect(sanitizeCSharpIdentifier("has space")).toBe("has_space");
+    expect(sanitizeCSharpIdentifier("a.b.c")).toBe("a_b_c");
+  });
+
+  it("handles leading special characters", () => {
+    expect(sanitizeCSharpIdentifier("$foo")).toBe("_foo");
+    expect(sanitizeCSharpIdentifier("-bar")).toBe("_bar");
+  });
+
+  it("handles empty string", () => {
+    expect(sanitizeCSharpIdentifier("")).toBe("_");
+  });
+});
+
+describe("createCSharpNamePolicy keyword escaping", () => {
+  const policy = createCSharpNamePolicy();
+
+  describe("PascalCase elements avoid most keyword conflicts naturally", () => {
+    it("class element: 'string' becomes 'String' (not a keyword, no escape)", () => {
+      expect(policy.getName("string", "class")).toBe("String");
+    });
+
+    it("class element: 'class' becomes 'Class' (not a keyword, no escape)", () => {
+      expect(policy.getName("class", "class")).toBe("Class");
+    });
+
+    it("class-property element: 'value' becomes 'Value' (not a keyword, no escape)", () => {
+      expect(policy.getName("value", "class-property")).toBe("Value");
+    });
+  });
+
+  describe("camelCase elements may hit keywords and get @-escaped", () => {
+    it("parameter: 'string' stays 'string' → gets @-escaped", () => {
+      expect(policy.getName("string", "parameter")).toBe("@string");
+    });
+
+    it("variable: 'int' stays 'int' → gets @-escaped", () => {
+      expect(policy.getName("int", "variable")).toBe("@int");
+    });
+
+    it("parameter: 'return' stays 'return' → gets @-escaped", () => {
+      expect(policy.getName("return", "parameter")).toBe("@return");
+    });
+
+    it("variable: 'value' stays 'value' — contextual keyword, not escaped", () => {
+      expect(policy.getName("value", "variable")).toBe("value");
+    });
+
+    it("parameter: 'async' stays 'async' — contextual keyword, not escaped", () => {
+      expect(policy.getName("async", "parameter")).toBe("async");
+    });
+  });
+
+  describe("non-keyword names pass through normally", () => {
+    it("parameter: 'myParam' stays 'myParam'", () => {
+      expect(policy.getName("myParam", "parameter")).toBe("myParam");
+    });
+
+    it("class: 'my-model' becomes 'MyModel'", () => {
+      expect(policy.getName("my-model", "class")).toBe("MyModel");
+    });
+
+    it("parameter: 'some-param' becomes 'someParam'", () => {
+      expect(policy.getName("some-param", "parameter")).toBe("someParam");
+    });
+  });
+
+  describe("namespace handling", () => {
+    it("applies PascalCase", () => {
+      expect(policy.getName("my-service", "namespace")).toBe("MyService");
+    });
+
+    it("single segment works", () => {
+      expect(policy.getName("system", "namespace")).toBe("System");
+    });
+
+    it("escapes keyword segments", () => {
+      // "namespace" as a namespace segment → PascalCase → "Namespace" → not a keyword
+      expect(policy.getName("namespace", "namespace")).toBe("Namespace");
+    });
+  });
+
+  describe("constant and private member escaping", () => {
+    it("constant: 'class' becomes 'CLASS' (not a keyword)", () => {
+      expect(policy.getName("class", "constant")).toBe("CLASS");
+    });
+
+    it("class-member-private: 'value' becomes '_value' (not a keyword)", () => {
+      expect(policy.getName("value", "class-member-private")).toBe("_value");
+    });
+  });
+
+  describe("identifier sanitization", () => {
+    it("sanitizes names starting with digits", () => {
+      expect(policy.getName("123foo", "class")).toBe("_123foo");
+    });
+
+    it("sanitizes names starting with digits for camelCase elements", () => {
+      expect(policy.getName("123param", "parameter")).toBe("_123param");
+    });
+
+    it("sanitizes empty string", () => {
+      expect(policy.getName("", "class")).toBe("_");
+    });
+
+    it("sanitizes namespace starting with digits", () => {
+      expect(policy.getName("123service", "namespace")).toBe("_123service");
+    });
+  });
+});

package/src/name-policy.ts

@@ -1,5 +1,7 @@
 import * as core from "@alloy-js/core";
 import * as changecase from "change-case";
+import { sanitizeCSharpIdentifier } from "./identifier-utils.js";
+import { isCSharpKeyword } from "./keywords.js";
 
 // the context in which the name policy should be applied
 export type CSharpElements =
@@ -20,10 +22,27 @@ export type CSharpElements =
   | "type-parameter"
   | "namespace";
 
-// creates the C# naming policy
+/**
+ * Prefixes the name with `@` if it is a C# keyword.
+ * This is the idiomatic C# way to use reserved words as identifiers.
+ * The check is case-sensitive, matching C# language semantics.
+ */
+function escapeIfKeyword(name: string): string {
+  return isCSharpKeyword(name) ? `@${name}` : name;
+}
+
+/**
+ * Creates the C# naming policy with case conversion and keyword escaping.
+ *
+ * After applying the appropriate case conversion for each element kind,
+ * the resulting name is checked against C# reserved and contextual keywords.
+ * If it matches (case-sensitively), the name is prefixed with `@`.
+ */
 export function createCSharpNamePolicy(): core.NamePolicy<CSharpElements> {
   return core.createNamePolicy((name, element) => {
+    let result: string;
     switch (element) {
+      case "namespace":
       case "class":
       case "struct":
       case "enum":
@@ -34,15 +53,20 @@ export function createCSharpNamePolicy(): core.NamePolicy<CSharpElements> {
       case "class-method":
       case "type-parameter":
       case "class-property":
-      case "namespace":
-        return changecase.pascalCase(name);
+        result = changecase.pascalCase(name);
+        break;
       case "constant":
-        return changecase.constantCase(name);
+        result = changecase.constantCase(name);
+        break;
       case "class-member-private":
-        return `_${changecase.camelCase(name)}`;
+        result = `_${changecase.camelCase(name)}`;
+        break;
       default:
-        return changecase.camelCase(name);
+        result = changecase.camelCase(name);
+        break;
     }
+
+    return escapeIfKeyword(sanitizeCSharpIdentifier(result));
   });
 }
 

package/temp/api.json

@@ -2305,6 +2305,38 @@
           "name": "ConstructorProps",
           "preserveMemberOrder": false,
           "members": [
+            {
+              "kind": "PropertySignature",
+              "canonicalReference": "@alloy-js/csharp!ConstructorProps#baseConstructor:member",
+              "docComment": "/**\n * Arguments to pass to the base class constructor.\n * Renders `: base(args)` between parameter list and body.\n *\n * @example\n * ```tsx\n * <Constructor public baseConstructor={[\"name\", \"42\"]}>\n * ```\n *\n * This will produce:\n * ```csharp\n * public MyClass(...) : base(name, 42)\n * {\n * }\n * ```\n *\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "baseConstructor?: "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "Children",
+                  "canonicalReference": "@alloy-js/core!Children:type"
+                },
+                {
+                  "kind": "Content",
+                  "text": "[]"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isReadonly": false,
+              "isOptional": true,
+              "releaseTag": "Public",
+              "name": "baseConstructor",
+              "propertyTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 3
+              }
+            },
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/csharp!ConstructorProps#children:member",
@@ -2420,6 +2452,38 @@
                 "startIndex": 1,
                 "endIndex": 2
               }
+            },
+            {
+              "kind": "PropertySignature",
+              "canonicalReference": "@alloy-js/csharp!ConstructorProps#thisConstructor:member",
+              "docComment": "/**\n * Arguments to pass to another constructor in the same class.\n * Renders `: this(args)` between parameter list and body.\n *\n * @example\n * ```tsx\n * <Constructor public thisConstructor={[\"0\", \"0\"]}>\n * ```\n *\n * This will produce:\n * ```csharp\n * public MyClass() : this(0, 0)\n * {\n * }\n * ```\n *\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "thisConstructor?: "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "Children",
+                  "canonicalReference": "@alloy-js/core!Children:type"
+                },
+                {
+                  "kind": "Content",
+                  "text": "[]"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isReadonly": false,
+              "isOptional": true,
+              "releaseTag": "Public",
+              "name": "thisConstructor",
+              "propertyTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 3
+              }
             }
           ],
           "extendsTokenRanges": [
@@ -2496,7 +2560,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/csharp!createCSharpNamePolicy:function(1)",
-          "docComment": "",
+          "docComment": "/**\n * Creates the C# naming policy with case conversion and keyword escaping.\n *\n * After applying the appropriate case conversion for each element kind,\n * the resulting name is checked against C# reserved and contextual keywords.\n * If it matches (case-sensitively), the name is prefixed with `@`.\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -3560,6 +3624,34 @@
           },
           "implementsTokenRanges": []
         },
+        {
+          "kind": "Variable",
+          "canonicalReference": "@alloy-js/csharp!csharpContextualKeywords:var",
+          "docComment": "/**\n * C# contextual keywords that are reserved in certain contexts.\n * While not always reserved, treating them as keywords in generated code\n * avoids subtle context-dependent issues.\n *\n * @see\n *\n *  https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/#contextual-keywords\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "csharpContextualKeywords: "
+            },
+            {
+              "kind": "Reference",
+              "text": "ReadonlySet",
+              "canonicalReference": "!ReadonlySet:interface"
+            },
+            {
+              "kind": "Content",
+              "text": "<string>"
+            }
+          ],
+          "fileUrlPath": "src/keywords.ts",
+          "isReadonly": true,
+          "releaseTag": "Public",
+          "name": "csharpContextualKeywords",
+          "variableTypeTokenRange": {
+            "startIndex": 1,
+            "endIndex": 3
+          }
+        },
         {
           "kind": "TypeAlias",
           "canonicalReference": "@alloy-js/csharp!CSharpElements:type",
@@ -3667,6 +3759,34 @@
             "endIndex": 8
           }
         },
+        {
+          "kind": "Variable",
+          "canonicalReference": "@alloy-js/csharp!csharpKeywords:var",
+          "docComment": "/**\n * C# reserved keywords that cannot be used as identifiers without `@` prefix.\n * These are case-sensitive in C#.\n *\n * @see\n *\n *  https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "csharpKeywords: "
+            },
+            {
+              "kind": "Reference",
+              "text": "ReadonlySet",
+              "canonicalReference": "!ReadonlySet:interface"
+            },
+            {
+              "kind": "Content",
+              "text": "<string>"
+            }
+          ],
+          "fileUrlPath": "src/keywords.ts",
+          "isReadonly": true,
+          "releaseTag": "Public",
+          "name": "csharpKeywords",
+          "variableTypeTokenRange": {
+            "startIndex": 1,
+            "endIndex": 3
+          }
+        },
         {
           "kind": "Class",
           "canonicalReference": "@alloy-js/csharp!CSharpLexicalScope:class",
@@ -10492,6 +10612,141 @@
           ],
           "extendsTokenRanges": []
         },
+        {
+          "kind": "Function",
+          "canonicalReference": "@alloy-js/csharp!isCSharpContextualKeyword:function(1)",
+          "docComment": "/**\n * Returns true if the given name is a C# contextual keyword.\n * Contextual keywords are only reserved in specific language contexts\n * and are generally valid as identifiers.\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export declare function isCSharpContextualKeyword(name: "
+            },
+            {
+              "kind": "Content",
+              "text": "string"
+            },
+            {
+              "kind": "Content",
+              "text": "): "
+            },
+            {
+              "kind": "Content",
+              "text": "boolean"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "src/keywords.ts",
+          "returnTypeTokenRange": {
+            "startIndex": 3,
+            "endIndex": 4
+          },
+          "releaseTag": "Public",
+          "overloadIndex": 1,
+          "parameters": [
+            {
+              "parameterName": "name",
+              "parameterTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              },
+              "isOptional": false
+            }
+          ],
+          "name": "isCSharpContextualKeyword"
+        },
+        {
+          "kind": "Function",
+          "canonicalReference": "@alloy-js/csharp!isCSharpKeyword:function(1)",
+          "docComment": "/**\n * Returns true if the given name is a C# reserved keyword.\n * The check is case-sensitive, matching C# language semantics.\n *\n * Note: this only checks reserved keywords, not contextual keywords.\n * Contextual keywords are only reserved in specific language contexts\n * and are valid identifiers elsewhere (e.g., `value` is valid as a parameter name).\n * Use {@link isCSharpContextualKeyword} to check contextual keywords separately.\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export declare function isCSharpKeyword(name: "
+            },
+            {
+              "kind": "Content",
+              "text": "string"
+            },
+            {
+              "kind": "Content",
+              "text": "): "
+            },
+            {
+              "kind": "Content",
+              "text": "boolean"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "src/keywords.ts",
+          "returnTypeTokenRange": {
+            "startIndex": 3,
+            "endIndex": 4
+          },
+          "releaseTag": "Public",
+          "overloadIndex": 1,
+          "parameters": [
+            {
+              "parameterName": "name",
+              "parameterTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              },
+              "isOptional": false
+            }
+          ],
+          "name": "isCSharpKeyword"
+        },
+        {
+          "kind": "Function",
+          "canonicalReference": "@alloy-js/csharp!isValidCSharpIdentifier:function(1)",
+          "docComment": "/**\n * Checks whether the provided name is a valid C# identifier (without `@` prefix).\n * Does not account for keyword conflicts — use {@link isCSharpKeyword} for that.\n *\n * @param name - The name to validate.\n *\n * @returns  true if the name matches C# identifier rules (letter or underscore start, word chars after).\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export declare function isValidCSharpIdentifier(name: "
+            },
+            {
+              "kind": "Content",
+              "text": "string"
+            },
+            {
+              "kind": "Content",
+              "text": "): "
+            },
+            {
+              "kind": "Content",
+              "text": "boolean"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "src/identifier-utils.ts",
+          "returnTypeTokenRange": {
+            "startIndex": 3,
+            "endIndex": 4
+          },
+          "releaseTag": "Public",
+          "overloadIndex": 1,
+          "parameters": [
+            {
+              "parameterName": "name",
+              "parameterTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              },
+              "isOptional": false
+            }
+          ],
+          "name": "isValidCSharpIdentifier"
+        },
         {
           "kind": "Interface",
           "canonicalReference": "@alloy-js/csharp!LeixcalScopePropsWithScopeInfo:interface",
@@ -14558,7 +14813,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/csharp!PropertyProps#get:member",
-              "docComment": "/**\n * If property should have a getter\n */\n",
+              "docComment": "/**\n * If property should have a getter. Pass `true` for an auto-property getter (`get;`),\n * or pass children for a getter with a body.\n *\n * @example\n *\n *  auto-property\n * ```tsx\n * <Property name=\"Name\" type=\"string\" get set />\n * ```\n *\n * Produces: `string Name { get; set; }`\n *\n * @example\n *\n *  with body\n * ```tsx\n * <Property name=\"Name\" type=\"string\" get={<>return _name;</>} set />\n * ```\n *\n * Produces:\n * ```csharp\n * string Name\n * {\n *     get { return _name; }\n *     set;\n * }\n * ```\n *\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -14566,7 +14821,12 @@
                 },
                 {
                   "kind": "Content",
-                  "text": "boolean"
+                  "text": "boolean | "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "Children",
+                  "canonicalReference": "@alloy-js/core!Children:type"
                 },
                 {
                   "kind": "Content",
@@ -14579,7 +14839,7 @@
               "name": "get",
               "propertyTypeTokenRange": {
                 "startIndex": 1,
-                "endIndex": 2
+                "endIndex": 3
               }
             },
             {
@@ -14727,7 +14987,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/csharp!PropertyProps#set:member",
-              "docComment": "/**\n * If property should have a setter\n */\n",
+              "docComment": "/**\n * If property should have a setter. Pass `true` for an auto-property setter (`set;`),\n * or pass children for a setter with a body.\n *\n * @example\n *\n *  with body\n * ```tsx\n * <Property name=\"Value\" type=\"int\" get set={<>_value = value;</>} />\n * ```\n *\n * Produces:\n * ```csharp\n * int Value\n * {\n *     get;\n *     set { _value = value; }\n * }\n * ```\n *\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -14735,7 +14995,12 @@
                 },
                 {
                   "kind": "Content",
-                  "text": "boolean"
+                  "text": "boolean | "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "Children",
+                  "canonicalReference": "@alloy-js/core!Children:type"
                 },
                 {
                   "kind": "Content",
@@ -14748,7 +15013,7 @@
               "name": "set",
               "propertyTypeTokenRange": {
                 "startIndex": 1,
-                "endIndex": 2
+                "endIndex": 3
               }
             },
             {
@@ -15539,6 +15804,51 @@
             "endIndex": 9
           }
         },
+        {
+          "kind": "Function",
+          "canonicalReference": "@alloy-js/csharp!sanitizeCSharpIdentifier:function(1)",
+          "docComment": "/**\n * Transforms an arbitrary string into a valid C# identifier by replacing\n * invalid characters. The result may still be a C# keyword — callers\n * should combine with keyword escaping if needed.\n *\n * - If the first character is not a letter or underscore, a `_` prefix is added.\n * - Subsequent non-word characters are replaced with `_`.\n * - Empty strings become `_`.\n *\n * @param name - The string to sanitize.\n *\n * @returns  A string that satisfies C# identifier character rules.\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export declare function sanitizeCSharpIdentifier(name: "
+            },
+            {
+              "kind": "Content",
+              "text": "string"
+            },
+            {
+              "kind": "Content",
+              "text": "): "
+            },
+            {
+              "kind": "Content",
+              "text": "string"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "src/identifier-utils.ts",
+          "returnTypeTokenRange": {
+            "startIndex": 3,
+            "endIndex": 4
+          },
+          "releaseTag": "Public",
+          "overloadIndex": 1,
+          "parameters": [
+            {
+              "parameterName": "name",
+              "parameterTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              },
+              "isOptional": false
+            }
+          ],
+          "name": "sanitizeCSharpIdentifier"
+        },
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/csharp!SourceFile:function(1)",