@sgfe/eslint-plugin-sg 1.0.3

package/lib/rules/no-only-tests.js

@@ -0,0 +1,99 @@
+'use strict';
+
+const utils = require('../utils');
+const {
+  isCommaToken,
+  isOpeningBraceToken,
+  isClosingBraceToken,
+} = require('eslint-utils');
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'disallow the test case property `only`',
+      category: 'Tests',
+      recommended: true,
+      url: 'https://github.com/eslint-community/eslint-plugin-eslint-plugin/tree/HEAD/docs/rules/no-only-tests.md',
+    },
+    hasSuggestions: true,
+    schema: [],
+    messages: {
+      foundOnly:
+        'The test case property `only` can be used during development, but should not be checked-in, since it prevents all the tests from running.',
+      removeOnly: 'Remove `only`.',
+    },
+  },
+
+  create(context) {
+    return {
+      Program(ast) {
+        for (const testRun of utils.getTestInfo(context, ast)) {
+          for (const test of [...testRun.valid, ...testRun.invalid]) {
+            if (test.type === 'ObjectExpression') {
+              // Test case object: { code: 'const x = 123;', ... }
+
+              const onlyProperty = test.properties.find(
+                (property) =>
+                  property.type === 'Property' &&
+                  property.key.type === 'Identifier' &&
+                  property.key.name === 'only' &&
+                  property.value.type === 'Literal' &&
+                  property.value.value
+              );
+
+              if (onlyProperty) {
+                context.report({
+                  node: onlyProperty,
+                  messageId: 'foundOnly',
+                  suggest: [
+                    {
+                      messageId: 'removeOnly',
+                      *fix(fixer) {
+                        const sourceCode =
+                          context.sourceCode || context.getSourceCode(); // TODO: just use context.sourceCode when dropping eslint < v9
+
+                        const tokenBefore =
+                          sourceCode.getTokenBefore(onlyProperty);
+                        const tokenAfter =
+                          sourceCode.getTokenAfter(onlyProperty);
+                        if (
+                          (isCommaToken(tokenBefore) &&
+                            isCommaToken(tokenAfter)) || // In middle of properties
+                          (isOpeningBraceToken(tokenBefore) &&
+                            isCommaToken(tokenAfter)) // At beginning of properties
+                        ) {
+                          yield fixer.remove(tokenAfter); // Remove extra comma.
+                        }
+                        if (
+                          isCommaToken(tokenBefore) &&
+                          isClosingBraceToken(tokenAfter)
+                        ) {
+                          // At end of properties
+                          yield fixer.remove(tokenBefore); // Remove extra comma.
+                        }
+
+                        yield fixer.remove(onlyProperty);
+                      },
+                    },
+                  ],
+                });
+              }
+            } else if (
+              test.type === 'CallExpression' &&
+              test.callee.type === 'MemberExpression' &&
+              test.callee.object.type === 'Identifier' &&
+              test.callee.object.name === 'RuleTester' &&
+              test.callee.property.type === 'Identifier' &&
+              test.callee.property.name === 'only'
+            ) {
+              // RuleTester.only('const x = 123;');
+              context.report({ node: test.callee, messageId: 'foundOnly' });
+            }
+          }
+        }
+      },
+    };
+  },
+};

package/lib/rules/no-property-in-node.js

