feat: implement extensions autofix

Author: stephenjason89

src/rules/extensions.js

@@ -1,5 +1,5 @@
 import path from 'path';
-
+import fs from 'fs';
 import minimatch from 'minimatch';
 import resolve from 'eslint-module-utils/resolve';
 import { isBuiltIn, isExternalModule, isScoped } from '../core/importType';
@@ -91,13 +91,14 @@ function buildProperties(context) {
 
 module.exports = {
   meta: {
-    type: 'suggestion',
+    type: 'problem',
     docs: {
-      category: 'Style guide',
-      description: 'Ensure consistent use of file extension within the import path.',
+      description: 'Enforce that import statements either always include or never include allowed file extensions.',
+      category: 'Static Analysis',
+      recommended: false,
       url: docsUrl('extensions'),
     },
-
+    fixable: 'code',
     schema: {
       anyOf: [
         {
@@ -133,6 +134,12 @@ module.exports = {
         },
       ],
     },
+    messages: {
+      missingExtension:
+        'Missing file extension for "{{importPath}}" (expected {{expected}}).',
+      unexpectedExtension:
+        'Unexpected file extension "{{extension}}" in import of "{{importPath}}".',
+    },
   },
 
   create(context) {
@@ -151,9 +158,14 @@ module.exports = {
       return getModifier(extension) === 'never';
     }
 
-    function isResolvableWithoutExtension(file) {
-      const extension = path.extname(file);
-      const fileWithoutExtension = file.slice(0, -extension.length);
+    // Updated: This helper now determines resolvability based on the passed options.
+    // If the configured option for the extension is "never", we return true immediately.
+    function isResolvableWithoutExtension(file, ext) {
+      if (isUseOfExtensionForbidden(ext)) {
+        return true;
+      }
+      const fileExt = path.extname(file);
+      const fileWithoutExtension = file.slice(0, -fileExt.length);
       const resolvedFileWithoutExtension = resolve(fileWithoutExtension, context);
 
       return resolvedFileWithoutExtension === resolve(file, context);
@@ -177,11 +189,19 @@ module.exports = {
       }
     }
 
+    function getCandidateExtension(importPath, currentDir) {
+      const basePath = path.resolve(currentDir, importPath);
+      const keys = Object.keys(props.pattern);
+      const valid = keys.filter((key) => fs.existsSync(`${basePath}.${key}`));
+      return valid.length === 1 ? `.${valid[0]}` : null;
+    }
+
     function checkFileExtension(source, node) {
       // bail if the declaration doesn't have a source, e.g. "export { foo };", or if it's only partially typed like in an editor
       if (!source || !source.value) { return; }
 
       const importPathWithQueryString = source.value;
+      const currentDir = path.dirname(context.getFilename());
 
       // If not undefined, the user decided if rules are enforced on this import
       const overrideAction = computeOverrideAction(
@@ -203,10 +223,7 @@ module.exports = {
       if (!overrideAction && isExternalRootModule(importPath)) { return; }
 
       const resolvedPath = resolve(importPath, context);
-
-      // get extension from resolved path, if possible.
-      // for unresolved, use source value.
-      const extension = path.extname(resolvedPath || importPath).substring(1);
+      const extensionWithDot = path.extname(resolvedPath || importPath);
 
       // determine if this is a module
       const isPackage = isExternalModule(
@@ -215,23 +232,38 @@ module.exports = {
         context,
       ) || isScoped(importPath);
 
-      if (!extension || !importPath.endsWith(`.${extension}`)) {
+      // Case 1: Missing extension.
+      if (!extensionWithDot || !importPath.endsWith(extensionWithDot)) {
         // ignore type-only imports and exports
         if (!props.checkTypeImports && (node.importKind === 'type' || node.exportKind === 'type')) { return; }
-        const extensionRequired = isUseOfExtensionRequired(extension, !overrideAction && isPackage);
-        const extensionForbidden = isUseOfExtensionForbidden(extension);
-        if (extensionRequired && !extensionForbidden) {
+        const candidate = getCandidateExtension(importPath, currentDir);
+        if (candidate && isUseOfExtensionRequired(candidate.replace(/^\./, ''), isPackage)) {
           context.report({
-            node: source,
-            message:
-              `Missing file extension ${extension ? `"${extension}" ` : ''}for "${importPathWithQueryString}"`,
+            node,
+            messageId: 'missingExtension',
+            data: {
+              importPath: importPathWithQueryString,
+              expected: candidate,
+            },
+            fix(fixer) {
+              return fixer.replaceText(source, JSON.stringify(importPathWithQueryString + candidate));
+            },
           });
         }
-      } else if (extension) {
-        if (isUseOfExtensionForbidden(extension) && isResolvableWithoutExtension(importPath)) {
+      } else {
+        // Case 2: Unexpected extension provided.
+        const extension = extensionWithDot.substring(1);
+        if (isUseOfExtensionForbidden(extension) && isResolvableWithoutExtension(importPath, extension)) {
           context.report({
             node: source,
-            message: `Unexpected use of file extension "${extension}" for "${importPathWithQueryString}"`,
+            messageId: 'unexpectedExtension',
+            data: {
+              extension,
+              importPath: importPathWithQueryString,
+            },
+            fix(fixer) {
+              return fixer.replaceText(source, JSON.stringify(importPath.slice(0, -extensionWithDot.length)));
+            },
           });
         }
       }