Add @deprecated arg detection to template-no-deprecated

Detects deprecated component arguments in Glimmer templates via a new
GlimmerAttrNode visitor. Navigates the TypeScript type chain from the
component's import symbol through getBaseTypes/getTypeArguments to the
Args object, then checks getJsDocTags on the specific arg's symbol.
Components without typed Args are silently skipped.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: wagenet

lib/rules/template-no-deprecated.js

@@ -33,6 +33,33 @@ module.exports = {
     const checker = services.program.getTypeChecker();
     const sourceCode = context.sourceCode;
 
+    // Cache component class symbol → Args object type (null = no Args) per lint run.
+    const argsTypeCache = new Map();
+
+    function getComponentArgsType(classSymbol) {
+      if (argsTypeCache.has(classSymbol)) {
+        return argsTypeCache.get(classSymbol);
+      }
+      let result = null;
+      try {
+        const declaredType = checker.getDeclaredTypeOfSymbol(classSymbol);
+        const baseTypes = checker.getBaseTypes(declaredType);
+        outer: for (const base of baseTypes) {
+          for (const arg of checker.getTypeArguments(base) ?? []) {
+            const argsSymbol = arg.getProperty('Args');
+            if (argsSymbol) {
+              result = checker.getTypeOfSymbol(argsSymbol);
+              break outer;
+            }
+          }
+        }
+      } catch {
+        result = null;
+      }
+      argsTypeCache.set(classSymbol, result);
+      return result;
+    }
+
     function getJsDocDeprecation(symbol) {
       let jsDocTags;
       try {
@@ -126,6 +153,65 @@ module.exports = {
         const scope = sourceCode.getScope(node.parent);
         checkDeprecatedIdentifier(node.parts[0], scope);
       },
+
+      GlimmerAttrNode(node) {
+        if (!node.name.startsWith('@')) {
+          return;
+        }
+
+        // Resolve the component import binding from the parent element
+        const elementNode = node.parent;
+        const scope = sourceCode.getScope(elementNode.parent);
+        const ref = scope.references.find((v) => v.identifier === elementNode.parts[0]);
+        const def = ref?.resolved?.defs[0];
+        if (!def || def.type !== 'ImportBinding') {
+          return;
+        }
+
+        const tsNode = services.esTreeNodeToTSNodeMap.get(def.node);
+        if (!tsNode) {
+          return;
+        }
+
+        const tsIdentifier = tsNode.name ?? tsNode;
+        const importSymbol = checker.getSymbolAtLocation(tsIdentifier);
+        if (!importSymbol) {
+          return;
+        }
+
+        // Resolve alias to the class symbol
+        // eslint-disable-next-line no-bitwise
+        const classSymbol =
+          importSymbol.flags & TS_ALIAS_FLAG
+            ? checker.getAliasedSymbol(importSymbol)
+            : importSymbol;
+
+        const argsType = getComponentArgsType(classSymbol);
+        if (!argsType) {
+          return;
+        }
+
+        const argName = node.name.slice(1); // strip leading '@'
+        const argSymbol = argsType.getProperty(argName);
+        const reason = getJsDocDeprecation(argSymbol);
+        if (reason === undefined) {
+          return;
+        }
+
+        if (reason === '') {
+          context.report({
+            node,
+            messageId: 'deprecated',
+            data: { name: node.name },
+          });
+        } else {
+          context.report({
+            node,
+            messageId: 'deprecatedWithReason',
+            data: { name: node.name, reason },
+          });
+        }
+      },
     };
   },
 };

tests/lib/rules-preprocessor/template-no-deprecated/component-stub.ts

@@ -0,0 +1,3 @@
+export default class ComponentBase<S extends object = object> {
+  declare args: S;
+}

tests/lib/rules-preprocessor/template-no-deprecated/component-with-args.ts

@@ -0,0 +1,11 @@
+import ComponentBase from './component-stub';
+
+export default class ComponentWithArgs extends ComponentBase<{
+  Args: {
+    /** @deprecated use newArg instead */
+    oldArg: string;
+    /** @deprecated */
+    oldArgNoReason: string;
+    newArg: string;
+  };
+}> {}

tests/lib/rules/template-no-deprecated.js

@@ -80,6 +80,22 @@ ruleTesterTyped.run('template-no-deprecated (with TS project)', rule, {
         <template>{{this.foo}}</template>
       `,
     },
+    // Non-deprecated @arg — no error
+    {
+      filename: path.join(FIXTURES_DIR, 'usage.gts'),
+      code: `
+        import ComponentWithArgs from './component-with-args';
+        <template><ComponentWithArgs @newArg='x' /></template>
+      `,
+    },
+    // @arg on a component with no typed Args — silently skip
+    {
+      filename: path.join(FIXTURES_DIR, 'usage.gts'),
+      code: `
+        import CurrentComponent from './current-component';
+        <template><CurrentComponent @anyArg='x' /></template>
+      `,
+    },
   ],
   invalid: [
     // Deprecated component in element position
@@ -112,5 +128,25 @@ ruleTesterTyped.run('template-no-deprecated (with TS project)', rule, {
       output: null,
       errors: [{ messageId: 'deprecatedWithReason', type: 'VarHead' }],
     },
+    // Deprecated @arg with reason
+    {
+      filename: path.join(FIXTURES_DIR, 'usage.gts'),
+      code: `
+        import ComponentWithArgs from './component-with-args';
+        <template><ComponentWithArgs @oldArg='x' /></template>
+      `,
+      output: null,
+      errors: [{ messageId: 'deprecatedWithReason', data: { name: '@oldArg', reason: 'use newArg instead' } }],
+    },
+    // Deprecated @arg without reason
+    {
+      filename: path.join(FIXTURES_DIR, 'usage.gts'),
+      code: `
+        import ComponentWithArgs from './component-with-args';
+        <template><ComponentWithArgs @oldArgNoReason='x' /></template>
+      `,
+      output: null,
+      errors: [{ messageId: 'deprecated', data: { name: '@oldArgNoReason' } }],
+    },
   ],
 });