@@ -0,0 +1,86 @@
+'use strict';
+
+const typedNodeSourceFileTesters = [
+  /@types[/\\]estree[/\\]index\.d\.ts/,
+  /@typescript-eslint[/\\]types[/\\]dist[/\\]generated[/\\]ast-spec\.d\.ts/,
+];
+
+/**
+ * Given a TypeScript type, determines whether the type appears to be for a known
+ * AST type from the typings of @typescript-eslint/types or estree.
+ * We check based on two rough conditions:
+ * - The type has a 'kind' property (as AST node types all do)
+ * - The type is declared in one of those package's .d.ts types
+ *
+ * @example
+ * ```
+ * module.exports = {
+ *  create(context) {
+ *    BinaryExpression(node) {
+ *      const type = services.getTypeAtLocation(node.right);
+ *      //    ^^^^
+ *      // This variable's type will be TSESTree.BinaryExpression
+ *    }
+ *  }
+ * }
+ * ```
+ *
+ * @param {import('typescript').Type} type
+ * @returns Whether the type seems to include a known ESTree or TSESTree AST node.
+ */
+function isAstNodeType(type) {
+  return (type.types || [type])
+    .filter((typePart) => typePart.getProperty('type'))
+    .flatMap(
+      (typePart) => (typePart.symbol && typePart.symbol.declarations) || []
+    )
+    .some((declaration) => {
+      const fileName = declaration.getSourceFile().fileName;
+      return (
+        fileName &&
+        typedNodeSourceFileTesters.some((tester) => tester.test(fileName))
+      );
+    });
+}
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'disallow using `in` to narrow node types instead of looking at properties',
+      category: 'Rules',
+      recommended: false,
+      requiresTypeChecking: true,
+      url: 'https://github.com/eslint-community/eslint-plugin-eslint-plugin/tree/HEAD/docs/rules/no-property-in-node.md',
+    },
+    schema: [],
+    messages: {
+      in: 'Prefer checking specific node properties instead of a broad `in`.',
+    },
+  },
+
+  create(context) {
+    return {
+      'BinaryExpression[operator=in]'(node) {
+        // TODO: Switch this to ESLintUtils.getParserServices with typescript-eslint@>=6
+        // https://github.com/eslint-community/eslint-plugin-eslint-plugin/issues/269
+        const services = (context.sourceCode || context).parserServices;
+        if (!services.program) {
+          throw new Error(
+            'You have used a rule which requires parserServices to be generated. You must therefore provide a value for the "parserOptions.project" property for @typescript-eslint/parser.'
+          );
+        }
+
+        const checker = services.program.getTypeChecker();
+        const tsNode = services.esTreeNodeToTSNodeMap.get(node.right);
+        const type = checker.getTypeAtLocation(tsNode);
+
+        if (isAstNodeType(type)) {
+          context.report({ messageId: 'in', node });
+        }
+      },
+    };
+  },
+};

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

