Sync with ember-template-lint

Author: NullVoxPopuli

docs/rules/template-no-restricted-invocations.md

@@ -6,72 +6,44 @@ Disallow certain components, helpers or modifiers from being used.
 
 Use cases include:
 
-- You bring in some addon with helpers or components, but your team deems one or many not suitable and wants to guard against their usage
+- You bring in some addon like ember-composable-helpers, but your team deems one or many of the helpers not suitable and wants to guard against their usage
 - You want to discourage use of a deprecated component
 
 ## Examples
 
 Given a config of:
 
 ```json
-{ "template-no-restricted-invocations": ["foo-bar"] }
+["foo-bar"]
 ```
 
 This rule **forbids** the following:
 
-```gjs
-<template>{{foo-bar}}</template>
+```hbs
+{{foo-bar}}
 ```
 
-```gjs
-<template>{{#foo-bar}}{{/foo-bar}}</template>
+```hbs
+{{#foo-bar}}{{/foo-bar}}
 ```
 
-```gjs
-<template><FooBar /></template>
-```
-
-This rule **allows** the following:
-
-```gjs
-<template>{{baz}}</template>
-```
-
-```gjs
-<template><Baz /></template>
+```hbs
+<FooBar />
 ```
 
 ## Configuration
 
 One of these:
 
-- `string[]` - helpers or components to disallow (using kebab-case names like `nested-scope/component-name`)
-- `object[]` - with the following keys:
-  - `names` - `string[]` - helpers or components to disallow
-  - `message` - `string` - custom error message to report for violations
-
-```js
-// .eslintrc.js
-module.exports = {
-  rules: {
-    'ember/template-no-restricted-invocations': [
-      'error',
-      [
-        'foo-bar',
-        {
-          names: ['deprecated-component'],
-          message: 'Use new-component instead',
-        },
-      ],
-    ],
-  },
-};
-```
+- string[] - helpers or components to disallow (using kebab-case names like `nested-scope/component-name`)
+- object[] - with the following keys:
+  - `names` - string[] - helpers or components to disallow (using kebab-case names like `nested-scope/component-name`)
+  - `message` - string - custom error message to report for violations (typically a deprecation notice / explanation of why not to use it and a recommended replacement)
 
 ## Related Rules
 
 - [ember/no-restricted-service-injections](https://github.com/ember-cli/eslint-plugin-ember/blob/master/docs/rules/no-restricted-service-injections.md)
 
 ## References
 
-- [emberjs.com - Deprecations](https://guides.emberjs.com/release/deprecations/)
+- [ember-cli-deprecation-workflow](https://github.com/mixonic/ember-cli-deprecation-workflow)

lib/rules/template-no-restricted-invocations.js

@@ -129,14 +129,18 @@ module.exports = {
           const scope = sourceCode.getScope(node.parent);
           const ref = scope.references.find((r) => r.identifier === node.parts[0]);
           // Only exempt if the reference actually resolves to a JS variable definition
-          return ref != null && ref.resolved != null;
+          return (
+            ref !== null && ref !== undefined && ref.resolved !== null && ref.resolved !== undefined
+          );
         }
 
         // For mustache/block/sub/modifier statements, check the path's head
         if (node.path && node.path.head) {
           const scope = sourceCode.getScope(node);
           const ref = scope.references.find((r) => r.identifier === node.path.head);
-          return ref != null && ref.resolved != null;
+          return (
+            ref !== null && ref !== undefined && ref.resolved !== null && ref.resolved !== undefined
+          );
         }
       } catch {
         // sourceCode.getScope may not be available in .hbs-only mode; ignore.
@@ -231,22 +235,46 @@ module.exports = {
       return '';
     }
 
+    function checkElementModifiers(node) {
+      if (!node.modifiers) {
+        return;
+      }
+      for (const modifier of node.modifiers) {
+        const modName =
+          modifier.path && modifier.path.type === 'GlimmerPathExpression' && modifier.path.original;
+        if (!modName) continue;
+        if (isBlockParam(modName)) continue;
+        if (isJsScopeVariable(modifier)) continue;
+
+        const modResult = isRestricted(modName);
+        if (modResult.restricted) {
+          context.report({
+            node: modifier,
+            message:
+              modResult.message ||
+              `Cannot use disallowed helper, component or modifier '{{${modName}}}'`,
+          });
+        }
+      }
+    }
+
+    function trackBlockParams(node) {
+      if (node.blockParams && node.blockParams.length > 0) {
+        pushBlockParams(node.blockParams);
+      }
+    }
+
     return {
       GlimmerElementNode(node) {
         // For element nodes, check the raw tag against block params before dasherizing.
         if (node.tag && isBlockParam(node.tag)) {
-          // Track block params from element nodes (e.g. <Foo as |bar|>).
-          if (node.blockParams && node.blockParams.length > 0) {
-            pushBlockParams(node.blockParams);
-          }
+          trackBlockParams(node);
           return;
         }
 
         // In gjs/gts, skip if the tag resolves to a JS-scope variable (import, const, etc.)
         if (isJsScopeVariable(node)) {
-          if (node.blockParams && node.blockParams.length > 0) {
-            pushBlockParams(node.blockParams);
-          }
+          trackBlockParams(node);
           return;
         }
 
@@ -263,33 +291,8 @@ module.exports = {
           }
         }
 
-        // Track block params from element nodes (e.g. <Foo as |bar|>).
-        if (node.blockParams && node.blockParams.length > 0) {
-          pushBlockParams(node.blockParams);
-        }
-
-        // Check modifiers on the element
-        if (node.modifiers) {
-          for (const modifier of node.modifiers) {
-            const modName =
-              modifier.path &&
-              modifier.path.type === 'GlimmerPathExpression' &&
-              modifier.path.original;
-            if (!modName) continue;
-            if (isBlockParam(modName)) continue;
-            if (isJsScopeVariable(modifier)) continue;
-
-            const modResult = isRestricted(modName);
-            if (modResult.restricted) {
-              context.report({
-                node: modifier,
-                message:
-                  modResult.message ||
-                  `Cannot use disallowed helper, component or modifier '{{${modName}}}'`,
-              });
-            }
-          }
-        }
+        trackBlockParams(node);
+        checkElementModifiers(node);
       },
 
       'GlimmerElementNode:exit'(node) {