metro 0.63.0 → 0.64.0

package/src/ModuleGraph/worker/collectDependencies.js.flow

@@ -10,6 +10,7 @@
 
 'use strict';
 
+const invariant = require('invariant');
 const nullthrows = require('nullthrows');
 
 const generate = require('@babel/generator').default;
@@ -17,101 +18,114 @@ const template = require('@babel/template').default;
 const traverse = require('@babel/traverse').default;
 const types = require('@babel/types');
 
-import type {Ast} from '@babel/core';
+const {isImport} = types;
+
+import type {NodePath} from '@babel/traverse';
+import type {CallExpression, Identifier, StringLiteral} from '@babel/types';
 import type {
   AllowOptionalDependencies,
   AsyncDependencyType,
 } from 'metro/src/DeltaBundler/types.flow.js';
 
-opaque type Identifier = any;
-opaque type Path = any;
-
-type DepOptions = {|
-  +prefetchOnly: boolean,
-  +jsResource?: boolean,
-  +isOptional?: boolean,
-|};
+type ImportDependencyOptions = $ReadOnly<{
+  asyncType: AsyncDependencyType,
+  jsResource?: boolean,
+  splitCondition?: NodePath<>,
+}>;
 
-type InternalDependency<D> = {|
-  +data: D,
-  +name: string,
-|};
+export type Dependency<TSplitCondition> = $ReadOnly<{
+  data: DependencyData<TSplitCondition>,
+  name: string,
+}>;
 
-type InternalDependencyData = {|
+type DependencyData<TSplitCondition> = $ReadOnly<{
+  // If null, then the dependency is synchronous.
+  // (ex. `require('foo')`)
   asyncType: AsyncDependencyType | null,
   isOptional?: boolean,
+  // If left unspecified, then the dependency is unconditionally split.
+  splitCondition?: TSplitCondition,
   locs: Array<BabelSourceLocation>,
-|};
+}>;
 
-type InternalDependencyInfo = {|
-  data: InternalDependencyData,
+export type MutableInternalDependency<TSplitCondition> = {
+  ...DependencyData<TSplitCondition>,
   index: number,
-|};
+  name: string,
+};
+
+export type InternalDependency<TSplitCondition> = $ReadOnly<
+  MutableInternalDependency<TSplitCondition>,
+>;
 
-type State = {|
-  asyncRequireModulePathStringLiteral: ?Identifier,
-  dependency: number,
+export type State<TSplitCondition> = {
+  asyncRequireModulePathStringLiteral: ?StringLiteral,
   dependencyCalls: Set<string>,
-  dependencyData: Map<string, InternalDependencyData>,
-  dependencyIndexes: Map<string, number>,
+  dependencyRegistry: ModuleDependencyRegistry<TSplitCondition>,
+  dependencyTransformer: DependencyTransformer<TSplitCondition>,
   dynamicRequires: DynamicRequiresBehavior,
   dependencyMapIdentifier: ?Identifier,
   keepRequireNames: boolean,
-  disableRequiresTransform: boolean,
   allowOptionalDependencies: AllowOptionalDependencies,
-|};
-
-export type Options = {|
-  +asyncRequireModulePath: string,
-  +dependencyMapName?: string,
-  +dynamicRequires: DynamicRequiresBehavior,
-  +inlineableCalls: $ReadOnlyArray<string>,
-  +keepRequireNames: boolean,
-  +disableRequiresTransform?: boolean,
-  +allowOptionalDependencies: AllowOptionalDependencies,
-|};
-
-export type CollectedDependencies = {|
-  +ast: Ast,
-  +dependencyMapName: string,
-  +dependencies: $ReadOnlyArray<Dependency>,
-|};
+};
 