@@ -0,0 +1,139 @@
+'use strict';
+
+const utils = require('../utils');
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'disallow unused `messageId`s in `meta.messages`',
+      category: 'Rules',
+      recommended: true,
+      url: 'https://github.com/eslint-community/eslint-plugin-eslint-plugin/tree/HEAD/docs/rules/no-unused-message-ids.md',
+    },
+    fixable: null,
+    schema: [],
+    messages: {
+      unusedMessage: 'The messageId "{{messageId}}" is never used.',
+    },
+  },
+
+  create(context) {
+    const sourceCode = context.sourceCode || context.getSourceCode(); // TODO: just use context.sourceCode when dropping eslint < v9
+    const { scopeManager } = sourceCode;
+    const ruleInfo = utils.getRuleInfo(sourceCode);
+    if (!ruleInfo) {
+      return {};
+    }
+
+    const messageIdsUsed = new Set();
+    let contextIdentifiers;
+    let hasSeenUnknownMessageId = false;
+    let hasSeenViolationReport = false;
+
+    const messageIdNodes = utils.getMessageIdNodes(ruleInfo, scopeManager);
+    if (!messageIdNodes) {
+      // If we can't find `meta.messages`, disable the rule.
+      return {};
+    }
+
+    return {
+      Program(ast) {
+        contextIdentifiers = utils.getContextIdentifiers(scopeManager, ast);
+      },
+
+      'Program:exit'(ast) {
+        if (hasSeenUnknownMessageId || !hasSeenViolationReport) {
+          /*
+          Bail out when the rule is likely to have false positives.
+          - If we saw a dynamic/unknown messageId
+          - If we couldn't find any violation reporting code, likely because a helper function from an external file is handling this
+          */
+          return;
+        }
+
+        const scope = sourceCode.getScope?.(ast) || context.getScope(); // TODO: just use sourceCode.getScope() when we drop support for ESLint < 9.0.0
+
+        const messageIdNodesUnused = messageIdNodes.filter(
+          (node) => !messageIdsUsed.has(utils.getKeyName(node, scope))
+        );
+
+        // Report any messageIds that were never used.
+        for (const messageIdNode of messageIdNodesUnused) {
+          context.report({
+            node: messageIdNode,
+            messageId: 'unusedMessage',
+            data: {
+              messageId: utils.getKeyName(messageIdNode, scope),
+            },
+          });
+        }
+      },
+
+      CallExpression(node) {
+        // Check for messageId properties used in known calls to context.report();
+        if (
+          node.callee.type === 'MemberExpression' &&
+          contextIdentifiers.has(node.callee.object) &&
+          node.callee.property.type === 'Identifier' &&
+          node.callee.property.name === 'report'
+        ) {
+          const reportInfo = utils.getReportInfo(node, context);
+          if (!reportInfo) {
+            return;
+          }
+
+          hasSeenViolationReport = true;
+
+          const reportMessagesAndDataArray =
+            utils.collectReportViolationAndSuggestionData(reportInfo);
+          for (const { messageId } of reportMessagesAndDataArray.filter(
+            (obj) => obj.messageId
+          )) {
+            const values =
+              messageId.type === 'Literal'
+                ? [messageId]
+                : utils.findPossibleVariableValues(messageId, scopeManager);
+            if (
+              values.length === 0 ||
+              values.some((val) => val.type !== 'Literal')
+            ) {
+              // When a dynamic messageId is used and we can't detect its value, disable the rule to avoid false positives.
+              hasSeenUnknownMessageId = true;
+            }
+            values.forEach((val) => messageIdsUsed.add(val.value));
+          }
+        }
+      },
+
+      Property(node) {
+        // In order to reduce false positives, we will also check for messageId properties anywhere in the file.
+        // This is helpful especially in the event that helper functions are used for reporting violations.
+        if (node.key.type === 'Identifier' && node.key.name === 'messageId') {
+          hasSeenViolationReport = true;
+
+          const values =
+            node.value.type === 'Literal'
+              ? [node.value]
+              : utils.findPossibleVariableValues(node.value, scopeManager);
+
+          if (
+            values.length === 0 ||
+            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;
+          }
+
+          values.forEach((val) => messageIdsUsed.add(val.value));
+        }
+      },
+    };
+  },
+};

package/lib/rules/no-unused-placeholders.js

