handle renaming

This is very similar to the existing aliasing feature. Previously, aliasing happened both during our analysis to decide which imports to handle and then again inside webpack. Now we handle it all once during analysis and emit imports for webpack that are already aliased. This means webpack doesn't need to learn about how renamed-modules too, which don't perfectly follow aliasing rules.

packages/ember-auto-import/ts/auto-import.ts

@@ -2,7 +2,7 @@ import Splitter from './splitter';
 import { Bundler, debugBundler } from './bundler';
 import Analyzer from './analyzer';
 import type { TreeType } from './analyzer';
-import Package from './package';
+import Package, { V2AddonResolver } from './package';
 import BroccoliDebug from 'broccoli-debug';
 import BundleConfig from './bundle-config';
 import type { Node } from 'broccoli-node-api';
@@ -12,6 +12,7 @@ import {
   AppInstance,
   findTopmostAddon,
   isDeepAddonInstance,
+  PackageCache,
 } from '@embroider/shared-internals';
 import WebpackBundler from './webpack';
 import { Memoize } from 'typescript-memoize';
@@ -49,6 +50,7 @@ export interface AutoImportSharedAPI {
 
 export default class AutoImport implements AutoImportSharedAPI {
   private packages: Set<Package> = new Set();
+  private packageCache: PackageCache;
   private env: 'development' | 'test' | 'production';
   private consoleWrite: (msg: string) => void;
   private analyzers: Map<Analyzer, Package> = new Map();
@@ -67,7 +69,13 @@ export default class AutoImport implements AutoImportSharedAPI {
 
   constructor(addonInstance: AddonInstance) {
     let topmostAddon = findTopmostAddon(addonInstance);
-    this.packages.add(Package.lookupParentOf(topmostAddon));
+    this.packageCache = PackageCache.shared(
+      'ember-auto-import',
+      topmostAddon.project.root
+    );
+    this.packages.add(
+      Package.lookupParentOf(topmostAddon, this.v2AddonResolver)
+    );
     let host = topmostAddon.app;
 
     this.installAppFilter(host);
@@ -108,7 +116,7 @@ export default class AutoImport implements AutoImportSharedAPI {
     treeType?: TreeType,
     supportsFastAnalyzer?: true
   ) {
-    let pack = Package.lookupParentOf(addon);
+    let pack = Package.lookupParentOf(addon, this.v2AddonResolver);
     this.packages.add(pack);
     let analyzer = new Analyzer(
       debugTree(tree, `preprocessor:input-${this.analyzers.size}`),
@@ -124,17 +132,55 @@ export default class AutoImport implements AutoImportSharedAPI {
     this.v2Addons.set(packageName, packageRoot);
   }
 
-  private makeBundler(allAppTree: Node): Bundler {
-    // this is a concession to compatibility with ember-cli's treeForApp
-    // merging. Addons are allowed to inject modules into the app, and it's
-    // extremely common that those modules want to import from the addons
-    // themselves, even though this jumps arbitrarily many levels in the
-    // dependency graph.
-    //
-    // Since we handle v2 addons, we need to make sure all v2 addons function as
-    // "dependencies" of the app even though they're not really.
-    this.rootPackage.magicDeps = this.v2Addons;
+  get v2AddonResolver(): V2AddonResolver {
+    return {
+      hasV2Addon: (name: string): boolean => {
+        return this.v2Addons.has(name);
+      },
+
+      v2AddonRoot: (name: string): string | undefined => {
+        return this.v2Addons.get(name);
+      },
+
+      handleRenaming: (name: string): string => {
+        let hit = this.renamedModules().get(name);
+        if (hit) {
+          return hit;
+        }
+        hit = this.renamedModules().get(name + '.js');
+        if (hit) {
+          return hit;
+        }
+        hit = this.renamedModules().get(name + '/index.js');
+        if (hit) {
+          return hit;
+        }
+        return name;
+      },
+    };
+  }
 
+  private _renamedModules: Map<string, string> | undefined;
+
+  private renamedModules(): Map<string, string> {
+    if (!this._renamedModules) {
+      this._renamedModules = new Map();
+      for (let packageRoot of this.v2Addons.values()) {
+        let pkg = this.packageCache.get(packageRoot);
+        if (pkg.isV2Addon()) {
+          let renamedModules = pkg.meta['renamed-modules'];
+          if (renamedModules) {
+            for (let [from, to] of Object.entries(renamedModules)) {
+              this._renamedModules.set(from, to);
+            }
+          }
+        }
+      }
+    }
+    return this._renamedModules;
+  }
+
+  private makeBundler(allAppTree: Node): Bundler {
     // The Splitter takes the set of imports from the Analyzer and
     // decides which ones to include in which bundles
     let splitter = new Splitter({
@@ -166,7 +212,6 @@ export default class AutoImport implements AutoImportSharedAPI {
       consoleWrite: this.consoleWrite,
       bundles: this.bundles,
       webpack,
-      v2Addons: this.v2Addons,
       rootPackage: this.rootPackage,
     });
   }

packages/ember-auto-import/ts/bundler.ts

@@ -15,7 +15,6 @@ export interface BundlerOptions {
   packages: Set<Package>;
   bundles: BundleConfig;
   webpack: typeof webpack;
-  v2Addons: Map<string, string>;
   rootPackage: Package;
 }
 

packages/ember-auto-import/ts/package.ts

@@ -46,9 +46,9 @@ export interface Options {
 
 export interface DepResolution {
   type: 'package';
-  path: string;
   packageName: string;
   packageRoot: string;
+  resolvedSpecifier: string;
 }
 
 interface LocalResolution {
@@ -71,6 +71,12 @@ type Resolution =
   | URLResolution
   | ImpreciseResolution;
 
+export type V2AddonResolver = {
+  hasV2Addon(name: string): boolean;
+  v2AddonRoot(name: string): string | undefined;
+  handleRenaming(name: string): string;
+};
+
 export default class Package {
   public name: string;
   public root: string;
@@ -87,21 +93,26 @@ export default class Package {
   private pkgGeneration: number;
   private pkgCache: any;
   private macrosConfig: MacrosConfig | undefined;
+  private extraResolve: V2AddonResolver;
 
-  static lookupParentOf(child: AddonInstance): Package {
+  static lookupParentOf(
+    child: AddonInstance,
+    extraResolve: V2AddonResolver
+  ): Package {
     if (!parentCache.has(child)) {
       let pkg = packageCache.get(child.parent);
       if (!pkg) {
-        pkg = new this(child);
+        pkg = new this(child, extraResolve);
         packageCache.set(child.parent, pkg);
       }
       parentCache.set(child, pkg);
     }
     return parentCache.get(child)!;
   }
 
-  constructor(child: AddonInstance) {
+  constructor(child: AddonInstance, extraResolve: V2AddonResolver) {
     this.name = child.parent.pkg.name;
+    this.extraResolve = extraResolve;
 
     if (isDeepAddonInstance(child)) {
       this.root = this.pkgRoot = child.parent.root;
@@ -233,19 +244,13 @@ export default class Package {
     return `${this.name}/${this.isAddon ? 'addon' : 'app'}`;
   }
 
-  // extra dependencies that must be treated as if they were really dependencies
-  // of this package. sigh.
-  //
-  // maps from packageName to packageRoot
-  magicDeps: Map<string, string> | undefined;
-
   hasDependency(name: string): boolean {
     let { pkg } = this;
     return Boolean(
       pkg.dependencies?.[name] ||
         pkg.devDependencies?.[name] ||
         pkg.peerDependencies?.[name] ||
-        this.magicDeps?.get(name)
+        this.extraResolve.hasV2Addon(name)
     );
   }
 
@@ -269,7 +274,7 @@ export default class Package {
     return Boolean(
       pkg.dependencies?.[name] ||
         pkg.peerDependencies?.[name] ||
-        this.magicDeps?.has(name)
+        this.extraResolve.hasV2Addon(name)
     );
   }
 
@@ -319,7 +324,7 @@ export default class Package {
         break;
     }
 
-    let path = this.aliasFor(importedPath);
+    let path = this.extraResolve.handleRenaming(this.aliasFor(importedPath));
     let packageName = getPackageName(path);
     if (!packageName) {
       // this can only happen if the user supplied an alias that points at a
@@ -344,9 +349,9 @@ export default class Package {
       ) {
         return {
           type: 'package',
-          path: localPath,
           packageName: this.name,
           packageRoot: join(this.root, 'app'),
+          resolvedSpecifier: path,
         };
       }
     }
@@ -368,7 +373,7 @@ export default class Package {
     }
 
     if (!packageRoot) {
-      packageRoot = this.magicDeps?.get(packageName);
+      packageRoot = this.extraResolve.v2AddonRoot(packageName);
     }
 
     if (packageRoot == null) {
@@ -384,9 +389,9 @@ export default class Package {
     this.assertAllowedDependency(packageName, fromPath);
     return {
       type: 'package',
-      path,
       packageName,
       packageRoot,
+      resolvedSpecifier: path,
     };
   }
 

packages/ember-auto-import/ts/splitter.ts

@@ -10,7 +10,8 @@ import { satisfies } from 'semver';
 const debug = makeDebug('ember-auto-import:splitter');
 
 export interface ResolvedImport {
-  specifier: string;
+  requestedSpecifier: string;
+  resolvedSpecifier: string;
   packageName: string;
   packageRoot: string;
   importedBy: LiteralImport[];
@@ -115,7 +116,8 @@ export default class Splitter {
       seenAlready.importedBy.push(imp);
     } else {
       targets.set(imp.specifier, {
-        specifier: imp.specifier,
+        requestedSpecifier: imp.specifier,
+        resolvedSpecifier: target.resolvedSpecifier,
         packageName: target.packageName,
         packageRoot: target.packageRoot,
         importedBy: [imp],
@@ -284,9 +286,11 @@ export default class Splitter {
   }
 
   private sortBundle(bundle: BundleDependencies) {
-    bundle.staticImports.sort((a, b) => a.specifier.localeCompare(b.specifier));
+    bundle.staticImports.sort((a, b) =>
+      a.requestedSpecifier.localeCompare(b.requestedSpecifier)
+    );
     bundle.dynamicImports.sort((a, b) =>
-      a.specifier.localeCompare(b.specifier)
+      a.requestedSpecifier.localeCompare(b.requestedSpecifier)
     );
     bundle.dynamicTemplateImports.sort((a, b) =>
       a.cookedQuasis[0].localeCompare(b.cookedQuasis[0])
@@ -329,7 +333,8 @@ class LazyPrintDeps {
 
   private describeResolvedImport(imp: ResolvedImport) {
     return {
-      specifier: imp.specifier,
+      requestedSpecifier: imp.requestedSpecifier,
+      resolvedSpecifier: imp.resolvedSpecifier,
       packageRoot: imp.packageRoot,
       importedBy: imp.importedBy.map(this.describeImport.bind(this)),
     };