[Fix] importType: handle symlinked external modules whose realpath is outside node_modules

When resolve v2 realpaths symlinked packages, the resolved path may fall
outside `node_modules`, causing `isExternalPath` to misclassify them as
internal. Add `isInExternalModuleFolder` to walk up the directory tree and
check if the base module exists in any external module folder.

Author: ljharb

src/core/importType.js

@@ -1,4 +1,5 @@
 import { isAbsolute as nodeIsAbsolute, relative, resolve as nodeResolve } from 'path';
+import { statSync } from 'fs';
 import isCoreModule from 'is-core-module';
 
 import resolve from 'eslint-module-utils/resolve';
@@ -108,6 +109,31 @@ function isExternalLookingName(name) {
   return isModule(name) || isScoped(name);
 }
 
+function isInExternalModuleFolder(name, context) {
+  const packagePath = getContextPackagePath(context);
+  const { settings } = context;
+  const folders = settings && settings['import/external-module-folders'] || ['node_modules'];
+  const base = baseModule(name);
+
+  return folders.some((folder) => {
+    if (nodeIsAbsolute(folder)) {
+      try { statSync(nodeResolve(folder, base)); return true; } catch (e) { return false; }
+    }
+    // Walk up directories checking each external module folder
+    let dir = packagePath;
+    while (true) {
+      try {
+        statSync(nodeResolve(dir, folder, base));
+        return true;
+      } catch (e) { /* continue */ }
+      const parent = nodeResolve(dir, '..');
+      if (parent === dir) { break; }
+      dir = parent;
+    }
+    return false;
+  });
+}
+
 function typeTest(name, context, path) {
   const { settings } = context;
   if (isInternalRegexMatch(name, settings)) { return 'internal'; }
@@ -117,6 +143,9 @@ function typeTest(name, context, path) {
   if (isIndex(name, settings, path)) { return 'index'; }
   if (isRelativeToSibling(name, settings, path)) { return 'sibling'; }
   if (isExternalPath(path, context)) { return 'external'; }
+  // Symlinked external modules may realpath outside node_modules.
+  // Check if the base module exists in any external module folder.
+  if (path && isExternalLookingName(name) && isInExternalModuleFolder(name, context)) { return 'external'; }
   if (isInternalPath(path, context)) { return 'internal'; }
   if (isExternalLookingName(name)) { return 'external'; }
   return 'unknown';

tests/src/core/importType.js

@@ -48,6 +48,15 @@ describe('importType(name)', function () {
     expect(importType('@eslint/import-test-order-redirect-scoped/module', context)).to.equal('external');
   });
 
+  it("should return 'external' for symlinked modules in node_modules even if realpath is outside", function () {
+    // eslint-import-test-order-redirect is a symlink in node_modules/ pointing
+    // to tests/files/order-redirect/. When resolve follows symlinks (the default),
+    // the resolved path is under tests/files/, not node_modules/. The module should
+    // still be classified as external because it exists in node_modules/.
+    expect(importType('eslint-import-test-order-redirect', context)).to.equal('external');
+    expect(importType('@eslint/import-test-order-redirect-scoped', context)).to.equal('external');
+  });
+
   it("should return 'internal' for non-builtins resolved outside of node_modules", function () {
     const pathContext = testContext({ 'import/resolver': { node: { paths: [pathToTestFiles] } } });
     expect(importType('importType', pathContext)).to.equal('internal');