@@ -0,0 +1,127 @@
+/**
+ * @fileoverview Disallow unused placeholders in rule report messages
+ * @author 薛定谔的猫<hh_2013@foxmail.com>
+ */
+
+'use strict';
+
+const utils = require('../utils');
+const { getStaticValue } = require('eslint-utils');
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'disallow unused placeholders in rule report messages',
+      category: 'Rules',
+      recommended: true,
+      url: 'https://github.com/eslint-community/eslint-plugin-eslint-plugin/tree/HEAD/docs/rules/no-unused-placeholders.md',
+    },
+    fixable: null,
+    schema: [],
+    messages: {
+      placeholderUnused:
+        'The placeholder {{{{unusedKey}}}} is unused (does not exist in the actual message).',
+    },
+  },
+
+  create(context) {
+    const sourceCode = context.sourceCode || context.getSourceCode(); // TODO: just use context.sourceCode when dropping eslint < v9
+    const { scopeManager } = sourceCode;
+
+    let contextIdentifiers;
+
+    const ruleInfo = utils.getRuleInfo(sourceCode);
+    if (!ruleInfo) {
+      return {};
+    }
+    const messagesNode = utils.getMessagesNode(ruleInfo, scopeManager);
+
+    return {
+      Program(ast) {
+        contextIdentifiers = utils.getContextIdentifiers(scopeManager, ast);
+      },
+      CallExpression(node) {
+        const scope = sourceCode.getScope?.(node) || context.getScope(); // TODO: just use sourceCode.getScope() when we drop support for ESLint < 9.0.0
+        if (
+          node.callee.type === 'MemberExpression' &&
+          contextIdentifiers.has(node.callee.object) &&
+          node.callee.property.type === 'Identifier' &&
+          node.callee.property.name === 'report'
+        ) {
+          const reportInfo = utils.getReportInfo(node, context);
+          if (!reportInfo) {
+            return;
+          }
+
+          const reportMessagesAndDataArray =
+            utils.collectReportViolationAndSuggestionData(reportInfo);
+
+          if (messagesNode) {
+            // Check for any potential instances where we can use the messageId to fill in the message for convenience.
+            reportMessagesAndDataArray.forEach((obj) => {
+              if (
+                !obj.message &&
+                obj.messageId &&
+                obj.messageId.type === 'Literal' &&
+                typeof obj.messageId.value === 'string'
+              ) {
+                const correspondingMessage = utils.getMessageIdNodeById(
+                  obj.messageId.value,
+                  ruleInfo,
+                  scopeManager,
+                  scope
+                );
+                if (correspondingMessage) {
+                  obj.message = correspondingMessage.value;
+                }
+              }
+            });
+          }
+
+          for (const { message, data } of reportMessagesAndDataArray.filter(
+            (obj) => obj.message
+          )) {
+            const messageStaticValue = getStaticValue(message, scope);
+            if (
+              ((message.type === 'Literal' &&
+                typeof message.value === 'string') ||
+                (messageStaticValue &&
+                  typeof messageStaticValue.value === 'string')) &&
+              data &&
+              data.type === 'ObjectExpression'
+            ) {
+              const messageValue = message.value || messageStaticValue.value;
+              // https://github.com/eslint/eslint/blob/2874d75ed8decf363006db25aac2d5f8991bd969/lib/linter.js#L986
+              const PLACEHOLDER_MATCHER = /{{\s*([^{}]+?)\s*}}/g;
+              const placeholdersInMessage = new Set();
+
+              messageValue.replaceAll(
+                PLACEHOLDER_MATCHER,
+                (fullMatch, term) => {
+                  placeholdersInMessage.add(term);
+                }
+              );
+
+              data.properties.forEach((prop) => {
+                const key = utils.getKeyName(prop);
+                if (!placeholdersInMessage.has(key)) {
+                  context.report({
+                    node: prop,
+                    messageId: 'placeholderUnused',
+                    data: { unusedKey: key },
+                  });
+                }
+              });
+            }
+          }
+        }
+      },
+    };
+  },
+};

package/lib/rules/no-useless-token-range.js