-export type DependencyData = $ReadOnly<InternalDependencyData>;
+export type Options<TSplitCondition = void> = $ReadOnly<{
+  asyncRequireModulePath: string,
+  dependencyMapName?: string,
+  dynamicRequires: DynamicRequiresBehavior,
+  inlineableCalls: $ReadOnlyArray<string>,
+  keepRequireNames: boolean,
+  allowOptionalDependencies: AllowOptionalDependencies,
+  dependencyRegistry?: ModuleDependencyRegistry<TSplitCondition>,
+  dependencyTransformer?: DependencyTransformer<TSplitCondition>,
+}>;
+
+export type CollectedDependencies<+TSplitCondition> = $ReadOnly<{
+  ast: BabelNodeFile,
+  dependencyMapName: string,
+  dependencies: $ReadOnlyArray<Dependency<TSplitCondition>>,
+}>;
+
+// Registry for the dependency of a module.
+// Defines when dependencies should be collapsed.
+// E.g. should a module that's once required optinally and once not
+// be tretaed as the smae or different dependencies.
+export interface ModuleDependencyRegistry<+TSplitCondition> {
+  registerDependency(
+    qualifier: ImportQualifier,
+  ): InternalDependency<TSplitCondition>;
+  getDependencies(): Array<InternalDependency<TSplitCondition>>;
+}
 
-export type Dependency = InternalDependency<DependencyData>;
+export interface DependencyTransformer<-TSplitCondition> {
+  transformSyncRequire(
+    path: NodePath<CallExpression>,
+    dependency: InternalDependency<TSplitCondition>,
+    state: State<TSplitCondition>,
+  ): void;
+  transformImportCall(
+    path: NodePath<>,
+    dependency: InternalDependency<TSplitCondition>,
+    state: State<TSplitCondition>,
+  ): void;
+  transformJSResource(
+    path: NodePath<>,
+    dependency: InternalDependency<TSplitCondition>,
+    state: State<TSplitCondition>,
+  ): void;
+  transformPrefetch(
+    path: NodePath<>,
+    dependency: InternalDependency<TSplitCondition>,
+    state: State<TSplitCondition>,
+  ): void;
+  transformIllegalDynamicRequire(
+    path: NodePath<>,
+    state: State<TSplitCondition>,
+  ): void;
+}
 
 export type DynamicRequiresBehavior = 'throwAtRuntime' | 'reject';
 
-/**
- * Produces a Babel template that will throw at runtime when the require call
- * is reached. This makes dynamic require errors catchable by libraries that
- * want to use them.
- */
-const dynamicRequireErrorTemplate = template(`
-  (function(line) {
-    throw new Error(
-      'Dynamic require defined at line ' + line + '; not supported by Metro',
-    );
-  })(LINE)
-`);
-
-/**
- * Produces a Babel template that transforms an "import(...)" call into a
- * "require(...)" call to the asyncRequire specified.
- */
-const makeAsyncRequireTemplate = template(`
-  require(ASYNC_REQUIRE_MODULE_PATH)(MODULE_ID, MODULE_NAME)
-`);
-
-const makeAsyncPrefetchTemplate = template(`
-  require(ASYNC_REQUIRE_MODULE_PATH).prefetch(MODULE_ID, MODULE_NAME)
-`);
-
-const makeJSResourceTemplate = template(`
-  require(ASYNC_REQUIRE_MODULE_PATH).resource(MODULE_ID, MODULE_NAME)
-`);
-
 /**
  * Transform all the calls to `require()` and `import()` in a file into ID-
  * independent code, and return the list of dependencies. For example, a call
@@ -121,62 +135,78 @@ const makeJSResourceTemplate = template(`
  *
  * The second argument is only provided for debugging purposes.
  */
