fix: false positives with violation reporting helper function in no-missing-message-ids and no-unused-message-ids rules

Author: bmish

lib/rules/no-unused-message-ids.js

@@ -120,7 +120,8 @@ module.exports = {
 
           if (
             values.length === 0 ||
-            values.some((val) => val.type !== 'Literal')
+            values.some((val) => val.type !== 'Literal') ||
+            utils.isVariableFromParameter(node.value, scopeManager)
           ) {
             // When a dynamic messageId is used and we can't detect its value, disable the rule to avoid false positives.
             hasSeenUnknownMessageId = true;

lib/utils.js

@@ -888,4 +888,19 @@ module.exports = {
       return [];
     });
   },
+
+  /**
+   * Check whether a variable's definition is from a function parameter.
+   * @param {Node} node - the Identifier node for the variable.
+   * @param {ScopeManager} scopeManager
+   * @returns {boolean} whether the variable comes from a function parameter
+   */
+  isVariableFromParameter(node, scopeManager) {
+    const variable = findVariable(
+      scopeManager.acquire(node) || scopeManager.globalScope,
+      node
+    );
+
+    return variable?.defs[0]?.type === 'Parameter';
+  },
 };

tests/lib/rules/no-missing-message-ids.js

@@ -196,6 +196,48 @@ ruleTester.run('no-missing-message-ids', rule, {
         }
       };
     `,
+    // Helper function with messageId parameter, outside rule.
+    `
+      function report(node, messageId) {
+        context.report({node, messageId});
+      }
+      module.exports = {
+        meta: { messages: { foo: 'hello' } },
+        create(context) {
+          report(node, 'foo');
+        }
+      };
+    `,
+    // Helper function with messageId parameter, inside rule, with parameter reassignment.
+    `
+      module.exports = {
+        meta: { messages: { foo: 'hello', bar: 'world' } },
+        create(context) {
+          function report(node, messageId) {
+            if (foo) {
+              messageId = 'bar';
+            }
+            context.report({node, messageId});
+          }
+          report(node, 'foo');
+        }
+      };
+    `,
+    // Helper function with messageId parameter, inside rule, with missing messageId.
+    // TODO: this should be an invalid test case because a non-existent `messageId` is used.
+    // Eventually, we should be able to detect what values are passed to this function for its `messageId` parameter.
+    `
+      module.exports = {
+        meta: { messages: { foo: 'hello' } },
+        create(context) {
+          function report(node, messageId) {
+            context.report({node, messageId});
+          }
+          report(node, 'foo');
+          report(node, 'bar');
+        }
+      };
+    `,
   ],
 
   invalid: [
@@ -287,5 +329,30 @@ ruleTester.run('no-missing-message-ids', rule, {
         },
       ],
     },
+    {
+      // Helper function with messageId parameter, inside rule, with missing messageId due to parameter reassignment.
+      code: `
+
+        module.exports = {
+          meta: { messages: { foo: 'hello' } },
+          create(context) {
+            function report(node, messageId) {
+              if (foo) {
+                messageId = 'bar';
+              }
+              context.report({node, messageId});
+            }
+            report(node, 'foo');
+          }
+        };
+      `,
+      errors: [
+        {
+          messageId: 'missingMessage',
+          data: { messageId: 'bar' },
+          type: 'Literal',
+        },
+      ],
+    },
   ],
 });

tests/lib/rules/no-unused-message-ids.js

@@ -227,6 +227,50 @@ ruleTester.run('no-unused-message-ids', rule, {
         create(context) {}
       };
     `,
+    // Helper function messageId parameter, outside rule.
+    `
+      function reportFoo(node, messageId) {
+        context.report({ node, messageId });
+      }
+      module.exports = {
+        meta: { messages: { foo: 'hello', bar: 'world', baz: 'planet' } },
+        create(context) {
+          reportFoo(node, 'foo');
+          reportFoo(node, 'bar');
+          reportFoo(node, 'baz');
+        }
+      };
+    `,
+    // Helper function with messageId parameter, inside rule, parameter reassignment.
+    `
+      module.exports = {
+        meta: { messages: { foo: 'hello', bar: 'world', baz: 'planet' } },
+        create(context) {
+          function reportFoo(node, messageId) {
+            if (foo) {
+              messageId = 'baz';
+            }
+            context.report({ node, messageId });
+          }
+          reportFoo(node, 'foo');
+          reportFoo(node, 'bar');
+        }
+      };
+    `,
+    // Helper function with messageId parameter, outside rule, with an unused messageId.
+    // TODO: this should be an invalid test case because a messageId is unused.
+    // Eventually, we should be able to detect what values are passed to this function for its messageId parameter.
+    `
+      function reportFoo(node, messageId) {
+        context.report({ node, messageId });
+      }
+      module.exports = {
+        meta: { messages: { foo: 'hello', bar: 'world' } },
+        create(context) {
+          reportFoo(node, 'foo');
+        }
+      };
+    `,
   ],
 
   invalid: [
@@ -363,7 +407,7 @@ ruleTester.run('no-unused-message-ids', rule, {
           context.report({ node, messageId });
         }
         module.exports = {
-          meta: { messages: { foo: 'hello world' } },
+          meta: { messages: { foo: 'hello world', bar: 'baz' } },
           create(context) {
             reportFoo(node);
           }