@@ -0,0 +1,174 @@
+/**
+ * @fileoverview Disallow unnecessary calls to `sourceCode.getFirstToken()` and `sourceCode.getLastToken()`
+ * @author Teddy Katz
+ */
+
+'use strict';
+
+const utils = require('../utils');
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'disallow unnecessary calls to `sourceCode.getFirstToken()` and `sourceCode.getLastToken()`',
+      category: 'Rules',
+      recommended: true,
+      url: 'https://github.com/eslint-community/eslint-plugin-eslint-plugin/tree/HEAD/docs/rules/no-useless-token-range.md',
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      useReplacement: "Use '{{replacementText}}' instead.",
+    },
+  },
+
+  create(context) {
+    const sourceCode = context.sourceCode || context.getSourceCode(); // TODO: just use context.sourceCode when dropping eslint < v9
+
+    // ----------------------------------------------------------------------
+    // Helpers
+    // ----------------------------------------------------------------------
+
+    /**
+     * Determines whether a second argument to getFirstToken or getLastToken changes the output of the function.
+     * This occurs when the second argument exists and is not an object literal, or has keys other than `includeComments`.
+     * @param {ASTNode} arg The second argument to `sourceCode.getFirstToken()` or `sourceCode.getLastToken()`
+     * @returns {boolean} `true` if the argument affects the output of getFirstToken or getLastToken
+     */
+    function affectsGetTokenOutput(arg) {
+      if (!arg) {
+        return false;
+      }
+      if (arg.type !== 'ObjectExpression') {
+        return true;
+      }
+      return (
+        arg.properties.length >= 2 ||
+        (arg.properties.length === 1 &&
+          (utils.getKeyName(arg.properties[0]) !== 'includeComments' ||
+            arg.properties[0].value.type !== 'Literal'))
+      );
+    }
+
+    /**
+     * Determines whether a node is a MemberExpression that accesses the `range` property
+     * @param {ASTNode} node The node
+     * @returns {boolean} `true` if the node is a MemberExpression that accesses the `range` property
+     */
+    function isRangeAccess(node) {
+      return (
+        node.type === 'MemberExpression' &&
+        node.property.type === 'Identifier' &&
+        node.property.name === 'range'
+      );
+    }
+
+    /**
+     * Determines whether a MemberExpression accesses the `start` property (either `.range[0]` or `.start`).
+     * Note that this will also work correctly if the `.range` MemberExpression is passed.
+     * @param {ASTNode} memberExpression The MemberExpression node to check
+     * @returns {boolean} `true` if this node accesses either `.range[0]` or `.start`
+     */
+    function isStartAccess(memberExpression) {
+      if (
+        isRangeAccess(memberExpression) &&
+        memberExpression.parent.type === 'MemberExpression'
+      ) {
+        return isStartAccess(memberExpression.parent);
+      }
+      return (
+        (memberExpression.property.type === 'Identifier' &&
+          memberExpression.property.name === 'start') ||
+        (memberExpression.computed &&
+          memberExpression.property.type === 'Literal' &&
+          memberExpression.property.value === 0 &&
+          isRangeAccess(memberExpression.object))
+      );
+    }
+
+    /**
+     * Determines whether a MemberExpression accesses the `start` property (either `.range[1]` or `.end`).
+     * Note that this will also work correctly if the `.range` MemberExpression is passed.
+     * @param {ASTNode} memberExpression The MemberExpression node to check
+     * @returns {boolean} `true` if this node accesses either `.range[1]` or `.end`
+     */
+    function isEndAccess(memberExpression) {
+      if (
+        isRangeAccess(memberExpression) &&
+        memberExpression.parent.type === 'MemberExpression'
+      ) {
+        return isEndAccess(memberExpression.parent);
+      }
+      return (
+        (memberExpression.property.type === 'Identifier' &&
+          memberExpression.property.name === 'end') ||
+        (memberExpression.computed &&
+          memberExpression.property.type === 'Literal' &&
+          memberExpression.property.value === 1 &&
+          isRangeAccess(memberExpression.object))
+      );
+    }
+
+    // ----------------------------------------------------------------------
+    // Public
+    // ----------------------------------------------------------------------
+
+    return {
+      'Program:exit'(ast) {
+        [...utils.getSourceCodeIdentifiers(sourceCode.scopeManager, ast)]
+          .filter(
+            (identifier) =>
+              identifier.parent.type === 'MemberExpression' &&
+              identifier.parent.object === identifier &&
+              identifier.parent.property.type === 'Identifier' &&
+              identifier.parent.parent.type === 'CallExpression' &&
+              identifier.parent === identifier.parent.parent.callee &&
+              identifier.parent.parent.arguments.length <= 2 &&
+              !affectsGetTokenOutput(identifier.parent.parent.arguments[1]) &&
+              identifier.parent.parent.parent.type === 'MemberExpression' &&
+              identifier.parent.parent ===
+                identifier.parent.parent.parent.object &&
+              ((isStartAccess(identifier.parent.parent.parent) &&
+                identifier.parent.property.name === 'getFirstToken') ||
+                (isEndAccess(identifier.parent.parent.parent) &&
+                  identifier.parent.property.name === 'getLastToken'))
+          )
+          .forEach((identifier) => {
+            const fullRangeAccess = isRangeAccess(
+              identifier.parent.parent.parent
+            )
+              ? identifier.parent.parent.parent.parent
+              : identifier.parent.parent.parent;
+            const replacementText =
+              sourceCode.text.slice(
+                fullRangeAccess.range[0],
+                identifier.parent.parent.range[0]
+              ) +
+              sourceCode.getText(identifier.parent.parent.arguments[0]) +
+              sourceCode.text.slice(
+                identifier.parent.parent.range[1],
+                fullRangeAccess.range[1]
+              );
+            context.report({
+              node: identifier.parent.parent,
+              messageId: 'useReplacement',
+              data: { replacementText },
+              fix(fixer) {
+                return fixer.replaceText(
+                  identifier.parent.parent,
+                  sourceCode.getText(identifier.parent.parent.arguments[0])
+                );
+              },
+            });
+          });
+      },
+    };
+  },
+};