add reserved property words to python

iscai-msft · iscai-msft · commit 7b1ce4b5d377 · 2026-03-24T16:33:50.000-04:00
diff --git a/packages/typespec-client-generator-core/src/rules/reserved-words/create-reserved-word-rule.ts b/packages/typespec-client-generator-core/src/rules/reserved-words/create-reserved-word-rule.ts
@@ -61,10 +61,21 @@ export function createReservedWordRule(
         }
       }
 
+      const parameterModels = new WeakSet<Model>();
+
       return {
         model: (node: Model) => check(node, reservedWords.model, "model"),
-        modelProperty: (node: ModelProperty) => check(node, reservedWords.property, "property"),
-        operation: (node: Operation) => check(node, reservedWords.operation, "operation"),
+        modelProperty: (node: ModelProperty) => {
+          if (node.model && parameterModels.has(node.model)) {
+            check(node, reservedWords.parameter, "parameter");
+          } else {
+            check(node, reservedWords.property, "property");
+          }
+        },
+        operation: (node: Operation) => {
+          check(node, reservedWords.operation, "operation");
+          parameterModels.add(node.parameters);
+        },
         enum: (node: Enum) => {
           check(node, reservedWords.enumType, "enum");
           for (const member of node.members.values()) {
diff --git a/packages/typespec-client-generator-core/src/rules/reserved-words/words.ts b/packages/typespec-client-generator-core/src/rules/reserved-words/words.ts
@@ -10,6 +10,8 @@ export interface LanguageReservedWords {
   readonly model: ReadonlySet<string>;
   /** Words reserved when used as property names */
   readonly property: ReadonlySet<string>;
+  /** Words reserved when used as operation parameter names */
+  readonly parameter: ReadonlySet<string>;
   /** Words reserved when used as operation/method names */
   readonly operation: ReadonlySet<string>;
   /** Words reserved when used as enum/union type names */
@@ -25,7 +27,14 @@ export interface LanguageReservedWords {
  */
 function createFlatReservedWords(words: readonly string[]): LanguageReservedWords {
   const set: ReadonlySet<string> = new Set(words);
-  return { model: set, property: set, operation: set, enumType: set, enumMember: set };
+  return {
+    model: set,
+    property: set,
+    parameter: set,
+    operation: set,
+    enumType: set,
+    enumMember: set,
+  };
 }
 
 // ---------------------------------------------------------------------------
@@ -69,9 +78,83 @@ const pythonAlwaysReserved: readonly string[] = [
   "yield",
 ];
 
+// Source: RESERVED_TSP_MODEL_PROPERTIES in python_mappings.py
+// These are Python dict/model base-class method names that conflict with
+// property names because Azure SDK models inherit from a dict-like base.
+const pythonReservedPropertyWords: readonly string[] = [
+  "self",
+  "keys",
+  "items",
+  "values",
+  "popitem",
+  "clear",
+  "update",
+  "setdefault",
+  "pop",
+  "get",
+  "copy",
+  "as_dict",
+  "datetime",
+];
+
+// Source: RESERVED_WORDS[PadType.PARAMETER] + TSP_RESERVED_WORDS[PadType.PARAMETER]
+// in python_mappings.py
+const pythonReservedParameterWords: readonly string[] = [
+  "self",
+  "cls",
+  // SDK operation kwargs
+  "content_type",
+  "accept",
+  "polling",
+  "continuation_token",
+  // transport kwargs
+  // https://github.com/Azure/azure-sdk-for-python/blob/master/sdk/core/azure-core/CLIENT_LIBRARY_DEVELOPER.md#transport
+  "connection_timeout",
+  "connection_verify",
+  "connection_cert",
+  "connection_data_block_size",
+  "use_env_settings",
+  "read_timeout",
+  "proxies",
+  "cookies",
+  // policy kwargs
+  // https://github.com/Azure/azure-sdk-for-python/blob/master/sdk/core/azure-core/CLIENT_LIBRARY_DEVELOPER.md#available-policies
+  "base_headers",
+  "headers",
+  "request_id",
+  "auto_request_id",
+  "base_user_agent",
+  "user_agent",
+  "user_agent_overwrite",
+  "user_agent_use_env",
+  "sdk_moniker",
+  "logging_enable",
+  "logger",
+  "response_encoding",
+  "raw_request_hook",
+  "raw_response_hook",
+  "network_span_namer",
+  "tracing_attributes",
+  "permit_redirects",
+  "redirect_max",
+  "redirect_remove_headers",
+  "redirect_on_status_codes",
+  "retry_total",
+  "retry_connect",
+  "retry_read",
+  "retry_status",
+  "retry_backoff_factor",
+  "retry_backoff_max",
+  "retry_mode",
+  "retry_on_status_codes",
+  // TSP-specific
+  "stream",
+];
+
 export const pythonReservedWords: LanguageReservedWords = {
   model: new Set([...pythonAlwaysReserved, "enum"]),
-  property: new Set([...pythonAlwaysReserved, "self"]),
+  property: new Set([...pythonAlwaysReserved, ...pythonReservedPropertyWords]),
+  parameter: new Set([...pythonAlwaysReserved, ...pythonReservedParameterWords]),
   operation: new Set([...pythonAlwaysReserved]),
   enumType: new Set([...pythonAlwaysReserved, "enum"]),
   enumMember: new Set([...pythonAlwaysReserved]),
diff --git a/packages/typespec-client-generator-core/test/rules/reserved-words.test.ts b/packages/typespec-client-generator-core/test/rules/reserved-words.test.ts
@@ -20,6 +20,7 @@ function expectedMessage(name: string, context: string, language: string): strin
 const testWords: LanguageReservedWords = {
   model: new Set(["reserved"]),
   property: new Set(["reserved"]),
+  parameter: new Set(["reserved"]),
   operation: new Set(["reserved"]),
   enumType: new Set(["reserved"]),
   enumMember: new Set(["reserved"]),
@@ -30,6 +31,7 @@ const testRule = createReservedWordRule("test", "Test", testWords);
 const contextIsolatedWords: LanguageReservedWords = {
   model: new Set(["modelonly"]),
   property: new Set(["proponly"]),
+  parameter: new Set(["paramonly"]),
   operation: new Set(["oponly"]),
   enumType: new Set(["enumtypeonly"]),
   enumMember: new Set(["enummemberonly"]),
@@ -70,6 +72,13 @@ describe("reserved word rule factory", () => {
     });
   });
 
+  it("emits warning for reserved parameter name", async () => {
+    await tester.expect(`op foo(reserved: string): void;`).toEmitDiagnostics({
+      code: "@azure-tools/typespec-client-generator-core/reserved-words-test",
+      message: expectedMessage("reserved", "parameter", "Test"),
+    });
+  });
+
   it("emits warning for reserved enum type name", async () => {
     await tester.expect(`enum reserved { a, b }`).toEmitDiagnostics({
       code: "@azure-tools/typespec-client-generator-core/reserved-words-test",
@@ -199,6 +208,27 @@ describe("context isolation", () => {
     await tester.expect(`model oponly { name: string; }`).toBeValid();
   });
 
+  // -- parameter-only word --
+
+  it("warns when parameter-only reserved word is used as a parameter name", async () => {
+    await tester.expect(`op foo(paramonly: string): void;`).toEmitDiagnostics({
+      code: "@azure-tools/typespec-client-generator-core/reserved-words-isolated",
+      message: expectedMessage("paramonly", "parameter", "Isolated"),
+    });
+  });
+
+  it("does not warn when parameter-only reserved word is used as a property name", async () => {
+    await tester.expect(`model Foo { paramonly: string; }`).toBeValid();
+  });
+
+  it("does not warn when parameter-only reserved word is used as an operation name", async () => {
+    await tester.expect(`op paramonly(): void;`).toBeValid();
+  });
+
+  it("does not warn when parameter-only reserved word is used as a model name", async () => {
+    await tester.expect(`model paramonly { name: string; }`).toBeValid();
+  });
+
   // -- enumType-only word --
 
   it("warns when enumType-only reserved word is used as an enum type name", async () => {
@@ -282,6 +312,28 @@ describe("python reserved words", () => {
     });
   });
 
+  it("emits warning for 'keys' used as property name (Python dict method conflict)", async () => {
+    await tester.expect(`model Foo { keys: string; }`).toEmitDiagnostics({
+      code: "@azure-tools/typespec-client-generator-core/reserved-words-python",
+      message: expectedMessage("keys", "property", "Python"),
+    });
+  });
+
+  it("'keys' does not warn as an operation name (property-only reserved word)", async () => {
+    await tester.expect(`op keys(): void;`).toBeValid();
+  });
+
+  it("emits warning for 'stream' used as parameter name (Python TSP-specific)", async () => {
+    await tester.expect(`op foo(stream: string): void;`).toEmitDiagnostics({
+      code: "@azure-tools/typespec-client-generator-core/reserved-words-python",
+      message: expectedMessage("stream", "parameter", "Python"),
+    });
+  });
+
+  it("'stream' does not warn as a property name (parameter-only reserved word)", async () => {
+    await tester.expect(`model Foo { stream: string; }`).toBeValid();
+  });
+
   it("is valid when @clientName resolves conflict for python scope", async () => {
     await tester
       .expect(`model Foo { @clientName("yieldValue", "python") \`yield\`: string; }`)