-function collectDependencies(
-  ast: Ast,
-  options: Options,
-): CollectedDependencies {
+function collectDependencies<TSplitCondition = void>(
+  ast: BabelNodeFile,
+  options: Options<TSplitCondition>,
+): CollectedDependencies<TSplitCondition> {
   const visited = new WeakSet();
 
-  const state: State = {
+  const state: State<TSplitCondition> = {
     asyncRequireModulePathStringLiteral: null,
-    dependency: 0,
     dependencyCalls: new Set(),
-    dependencyData: new Map(),
-    dependencyIndexes: new Map(),
+    dependencyRegistry:
+      options.dependencyRegistry ?? new DefaultModuleDependencyRegistry(),
+    dependencyTransformer:
+      options.dependencyTransformer ?? DefaultDependencyTransformer,
     dependencyMapIdentifier: null,
     dynamicRequires: options.dynamicRequires,
     keepRequireNames: options.keepRequireNames,
-    disableRequiresTransform: !!options.disableRequiresTransform,
     allowOptionalDependencies: options.allowOptionalDependencies,
   };
 
   const visitor = {
-    CallExpression(path: Path, state: State) {
+    CallExpression(path, state): void {
       if (visited.has(path.node)) {
         return;
       }
 
-      const callee = path.get('callee');
-      const name = callee.node.name;
+      const callee = path.node.callee;
+      const name = callee.type === 'Identifier' ? callee.name : null;
 
-      if (callee.isImport()) {
+      if (isImport(callee)) {
         processImportCall(path, state, {
-          prefetchOnly: false,
+          asyncType: 'async',
         });
         return;
       }
 
       if (name === '__prefetchImport' && !path.scope.getBinding(name)) {
         processImportCall(path, state, {
-          prefetchOnly: true,
+          asyncType: 'prefetch',
+        });
+        return;
+      }
+
+      if (name === '__jsResource' && !path.scope.getBinding(name)) {
+        processImportCall(path, state, {
+          asyncType: 'async',
+          jsResource: true,
         });
         return;
       }
 
       if (
-        (name === '__jsResource' ||
-          name === '__conditionallySplitJSResource') &&
+        name === '__conditionallySplitJSResource' &&
         !path.scope.getBinding(name)
       ) {
+        const args = path.get('arguments');
+        invariant(Array.isArray(args), 'Expected arguments to be an array');
+
         processImportCall(path, state, {
-          prefetchOnly: false,
+          asyncType: 'async',
           jsResource: true,
+          splitCondition: args[1],
         });
         return;
       }
 
-      if (state.dependencyCalls.has(name) && !path.scope.getBinding(name)) {
-        visited.add(processRequireCall(path, state).node);
+      if (
+        name != null &&
+        state.dependencyCalls.has(name) &&
+        !path.scope.getBinding(name)
+      ) {
+        processRequireCall(path, state);
+        visited.add(path.node);
       }
     },
 
@@ -184,7 +214,7 @@ function collectDependencies(
     ExportNamedDeclaration: collectImports,
     ExportAllDeclaration: collectImports,
 
-    Program(path: Path, state: State) {
+    Program(path, state) {
       state.asyncRequireModulePathStringLiteral = types.stringLiteral(
         options.asyncRequireModulePath,
       );
@@ -205,11 +235,15 @@ function collectDependencies(
 
   traverse(ast, visitor, null, state);
 
+  const collectedDependencies = state.dependencyRegistry.getDependencies();
   // Compute the list of dependencies.
-  const dependencies = new Array(state.dependency);
+  const dependencies = new Array(collectedDependencies.length);
 
-  for (const [name, data] of state.dependencyData) {
-    dependencies[nullthrows(state.dependencyIndexes.get(name))] = {name, data};
+  for (const {index, name, ...dependencyData} of collectedDependencies) {
+    dependencies[index] = {
+      name,
+      data: dependencyData,
+    };
   }
 
   return {
@@ -219,165 +253,128 @@ function collectDependencies(
   };
 }
 
-function collectImports(path: Path, state: State) {
+function collectImports<TSplitCondition>(
+  path: NodePath<>,
+  state: State<TSplitCondition>,
+): void {
   if (path.node.source) {
-    const dep = getDependency(
+    registerDependency(
       state,
-      path.node.source.value,
       {
-        prefetchOnly: false,
+        name: path.node.source.value,
+        asyncType: null,
+        optional: false,
       },
       path,
     );
-
-    dep.data.asyncType = null;
   }
 }
 
-function processImportCall(path: Path, state: State, opts: DepOptions): Path {
+function processImportCall<TSplitCondition>(
+  path: NodePath<CallExpression>,
+  state: State<TSplitCondition>,
+  options: ImportDependencyOptions,
+): void {
   const name = getModuleNameFromCallArgs(path);
 
   if (name == null) {
     throw new InvalidRequireCallError(path);
   }
 
-  const options = {
-    ...opts,
-    isOptional: isOptionalDependency(name, path, state),
-  };
-  const dep = getDependency(state, name, options, path);
-  if (!options.prefetchOnly && dep.data.asyncType === 'prefetch') {
-    dep.data.asyncType = 'async';
-  }
-  if (state.disableRequiresTransform) {
-    return path;
-  }
-
-  const ASYNC_REQUIRE_MODULE_PATH = state.asyncRequireModulePathStringLiteral;
-  const MODULE_ID = types.memberExpression(
-    state.dependencyMapIdentifier,
-    types.numericLiteral(dep.index),
-    true,
+  const dep = registerDependency(
+    state,
+    {
+      name,
+      asyncType: options.asyncType,
+      splitCondition: options.splitCondition,
+      optional: isOptionalDependency(name, path, state),
+    },
+    path,
   );
-  const MODULE_NAME = types.stringLiteral(name);
+
+  const transformer = state.dependencyTransformer;
 
   if (options.jsResource) {
-    path.replaceWith(
-      makeJSResourceTemplate({
-        ASYNC_REQUIRE_MODULE_PATH,
-        MODULE_ID,
-        MODULE_NAME,
-      }),
-    );
-  } else if (!options.prefetchOnly) {
-    path.replaceWith(
-      makeAsyncRequireTemplate({
-        ASYNC_REQUIRE_MODULE_PATH,
-        MODULE_ID,
-        MODULE_NAME,
-      }),
-    );
+    transformer.transformJSResource(path, dep, state);
+  } else if (options.asyncType === 'async') {
+    transformer.transformImportCall(path, dep, state);
   } else {
-    path.replaceWith(
-      makeAsyncPrefetchTemplate({
-        ASYNC_REQUIRE_MODULE_PATH,
-        MODULE_ID,
-        MODULE_NAME,
-      }),
-    );
+    transformer.transformPrefetch(path, dep, state);
   }
-
-  return path;
 }
 
-function processRequireCall(path: Path, state: State): Path {
+function processRequireCall<TSplitCondition>(
+  path: NodePath<CallExpression>,
+  state: State<TSplitCondition>,
+): void {
   const name = getModuleNameFromCallArgs(path);
 
+  const transformer = state.dependencyTransformer;
+
   if (name == null) {
     if (state.dynamicRequires === 'reject') {
       throw new InvalidRequireCallError(path);
     }
 
-    path.replaceWith(
-      dynamicRequireErrorTemplate({
-        LINE: '' + path.node.loc.start.line,
-      }),
-    );
-    return path;
+    transformer.transformIllegalDynamicRequire(path, state);
+    return;
   }
 
-  const dep = getDependency(
+  const dep = registerDependency(
     state,
-    name,
-    {prefetchOnly: false, isOptional: isOptionalDependency(name, path, state)},
+    {
+      name,
+      asyncType: null,
+      optional: isOptionalDependency(name, path, state),
+    },
     path,
   );
-  dep.data.asyncType = null;
-
-  if (state.disableRequiresTransform) {
-    return path;
-  }
-
-  const moduleIDExpression = types.memberExpression(
-    state.dependencyMapIdentifier,
-    types.numericLiteral(dep.index),
-    true,
-  );
-
-  path.node.arguments = state.keepRequireNames
-    ? [moduleIDExpression, types.stringLiteral(name)]
-    : [moduleIDExpression];
 
-  return path;
+  transformer.transformSyncRequire(path, dep, state);
 }
 
-function getNearestLocFromPath(path: Path): ?BabelSourceLocation {
-  while (path && !path.node.loc) {
-    path = path.parentPath;
+function getNearestLocFromPath(path: NodePath<>): ?BabelSourceLocation {
+  let current = path;
+  while (current && !current.node.loc) {
+    current = current.parentPath;
   }
-  return path?.node.loc;
+  return current?.node.loc;
 }
 
-function getDependency(
-  state: State,
+export type ImportQualifier = $ReadOnly<{
   name: string,
-  options: DepOptions,
-  path: Path,
-): InternalDependencyInfo {
-  const loc = getNearestLocFromPath(path);
-  let index = state.dependencyIndexes.get(name);
-  let data: ?InternalDependencyData = state.dependencyData.get(name);
-
-  if (!data) {
-    index = state.dependency++;
-    data = {asyncType: 'async', locs: []};
-
-    if (options.prefetchOnly) {
-      data.asyncType = 'prefetch';
-    }
-
-    if (options.isOptional) {
-      data.isOptional = true;
-    }
+  asyncType: AsyncDependencyType | null,
+  splitCondition?: NodePath<>,
+  optional: boolean,
+}>;
 
-    state.dependencyIndexes.set(name, index);
-    state.dependencyData.set(name, data);
-  }
+function registerDependency<TSplitCondition>(
+  state: State<TSplitCondition>,
+  qualifier: ImportQualifier,
+  path: NodePath<>,
+): InternalDependency<TSplitCondition> {
+  const dependency = state.dependencyRegistry.registerDependency(qualifier);
 
+  const loc = getNearestLocFromPath(path);
   if (loc != null) {
-    data.locs.push(loc);
+    dependency.locs.push(loc);
   }
 
-  return {index: nullthrows(index), data: nullthrows(data)};
+  return dependency;
 }
 
-const isOptionalDependency = (
+function isOptionalDependency<TSplitCondition>(
   name: string,
-  path: Path,
-  state: State,
-): boolean => {
+  path: NodePath<>,
+  state: State<TSplitCondition>,
+): boolean {
   const {allowOptionalDependencies} = state;
 
+  // The async require module is a 'built-in'. Resolving should never fail -> treat it as non-optional.
+  if (name === state.asyncRequireModulePathStringLiteral?.value) {
+    return false;
+  }
+
   const isExcluded = () =>
     Array.isArray(allowOptionalDependencies.exclude) &&
     allowOptionalDependencies.exclude.includes(name);
@@ -394,7 +391,11 @@ const isOptionalDependency = (
       if (p.node.type === 'BlockStatement') {
         // A single-level should have the tryStatement immediately followed BlockStatement
         // with the key 'block' to distinguish from the finally block, which has key = 'finalizer'
-        return p.parentPath.node.type === 'TryStatement' && p.key === 'block';
+        return (
+          p.parentPath != null &&
+          p.parentPath.node.type === 'TryStatement' &&
+          p.key === 'block'
+        );
       }
       sCount += 1;
     }
@@ -402,16 +403,17 @@ const isOptionalDependency = (
   }
 
   return false;
-};
+}
 
-function getModuleNameFromCallArgs(path: Path): ?string {
+function getModuleNameFromCallArgs(path: NodePath<CallExpression>): ?string {
   const expectedCount =
     path.node.callee.name === '__conditionallySplitJSResource' ? 2 : 1;
-  if (path.get('arguments').length !== expectedCount) {
+  const args = path.get('arguments');
+  if (!Array.isArray(args) || args.length !== expectedCount) {
     throw new InvalidRequireCallError(path);
   }
 
-  const result = path.get('arguments.0').evaluate();
+  const result = args[0].evaluate();
 
   if (result.confident && typeof result.value === 'string') {
     return result.value;
@@ -433,4 +435,190 @@ class InvalidRequireCallError extends Error {
 
 collectDependencies.InvalidRequireCallError = InvalidRequireCallError;
 
+/**
+ * Produces a Babel template that will throw at runtime when the require call
+ * is reached. This makes dynamic require errors catchable by libraries that
+ * want to use them.
+ */
+const dynamicRequireErrorTemplate = template.statement(`
+  (function(line) {
+    throw new Error(
+      'Dynamic require defined at line ' + line + '; not supported by Metro',
+    );
+  })(LINE)
+`);
+
+/**
+ * Produces a Babel template that transforms an "import(...)" call into a
+ * "require(...)" call to the asyncRequire specified.
+ */
+const makeAsyncRequireTemplate = template.statement(`
+  require(ASYNC_REQUIRE_MODULE_PATH)(MODULE_ID, MODULE_NAME)
+`);
+
+const makeAsyncPrefetchTemplate = template.statement(`
+  require(ASYNC_REQUIRE_MODULE_PATH).prefetch(MODULE_ID, MODULE_NAME)
+`);
+
+const makeJSResourceTemplate = template.statement(`
+  require(ASYNC_REQUIRE_MODULE_PATH).resource(MODULE_ID, MODULE_NAME)
+`);
+
+const DefaultDependencyTransformer: DependencyTransformer<mixed> = {
+  transformSyncRequire(
+    path: NodePath<CallExpression>,
+    dependency: InternalDependency<mixed>,
+    state: State<mixed>,
+  ): void {
+    const moduleIDExpression = createModuleIDExpression(dependency, state);
+    path.node.arguments = state.keepRequireNames
+      ? [moduleIDExpression, types.stringLiteral(dependency.name)]
+      : [moduleIDExpression];
+  },
+
+  transformImportCall(
+    path: NodePath<>,
+    dependency: InternalDependency<mixed>,
+    state: State<mixed>,
+  ): void {
+    path.replaceWith(
+      makeAsyncRequireTemplate({
+        ASYNC_REQUIRE_MODULE_PATH: nullthrows(
+          state.asyncRequireModulePathStringLiteral,
+        ),
+        MODULE_ID: createModuleIDExpression(dependency, state),
+        MODULE_NAME: createModuleNameLiteral(dependency),
+      }),
+    );
+  },
+
+  transformJSResource(
+    path: NodePath<>,
+    dependency: InternalDependency<mixed>,
+    state: State<mixed>,
+  ): void {
+    path.replaceWith(
+      makeJSResourceTemplate({
+        ASYNC_REQUIRE_MODULE_PATH: nullthrows(
+          state.asyncRequireModulePathStringLiteral,
+        ),
+        MODULE_ID: createModuleIDExpression(dependency, state),
+        MODULE_NAME: createModuleNameLiteral(dependency),
+      }),
+    );
+  },
+
+  transformPrefetch(
+    path: NodePath<>,
+    dependency: InternalDependency<mixed>,
+    state: State<mixed>,
+  ): void {
+    path.replaceWith(
+      makeAsyncPrefetchTemplate({
+        ASYNC_REQUIRE_MODULE_PATH: nullthrows(
+          state.asyncRequireModulePathStringLiteral,
+        ),
+        MODULE_ID: createModuleIDExpression(dependency, state),
+        MODULE_NAME: createModuleNameLiteral(dependency),
+      }),
+    );
+  },
+
+  transformIllegalDynamicRequire(path: NodePath<>, state: State<mixed>): void {
+    path.replaceWith(
+      dynamicRequireErrorTemplate({
+        LINE: types.numericLiteral(path.node.loc?.start.line ?? 0),
+      }),
+    );
+  },
+};
+
+function createModuleIDExpression(
+  dependency: InternalDependency<mixed>,
+  state: State<mixed>,
+) {
+  return types.memberExpression(
+    nullthrows(state.dependencyMapIdentifier),
+    types.numericLiteral(dependency.index),
+    true,
+  );
+}
+
+function createModuleNameLiteral(dependency: InternalDependency<mixed>) {
+  return types.stringLiteral(dependency.name);
+}
+
+class DefaultModuleDependencyRegistry<TSplitCondition = void>
+  implements ModuleDependencyRegistry<TSplitCondition> {
+  _dependencies: Map<string, InternalDependency<TSplitCondition>> = new Map();
+
+  registerDependency(
+    qualifier: ImportQualifier,
+  ): InternalDependency<TSplitCondition> {
+    let dependency: ?InternalDependency<TSplitCondition> = this._dependencies.get(
+      qualifier.name,
+    );
+
+    if (dependency == null) {
+      const newDependency: MutableInternalDependency<TSplitCondition> = {
+        name: qualifier.name,
+        asyncType: qualifier.asyncType,
+        locs: [],
+        index: this._dependencies.size,
+      };
+
+      if (qualifier.optional) {
+        newDependency.isOptional = true;
+      }
+
+      dependency = newDependency;
+      this._dependencies.set(qualifier.name, dependency);
+    } else {
+      const original = dependency;
+      dependency = collapseDependencies(original, qualifier);
+      if (original !== dependency) {
+        this._dependencies.set(qualifier.name, dependency);
+      }
+    }
+
+    return dependency;
+  }
+
+  getDependencies(): Array<InternalDependency<TSplitCondition>> {
+    return Array.from(this._dependencies.values());
+  }
+}
+
+function collapseDependencies<TSplitCondition>(
+  dependency: InternalDependency<TSplitCondition>,
+  qualifier: ImportQualifier,
+): InternalDependency<TSplitCondition> {
+  let collapsed = dependency;
+
+  // A previously optionally required dependency was required non-optionaly.
+  // Mark it non optional for the whole module
+  if (collapsed.isOptional && !qualifier.optional) {
+    collapsed = {
+      ...dependency,
+      isOptional: false,
+    };
+  }
+
+  // A previously asynchronously (or prefetch) required module was required synchronously.
+  // Make the dependency sync.
+  if (collapsed.asyncType != null && qualifier.asyncType == null) {
+    collapsed = {...dependency, asyncType: null};
+  }
+
+  // A prefetched dependency was required async in the module. Mark it as async.
+  if (collapsed.asyncType === 'prefetch' && qualifier.asyncType === 'async') {
+    collapsed = {
+      ...dependency,
+      asyncType: 'async',
+    };
+  }
+
+  return collapsed;
+}
+
 module.exports = collectDependencies;