add reserved words test

Author: iscai-msft

packages/typespec-client-generator-core/src/linter.ts

@@ -1,24 +1,46 @@
 import { defineLinter } from "@typespec/compiler";
 import { noUnnamedTypesRule } from "./rules/no-unnamed-types.rule.js";
 import { propertyNameConflictRule } from "./rules/property-name-conflict.rule.js";
+import { csharpReservedWordsRule } from "./rules/reserved-words/csharp.rule.js";
+import { javaReservedWordsRule } from "./rules/reserved-words/java.rule.js";
+import { javascriptReservedWordsRule } from "./rules/reserved-words/javascript.rule.js";
+import { pythonReservedWordsRule } from "./rules/reserved-words/python.rule.js";
 import { requireClientSuffixRule } from "./rules/require-client-suffix.rule.js";
 
-const rules = [requireClientSuffixRule, propertyNameConflictRule, noUnnamedTypesRule];
+const rules = [
+  requireClientSuffixRule,
+  propertyNameConflictRule,
+  noUnnamedTypesRule,
+  csharpReservedWordsRule,
+  pythonReservedWordsRule,
+  javaReservedWordsRule,
+  javascriptReservedWordsRule,
+];
 
-const csharpRules = [propertyNameConflictRule];
+const csharpRules = [propertyNameConflictRule, csharpReservedWordsRule];
+const pythonRules = [pythonReservedWordsRule];
+const javaRules = [javaReservedWordsRule];
+const javascriptRules = [javascriptReservedWordsRule];
+
+function createRuleSet(langRules: typeof rules) {
+  return {
+    enable: {
+      ...Object.fromEntries(
+        langRules.map((rule) => [
+          `@azure-tools/typespec-client-generator-core/${rule.name}`,
+          true,
+        ]),
+      ),
+    },
+  };
+}
 
 export const $linter = defineLinter({
   rules,
   ruleSets: {
-    "best-practices:csharp": {
-      enable: {
-        ...Object.fromEntries(
-          csharpRules.map((rule) => [
-            `@azure-tools/typespec-client-generator-core/${rule.name}`,
-            true,
-          ]),
-        ),
-      },
-    },
+    "best-practices:csharp": createRuleSet(csharpRules),
+    "best-practices:python": createRuleSet(pythonRules),
+    "best-practices:java": createRuleSet(javaRules),
+    "best-practices:javascript": createRuleSet(javascriptRules),
   },
 });

packages/typespec-client-generator-core/src/rules/reserved-words/create-reserved-word-rule.ts

@@ -0,0 +1,79 @@
+import {
+  Enum,
+  EnumMember,
+  Model,
+  ModelProperty,
+  Operation,
+  Union,
+  UnionVariant,
+  createRule,
+  paramMessage,
+} from "@typespec/compiler";
+import { createTCGCContext } from "../../context.js";
+import { getLibraryName } from "../../public-utils.js";
+import { LanguageReservedWords } from "./words.js";
+
+/**
+ * Creates a linter rule that warns when identifiers conflict with reserved
+ * words in a target language. The rule is context-aware: different reserved
+ * word sets can be specified for models, properties, operations, enum types,
+ * and enum members.
+ *
+ * @param language - The scope string for the language (e.g. "python", "csharp").
+ *                   Used with `getLibraryName` to resolve `@clientName` overrides.
+ * @param displayName - Human-readable language name for diagnostic messages (e.g. "Python", "C#").
+ * @param reservedWords - Context-specific reserved word sets.
+ */
+export function createReservedWordRule(
+  language: string,
+  displayName: string,
+  reservedWords: LanguageReservedWords,
+) {
+  return createRule({
+    name: `reserved-words-${language}`,
+    description: `Warns when identifiers conflict with ${displayName} reserved words.`,
+    severity: "warning",
+    url: `https://azure.github.io/typespec-azure/docs/libraries/typespec-client-generator-core/rules/reserved-words-${language}`,
+    messages: {
+      default: paramMessage`'${"name"}' cannot be used as a ${"context"} name since it is a reserved word in ${"language"}. Consider using the @clientName decorator to rename it for ${"language"} code generation.`,
+    },
+    create(context) {
+      const tcgcContext = createTCGCContext(
+        context.program,
+        "@azure-tools/typespec-client-generator-core",
+        {
+          mutateNamespace: false,
+        },
+      );
+
+      function check(
+        target: Model | ModelProperty | Operation | Enum | EnumMember | Union | UnionVariant,
+        wordSet: ReadonlySet<string>,
+        contextName: string,
+      ) {
+        if (typeof target.name !== "string") return;
+        const effectiveName = getLibraryName(tcgcContext, target, language);
+        if (wordSet.has(effectiveName)) {
+          context.reportDiagnostic({
+            format: { name: effectiveName, language: displayName, context: contextName },
+            target,
+          });
+        }
+      }
+
+      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"),
+        enum: (node: Enum) => {
+          check(node, reservedWords.enumType, "enum");
+          for (const member of node.members.values()) {
+            check(member, reservedWords.enumMember, "enum member");
+          }
+        },
+        union: (node: Union) => check(node, reservedWords.enumType, "union"),
+        unionVariant: (node: UnionVariant) => check(node, reservedWords.enumMember, "union variant"),
+      };
+    },
+  });
+}

packages/typespec-client-generator-core/src/rules/reserved-words/csharp.rule.ts

@@ -0,0 +1,8 @@
+import { createReservedWordRule } from "./create-reserved-word-rule.js";
+import { csharpReservedWords } from "./words.js";
+
+export const csharpReservedWordsRule = createReservedWordRule(
+  "csharp",
+  "C#",
+  csharpReservedWords,
+);

packages/typespec-client-generator-core/src/rules/reserved-words/java.rule.ts

@@ -0,0 +1,4 @@
+import { createReservedWordRule } from "./create-reserved-word-rule.js";
+import { javaReservedWords } from "./words.js";
+
+export const javaReservedWordsRule = createReservedWordRule("java", "Java", javaReservedWords);

packages/typespec-client-generator-core/src/rules/reserved-words/javascript.rule.ts

@@ -0,0 +1,8 @@
+import { createReservedWordRule } from "./create-reserved-word-rule.js";
+import { javascriptReservedWords } from "./words.js";
+
+export const javascriptReservedWordsRule = createReservedWordRule(
+  "javascript",
+  "JavaScript",
+  javascriptReservedWords,
+);

packages/typespec-client-generator-core/src/rules/reserved-words/python.rule.ts

@@ -0,0 +1,8 @@
+import { createReservedWordRule } from "./create-reserved-word-rule.js";
+import { pythonReservedWords } from "./words.js";
+
+export const pythonReservedWordsRule = createReservedWordRule(
+  "python",
+  "Python",
+  pythonReservedWords,
+);