@contractkit/plugin-csharp 0.1.2 → 0.1.4

package/dist/naming.d.ts

@@ -36,6 +36,18 @@ export declare function toCSharpPropertyName(name: string): string;
  * regularly — a path parameter named `event` or `params` is ordinary in a contract.
  */
 export declare function toCSharpParameterName(name: string): string;
+/**
+ * A C# parameter or local name for each declared name, keyed by that name.
+ *
+ * Each goes through {@link toCSharpParameterName}, then gains a `_` until it collides with neither
+ * one of `taken` nor another name's result, and is keyword-escaped last. The comparison is on the
+ * unescaped spelling, since `@class` and `class` are the same identifier to the compiler. Returns
+ * the plain conversion in the common case, so existing output stays byte-identical.
+ *
+ * @param taken Unescaped identifiers the surrounding generated code already binds or reads, which
+ * a declared name must not duplicate or shadow.
+ */
+export declare function bindCSharpParameterNames(names: readonly string[], taken: Iterable<string>): Map<string, string>;
 /**
  * Make a property name safe inside `ownerTypeName`.
  *

package/dist/naming.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"naming.d.ts","sourceRoot":"","sources":["../src/naming.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,eAAe,EAAE,WAAW,CAAC,MAAM,CA8E9C,CAAC;AAQH;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAMzD;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAQ1D;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,YAAY,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,CAGlF;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAMrD;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAM3D;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAM5D;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAOzD;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,SAAY,GAAG,MAAM,EAAE,CAMnF;AAED,yFAAyF;AACzF,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE9C;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CASvD"}
+{"version":3,"file":"naming.d.ts","sourceRoot":"","sources":["../src/naming.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,eAAe,EAAE,WAAW,CAAC,MAAM,CA8E9C,CAAC;AAQH;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAMzD;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAQ1D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,EAAE,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAU/G;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,YAAY,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,CAGlF;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAMrD;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAM3D;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAM5D;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAOzD;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,SAAY,GAAG,MAAM,EAAE,CAMnF;AAED,yFAAyF;AACzF,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE9C;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CASvD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contractkit/plugin-csharp",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "ContractKit built-in plugin: C#/.NET SDK client generation (System.Text.Json + HttpClient, no NuGet dependencies)",
   "license": "MIT",
   "author": {

package/src/codegen-client.ts

@@ -12,6 +12,7 @@ import { classifyContentType, observableResponses, resolveModifiers } from '@con
 import type { HoistResult } from './hoist.js';
 import { createRenderContext, renderCSharpType, renderFile, type RenderContext } from './codegen-models.js';
 import {
+    bindCSharpParameterNames,
     deriveCSharpFileBase,
     quoteCSharpString,
     safeMemberName,
@@ -193,11 +194,14 @@ function observableOf(shape: ResponseShape): OpResponseNode[] {
 function generateMethod(route: OpRouteNode, op: OpOperationNode, ctx: RenderContext, methodName: string): string[] {
     const base = methodBase(methodName);
     const shape = responseShape(op);
-    const returnType = returnTypeFor(shape, base, ctx);
+    const returnType = returnTypeFor(shape, op, base, ctx);
     const observable = observableOf(shape);
     const expectStatuses = observable.filter(r => r.statusCode < 200 || r.statusCode >= 300).map(r => r.statusCode);
 
-    const params = buildMethodParams(route, op, ctx);
+    const pathBindings = bindPathParams(route);
+    const params = buildMethodParams(route, op, ctx, pathBindings);
+    // Everything the body can see by name: a response-header pattern variable must not redeclare one.
+    const bound = [...METHOD_LOCALS, ...params.map(p => p.name.replace(/^@/, ''))];
     const signature = [...params.map(p => `${p.type} ${p.name}${p.optional ? ' = null' : ''}`), 'CancellationToken cancellationToken = default'].join(
         ', ',
     );
@@ -209,7 +213,7 @@ function generateMethod(route: OpRouteNode, op: OpOperationNode, ctx: RenderCont
     lines.push(`public async ${returnType === 'void' ? 'Task' : `Task<${returnType}>`} ${methodName}(${signature})`);
     lines.push('{');
 
-    const callArgs: string[] = [`HttpMethod.${httpMethodConstant(op.method)}`, buildPathExpression(route.path, route.params)];
+    const callArgs: string[] = [`HttpMethod.${httpMethodConstant(op.method)}`, buildPathExpression(route.path, route.params, pathBindings)];
     if (op.query) callArgs.push('query: http.Params(query)');
     if (op.headers) callArgs.push('headers: http.Params(customHeaders)');
     const content = bodyArgument(op);
@@ -222,18 +226,18 @@ function generateMethod(route: OpRouteNode, op: OpOperationNode, ctx: RenderCont
     callArgs.forEach((arg, index) => {
         lines.push(`        ${arg}${index === callArgs.length - 1 ? ').ConfigureAwait(false);' : ','}`);
     });
-    lines.push(...returnStatements(shape, base, ctx, where(route, op)));
+    lines.push(...returnStatements(shape, op, base, ctx, where(route, op), bound));
     lines.push('}');
     return lines;
 }
 
 /** What a method hands back. Declared before the body so the two cannot drift apart. */
-function returnTypeFor(shape: ResponseShape, base: string, ctx: RenderContext): string {
+function returnTypeFor(shape: ResponseShape, op: OpOperationNode, base: string, ctx: RenderContext): string {
     if (shape.kind !== 'simple') return `${base}Response`;
     const response = shape.response;
     const body = response?.bodies[0];
     const headers = response?.headers ?? [];
-    if (!body) return headers.length > 0 ? `${base}Headers` : 'void';
+    if (!body) return headers.length > 0 ? headersRecordName(op, base) : 'void';
     const dataType = bodyCSharpType(body, ctx);
     // A declared response header changes the return shape: the body alone cannot carry it.
     return headers.length > 0 ? `${base}Result` : dataType;
@@ -264,19 +268,26 @@ function bodyReadExpr(body: OpResponseBodyNode, ctx: RenderContext): string {
 }
 
 /** The statements after `ExecuteAsync`, which turn the response into the declared return type. */
-function returnStatements(shape: ResponseShape, base: string, ctx: RenderContext, place: string): string[] {
+function returnStatements(
+    shape: ResponseShape,
+    op: OpOperationNode,
+    base: string,
+    ctx: RenderContext,
+    place: string,
+    bound: readonly string[],
+): string[] {
     if (shape.kind === 'simple') {
         const response = shape.response;
         const body = response?.bodies[0];
         const headers = response?.headers ?? [];
         if (headers.length === 0) return body ? [`    return ${bodyReadExpr(body, ctx)};`] : [];
-        const lines = readHeaderLines(headers, `${base}Headers`, ctx, place, '    ');
+        const lines = readHeaderLines(headers, headersRecordName(op, base), ctx, place, '    ', bound);
         return body ? [...lines, `    return new ${base}Result(${bodyReadExpr(body, ctx)}, headers);`] : [...lines, '    return headers;'];
     }
 
     if (shape.kind === 'multiMime') {
         const headers = shape.response.headers ?? [];
-        const lines = headers.length > 0 ? readHeaderLines(headers, `${base}Headers`, ctx, place, '    ') : [];
+        const lines = headers.length > 0 ? readHeaderLines(headers, headersRecordName(op, base), ctx, place, '    ', bound) : [];
         lines.push(...mimeSwitch(shape.response, base, undefined, ctx, '    ', headers.length > 0));
         return lines;
     }
@@ -288,13 +299,13 @@ function returnStatements(shape: ResponseShape, base: string, ctx: RenderContext
     for (const response of rest) {
         lines.push(`        case ${response.statusCode}:`);
         lines.push('        {');
-        lines.push(...statusBranch(response, base, response.statusCode, ctx, place, '            '));
+        lines.push(...statusBranch(response, op, base, response.statusCode, ctx, place, '            ', bound));
         lines.push('        }');
         lines.push('');
     }
     lines.push('        default:');
     lines.push('        {');
-    lines.push(...statusBranch(fallback!, base, fallback!.statusCode, ctx, place, '            '));
+    lines.push(...statusBranch(fallback!, op, base, fallback!.statusCode, ctx, place, '            ', bound));
     lines.push('        }');
     lines.push('    }');
     return lines;
@@ -306,10 +317,19 @@ function returnStatements(shape: ResponseShape, base: string, ctx: RenderContext
  * Every branch is braced. Two branches each declaring `headers` would otherwise collide, since a
  * declaration in a switch section is scoped to the whole switch block rather than to its own case.
  */
-function statusBranch(response: OpResponseNode, base: string, statusCode: number, ctx: RenderContext, place: string, indent: string): string[] {
+function statusBranch(
+    response: OpResponseNode,
+    op: OpOperationNode,
+    base: string,
+    statusCode: number,
+    ctx: RenderContext,
+    place: string,
+    indent: string,
+    bound: readonly string[],
+): string[] {
     const lines: string[] = [];
     const headers = response.headers ?? [];
-    if (headers.length > 0) lines.push(...readHeaderLines(headers, headersRecordName(base, statusCode), ctx, place, indent));
+    if (headers.length > 0) lines.push(...readHeaderLines(headers, headersRecordName(op, base, statusCode), ctx, place, indent, bound));
     lines.push(...mimeSwitch(response, base, statusCode, ctx, indent, headers.length > 0));
     return lines;
 }
@@ -371,8 +391,22 @@ function bodyArgument(op: OpOperationNode): string | undefined {
 
 // ─── Response declarations ─────────────────────────────────────────────────
 
-function headersRecordName(base: string, statusCode?: number): string {
-    return statusCode === undefined ? `${base}Headers` : `${base}${statusCode}Headers`;
+/**
+ * The name of a response-headers record: `<Method><Status>Headers` when the status is part of the
+ * value, otherwise `<Method>Headers`.
+ *
+ * The request-headers record claims `<Method>Headers` first, since it is the one a caller builds by
+ * name, so an operation that declares both gets `<Method>ResponseHeaders` for its response side.
+ * Two records of one name in one namespace is CS0101.
+ */
+function headersRecordName(op: OpOperationNode, base: string, statusCode?: number): string {
+    if (statusCode !== undefined) return `${base}${statusCode}Headers`;
+    return declaresRequestHeadersRecord(op) ? `${base}ResponseHeaders` : `${base}Headers`;
+}
+
+/** Whether the operation's `headers:` block gets a generated `<Method>Headers` record. */
+function declaresRequestHeadersRecord(op: OpOperationNode): boolean {
+    return op.headers?.kind === 'params' && op.headers.nodes.length > 0;
 }
 
 /**
@@ -415,12 +449,12 @@ function responseDeclarations(route: OpRouteNode, op: OpOperationNode, ctx: Rend
         const response = shape.response;
         const headers = response?.headers ?? [];
         if (headers.length === 0) return lines;
-        headerRecord(headers, headersRecordName(base));
+        headerRecord(headers, headersRecordName(op, base));
         const body = response?.bodies[0];
         if (body) {
             lines.push('');
             lines.push(...xmlDocLines(`The body of ${place}, with the response headers the contract declares.`, ''));
-            lines.push(`public sealed record ${base}Result(${bodyCSharpType(body, ctx)} Data, ${headersRecordName(base)} Headers);`);
+            lines.push(`public sealed record ${base}Result(${bodyCSharpType(body, ctx)} Data, ${headersRecordName(op, base)} Headers);`);
         }
         return lines;
     }
@@ -429,7 +463,7 @@ function responseDeclarations(route: OpRouteNode, op: OpOperationNode, ctx: Rend
     const withStatus = shape.kind === 'multiStatus';
     for (const response of responses) {
         const headers = response.headers ?? [];
-        if (headers.length > 0) headerRecord(headers, headersRecordName(base, withStatus ? response.statusCode : undefined));
+        if (headers.length > 0) headerRecord(headers, headersRecordName(op, base, withStatus ? response.statusCode : undefined));
     }
 
     lines.push('');
@@ -453,7 +487,7 @@ function responseDeclarations(route: OpRouteNode, op: OpOperationNode, ctx: Rend
             const name = leafRecordName(response, body, statusCode);
             const parameters: string[] = [];
             if (body) parameters.push(`${bodyCSharpType(body, ctx)} Data`);
-            if (headers.length > 0) parameters.push(`${headersRecordName(base, statusCode)} Headers`);
+            if (headers.length > 0) parameters.push(`${headersRecordName(op, base, statusCode)} Headers`);
             lines.push('');
             lines.push(`    public sealed record ${name}(${parameters.join(', ')}) : ${base}Response;`);
         }
@@ -515,14 +549,27 @@ function describeHeaderType(type: { kind: string; name?: string }): string {
 }
 
 /** The lines that build one response-headers value out of the response. */
-function readHeaderLines(headers: OpResponseHeaderNode[], typeName: string, ctx: RenderContext, place: string, indent: string): string[] {
+function readHeaderLines(
+    headers: OpResponseHeaderNode[],
+    typeName: string,
+    ctx: RenderContext,
+    place: string,
+    indent: string,
+    bound: readonly string[],
+): string[] {
+    // Pattern variables share the statement's scope, and the method's: each needs a name nothing
+    // else in either binds.
+    const locals = bindCSharpParameterNames(
+        headers.filter(h => h.optional).map(h => h.name),
+        bound,
+    );
     const args = headers.map(header => {
         const reader = headerReader(header, place);
         const name = quoteCSharpString(header.name);
         // A required header the service omitted is a broken contract, not a null the caller has to
         // handle; an optional one simply stays absent.
         if (!header.optional) return reader.read(`http.RequireHeader(response, ${name})`);
-        const local = toCSharpParameterName(header.name);
+        const local = locals.get(header.name)!;
         return `response.Header(${name}) is { } ${local} ? ${reader.read(local)} : null`;
     });
     const lines: string[] = [`${indent}var headers = new ${typeName}(`];
@@ -564,7 +611,7 @@ const PATH_PLACEHOLDER = /\{([a-zA-Z_$][a-zA-Z0-9_$.-]*)\}/g;
  * values that came from the caller are percent-encoded. `params` says where a value lives: spread
  * across the signature, or behind one `pathParams` argument when the route declares a model.
  */
-export function buildPathExpression(path: string, params?: ParamSource): string {
+export function buildPathExpression(path: string, params?: ParamSource, bindings?: ReadonlyMap<string, string>): string {
     const args = path
         .split('/')
         .filter(Boolean)
@@ -572,7 +619,10 @@ export function buildPathExpression(path: string, params?: ParamSource): string
             PATH_PLACEHOLDER.lastIndex = 0;
             const match = PATH_PLACEHOLDER.exec(raw);
             if (!match || match[0] !== raw) return quoteCSharpString(raw);
-            const value = params && params.kind !== 'params' ? `pathParams.${toCSharpPropertyName(match[1]!)}` : toCSharpParameterName(match[1]!);
+            const value =
+                params && params.kind !== 'params'
+                    ? `pathParams.${toCSharpPropertyName(match[1]!)}`
+                    : (bindings?.get(match[1]!) ?? toCSharpParameterName(match[1]!));
             return `http.Segment(${value})`;
         });
     return `http.Path(${args.join(', ')})`;
@@ -580,6 +630,27 @@ export function buildPathExpression(path: string, params?: ParamSource): string
 
 // ─── Parameters ────────────────────────────────────────────────────────────
 
+/**
+ * Identifiers a generated method binds or reads besides its path parameters: the other arguments
+ * {@link buildMethodParams} can declare, the trailing `CancellationToken`, the locals the body
+ * declares, and the client's own `http` constructor parameter. A path parameter under one of these
+ * names would duplicate an argument (CS0100), clash with a local (CS0136), or hide `http`.
+ */
+const METHOD_LOCALS = ['body', 'query', 'customHeaders', 'pathParams', 'cancellationToken', 'response', 'headers', 'http'] as const;
+
+/**
+ * The C# parameter name each inline path parameter is spread into the signature under, keyed by its
+ * declared name. Keyword-escaped (`@class`), and suffixed when it lands on one of
+ * {@link METHOD_LOCALS} (`body_`). Empty when the route has no inline params.
+ */
+function bindPathParams(route: OpRouteNode): Map<string, string> {
+    if (route.params?.kind !== 'params') return new Map();
+    return bindCSharpParameterNames(
+        route.params.nodes.map(n => n.name),
+        METHOD_LOCALS,
+    );
+}
+
 interface MethodParam {
     name: string;
     type: string;
@@ -594,13 +665,13 @@ interface MethodParam {
  * order cannot always survive. The relative order within each group is kept, and a trailing
  * `CancellationToken` is appended by the caller.
  */
-function buildMethodParams(route: OpRouteNode, op: OpOperationNode, ctx: RenderContext): MethodParam[] {
+function buildMethodParams(route: OpRouteNode, op: OpOperationNode, ctx: RenderContext, pathBindings: ReadonlyMap<string, string>): MethodParam[] {
     const params: MethodParam[] = [];
 
     if (route.params) {
         if (route.params.kind === 'params') {
             for (const node of route.params.nodes) {
-                params.push({ name: toCSharpParameterName(node.name), type: renderCSharpType(node.type, ctx, true), optional: false });
+                params.push({ name: pathBindings.get(node.name)!, type: renderCSharpType(node.type, ctx, true), optional: false });
             }
         } else {
             // Not `params`, which is a C# keyword: the argument would have to be written `@params`.

package/src/codegen-models.ts

@@ -276,8 +276,21 @@ function literalCSharpType(value: string | number | boolean, ctx: RenderContext)
  * Render a contract default as a C# expression of the field's own type. Returns `undefined` when the
  * value cannot be expressed, so the field is emitted as `required` rather than with an initializer
  * that will not compile.
+ *
+ * `memberNames` are the property names of the record the initializer sits in. Inside that record a
+ * simple name resolves to a member before a type, so `public Rating? Rating { get; init; } =
+ * Rating.Neutral;` reads the instance property and fails with CS0236. C#'s rule that lets a member
+ * share its type's name applies only when the member's type is exactly that type, and `Rating?` is
+ * `Nullable<Rating>`. An enum a member would shadow is written from the global namespace instead.
  */
-function renderDefault(value: string | number | boolean, type: ContractTypeNode, ctx: RenderContext): string | undefined {
+function renderDefault(
+    value: string | number | boolean,
+    type: ContractTypeNode,
+    ctx: RenderContext,
+    memberNames: ReadonlySet<string> = new Set(),
+): string | undefined {
+    const enumType = (name: string): string => (memberNames.has(name) ? `global::${ctx.namespace}.Models.${name}` : name);
+
     const inner = type.kind === 'lazy' ? type.inner : type;
 
     if (typeof value === 'boolean') return String(value);
@@ -303,7 +316,7 @@ function renderDefault(value: string | number | boolean, type: ContractTypeNode,
     if (inner.kind === 'enum') {
         const decl = ctx.hoisted?.byNode.get(inner);
         if (!decl || !inner.values.includes(value)) return undefined;
-        return `${decl.name}.${enumMemberNames(inner.values).get(value)}`;
+        return `${enumType(decl.name)}.${enumMemberNames(inner.values).get(value)}`;
     }
 
     // The same default written against a NAMED enum contract — `rating: Rating = "neutral"`, where
@@ -312,7 +325,7 @@ function renderDefault(value: string | number | boolean, type: ContractTypeNode,
         const target = ctx.modelIndex.get(inner.name);
         const targetType = target?.type?.kind === 'lazy' ? target.type.inner : target?.type;
         if (targetType?.kind !== 'enum' || !targetType.values.includes(value)) return undefined;
-        return `${inner.name}.${enumMemberNames(targetType.values).get(value)}`;
+        return `${enumType(inner.name)}.${enumMemberNames(targetType.values).get(value)}`;
     }
 
     if (inner.kind === 'scalar') {
@@ -619,11 +632,12 @@ function renderRecord(
         return lines;
     }
 
+    const memberNames = new Set(fields.map(field => memberName(field, name)));
     lines.push(`public sealed record ${name}${implementsClause}`);
     lines.push('{');
     fields.forEach((field, index) => {
         if (index > 0) lines.push('');
-        lines.push(...renderField(field, ctx, forInput, name, wireCase));
+        lines.push(...renderField(field, ctx, forInput, name, memberNames, wireCase));
     });
     lines.push('}');
     return lines;
@@ -641,19 +655,31 @@ function renderRecord(
  * `#nullable enable` and the generated SDK compiles with warnings as errors. `required` is never
  * combined with `[JsonIgnore]`, which System.Text.Json rejects at run time.
  */
-function renderField(field: FieldNode, ctx: RenderContext, forInput: boolean, ownerTypeName: string, wireCase?: WireCase): string[] {
-    const propName = safeMemberName(toCSharpPropertyName(field.name), ownerTypeName);
+/** The C# property name a field is emitted under inside `ownerTypeName`. */
+function memberName(field: FieldNode, ownerTypeName: string): string {
+    return safeMemberName(toCSharpPropertyName(field.name), ownerTypeName);
+}
+
+function renderField(
+    field: FieldNode,
+    ctx: RenderContext,
+    forInput: boolean,
+    ownerTypeName: string,
+    memberNames: ReadonlySet<string>,
+    wireCase?: WireCase,
+): string[] {
+    const propName = memberName(field, ownerTypeName);
     const wireName = applyWireCase(field.name, wireCase);
 
     let typeStr = renderCSharpType(field.type, ctx, forInput);
     if ((field.optional || field.nullable) && !typeStr.endsWith('?')) typeStr += '?';
 
-    let initializer = field.default !== undefined ? renderDefault(field.default, field.type, ctx) : undefined;
+    let initializer = field.default !== undefined ? renderDefault(field.default, field.type, ctx, memberNames) : undefined;
     // A `literal()` field carries exactly one value, so it defaults to it rather than being asked
     // for at every call site. The property is ordinary, so the value always reaches the wire.
     if (initializer === undefined && !field.optional && !field.nullable) {
         const inner = field.type.kind === 'lazy' ? field.type.inner : field.type;
-        if (inner.kind === 'literal') initializer = renderDefault(inner.value, inner, ctx);
+        if (inner.kind === 'literal') initializer = renderDefault(inner.value, inner, ctx, memberNames);
     }
 
     const isRequired = !field.optional && initializer === undefined;

package/src/naming.ts

@@ -141,6 +141,29 @@ export function toCSharpParameterName(name: string): string {
     return escapeCSharpIdentifier(result);
 }
 
+/**
+ * A C# parameter or local name for each declared name, keyed by that name.
+ *
+ * Each goes through {@link toCSharpParameterName}, then gains a `_` until it collides with neither
+ * one of `taken` nor another name's result, and is keyword-escaped last. The comparison is on the
+ * unescaped spelling, since `@class` and `class` are the same identifier to the compiler. Returns
+ * the plain conversion in the common case, so existing output stays byte-identical.
+ *
+ * @param taken Unescaped identifiers the surrounding generated code already binds or reads, which
+ * a declared name must not duplicate or shadow.
+ */
+export function bindCSharpParameterNames(names: readonly string[], taken: Iterable<string>): Map<string, string> {
+    const unavailable = new Set<string>(taken);
+    const bindings = new Map<string, string>();
+    for (const name of names) {
+        let local = toCSharpParameterName(name).replace(/^@/, '');
+        while (unavailable.has(local)) local += '_';
+        unavailable.add(local);
+        bindings.set(name, escapeCSharpIdentifier(local));
+    }
+    return bindings;
+}
+
 /**
  * Make a property name safe inside `ownerTypeName`.
  *

package/tests/codegen-client.test.ts

@@ -171,6 +171,37 @@ describe('parameters', () => {
         expect(signature).toContain('ListQuery? query = null');
     });
 
+    it('escapes a path param named after a C# keyword, in the signature and the path alike', () => {
+        const root = opRoot([opRoute('/seats/{class}', [opOperation('get', { sdk: 'getSeat' })], [opParam('class', scalarType('string'))])]);
+        const out = render(root, { contracts });
+        expect(out).toContain('public async Task GetSeatAsync(string @class, CancellationToken cancellationToken = default)');
+        expect(out).toContain('http.Path("seats", http.Segment(@class))');
+    });
+
+    it('suffixes a path param named like the request body argument, which would otherwise be CS0100', () => {
+        const root = opRoot([
+            opRoute(
+                '/notes/{body}',
+                [opOperation('put', { sdk: 'putNote', request: opRequest('Payment') })],
+                [opParam('body', scalarType('string'))],
+            ),
+        ]);
+        const out = render(root, { contracts });
+        expect(out).toContain('PutNoteAsync(string body_, Payment body, CancellationToken cancellationToken = default)');
+        expect(out).toContain('http.Path("notes", http.Segment(body_))');
+        expect(out).toContain('content: http.JsonContent(body, "application/json")');
+    });
+
+    it.each(['query', 'customHeaders', 'cancellationToken', 'response', 'headers', 'http', 'pathParams'])(
+        'suffixes a path param named `%s`, which the method already binds or reads',
+        name => {
+            const root = opRoot([opRoute(`/things/{${name}}`, [opOperation('get', { sdk: 'getThing' })], [opParam(name, scalarType('string'))])]);
+            const out = render(root, { contracts });
+            expect(out).toContain(`GetThingAsync(string ${name}_, CancellationToken cancellationToken = default)`);
+            expect(out).toContain(`http.Segment(${name}_)`);
+        },
+    );
+
     it('names a route-level params model pathParams, since params is a C# keyword', () => {
         const root = opRoot([opRoute('/refunds/{paymentId}', [opOperation('get', { sdk: 'refund' })], paramRef('PaymentRef'))]);
         const out = render(root, { contracts: [contractRoot([model('PaymentRef', [field('paymentId', scalarType('uuid'))])])] });
@@ -269,7 +300,79 @@ describe('response headers', () => {
         expect(withHeaders([{ name: 'h', optional: false, type: scalarType('bigint') }])).toContain('BigInteger.Parse(');
     });
 
+    it('renames an optional header pattern variable that would redeclare a parameter', () => {
+        const root = opRoot([
+            opRoute(
+                '/payments/{from}',
+                [
+                    opOperation('get', {
+                        sdk: 'get',
+                        responses: [{ ...opResponse(200, 'Payment'), headers: [{ name: 'from', optional: true, type: scalarType('string') }] }],
+                    }),
+                ],
+                [opParam('from', scalarType('string'))],
+            ),
+        ]);
+        const out = render(root, { contracts });
+        // `is { } from` in the method that takes `string from` is CS0136.
+        expect(out).toContain('response.Header("from") is { } from_ ? from_ : null');
+    });
+
     it('rejects a header type that cannot come off the wire as text', () => {
         expect(() => withHeaders([{ name: 'h', optional: false, type: scalarType('json') }])).toThrow(/cannot be read from an HTTP header/);
     });
 });
+
+describe('request and response headers on one operation', () => {
+    const contracts = [contractRoot([model('Payment', [field('id', scalarType('uuid'))])])];
+    const requestHeaders = [opParam('from', scalarType('string'), { optional: true })];
+    const responseHeaders = [{ name: 'x-request-id', optional: false, type: scalarType('string') }];
+
+    it('gives the response side its own record name, so the namespace does not declare GetHeaders twice', () => {
+        const root = opRoot([
+            opRoute('/payments', [
+                opOperation('get', { sdk: 'get', headers: requestHeaders, responses: [{ ...opResponse(200, 'Payment'), headers: responseHeaders }] }),
+            ]),
+        ]);
+        const out = render(root, { contracts });
+        expect(out.match(/public sealed record GetHeaders\b/g)).toHaveLength(1);
+        expect(out).toContain('GetHeaders? customHeaders = null');
+        expect(out).toContain('public sealed record GetResponseHeaders(string XRequestId);');
+        expect(out).toContain('public sealed record GetResult(Payment Data, GetResponseHeaders Headers);');
+        expect(out).toContain('var headers = new GetResponseHeaders(');
+    });
+
+    it('returns the renamed record when the response carries headers and no body', () => {
+        const root = opRoot([
+            opRoute('/payments', [
+                opOperation('head', { sdk: 'get', headers: requestHeaders, responses: [{ ...opResponse(204), headers: responseHeaders }] }),
+            ]),
+        ]);
+        expect(render(root, { contracts })).toContain('public async Task<GetResponseHeaders> GetAsync(');
+    });
+
+    it('keeps GetHeaders for the response side when the operation declares no request headers', () => {
+        const root = opRoot([
+            opRoute('/payments', [opOperation('get', { sdk: 'get', responses: [{ ...opResponse(200, 'Payment'), headers: responseHeaders }] })]),
+        ]);
+        expect(render(root, { contracts })).toContain('public sealed record GetHeaders(string XRequestId);');
+    });
+
+    it('leaves per-status header records alone, since they never collide', () => {
+        const root = opRoot([
+            opRoute('/payments', [
+                opOperation('get', {
+                    sdk: 'get',
+                    headers: requestHeaders,
+                    responses: [
+                        { ...opResponse(200, 'Payment'), headers: responseHeaders },
+                        { ...opResponse(202, 'Payment'), headers: responseHeaders },
+                    ],
+                }),
+            ]),
+        ]);
+        const out = render(root, { contracts });
+        expect(out).toContain('public sealed record Get200Headers(string XRequestId);');
+        expect(out).toContain('public sealed record Get202Headers(string XRequestId);');
+    });
+});

package/tests/codegen-models.test.ts

@@ -154,6 +154,21 @@ describe('optional, nullable, default and literal', () => {
         ]);
         expect(render(root)).toContain('public Rating R { get; init; } = Rating.Neutral;');
     });
+
+    it('qualifies the enum when a property of the same record shares its name', () => {
+        // `Rating?` is `Nullable<Rating>`, so C#'s same-name rule does not apply and a bare
+        // `Rating.Neutral` reads the property: CS0236 at build time.
+        const root = contractRoot([
+            model('Rating', [], { type: enumType('good', 'neutral') }),
+            model('M', [field('rating', refType('Rating'), { optional: true, default: 'neutral' })]),
+        ]);
+        expect(render(root)).toContain('public Rating? Rating { get; init; } = global::Acme.Sdk.Models.Rating.Neutral;');
+    });
+
+    it('qualifies a hoisted enum shadowed by a sibling property', () => {
+        const out = render(one('M', field('status', enumType('pending', 'done'), { default: 'done' }), field('mStatus', scalarType('string'))));
+        expect(out).toContain('public MStatus Status { get; init; } = global::Acme.Sdk.Models.MStatus.Done;');
+    });
 });
 
 describe('naming', () => {

package/tests/naming.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, it } from 'vitest';
 import {
     CSHARP_KEYWORDS,
+    bindCSharpParameterNames,
     deriveCSharpFileBase,
     escapeCSharpIdentifier,
     escapeXml,
@@ -59,6 +60,31 @@ describe('toCSharpParameterName', () => {
     });
 });
 
+describe('bindCSharpParameterNames', () => {
+    it('converts and escapes like toCSharpParameterName when nothing collides', () => {
+        expect(bindCSharpParameterNames(['invoice-id', 'class'], [])).toEqual(
+            new Map([
+                ['invoice-id', 'invoiceId'],
+                ['class', '@class'],
+            ]),
+        );
+    });
+
+    it('suffixes a name that lands on one already taken', () => {
+        expect(bindCSharpParameterNames(['body'], ['body']).get('body')).toBe('body_');
+    });
+
+    it('compares the unescaped spelling, since @class and class are one identifier', () => {
+        expect(bindCSharpParameterNames(['class'], ['class']).get('class')).toBe('class_');
+    });
+
+    it('keeps two names distinct when a suffix would collapse them onto one', () => {
+        const bindings = bindCSharpParameterNames(['body', 'body_'], ['body']);
+        expect(bindings.get('body')).toBe('body_');
+        expect(bindings.get('body_')).toBe('body__');
+    });
+});
+
 describe('safeMemberName', () => {
     it('renames a member that matches its enclosing type, which C# rejects', () => {
         expect(safeMemberName('Invoice', 'Invoice')).toBe('InvoiceValue');