metro-file-map 0.83.3 → 0.84.0

package/src/plugins/HastePlugin.js.flow

@@ -16,7 +16,7 @@ import type {
   FileMapDelta,
   FileMapPlugin,
   FileMapPluginInitOptions,
-  FileMetadata,
+  FileMapPluginWorker,
   HasteConflict,
   HasteMap,
   HasteMapItem,
@@ -34,39 +34,45 @@ import getPlatformExtension from './haste/getPlatformExtension';
 import {HasteConflictsError} from './haste/HasteConflictsError';
 import path from 'path';
 
-const EMPTY_OBJ: $ReadOnly<{[string]: HasteMapItemMetadata}> = {};
-const EMPTY_MAP: $ReadOnlyMap<string, DuplicatesSet> = new Map();
+const EMPTY_OBJ: Readonly<{[string]: HasteMapItemMetadata}> = {};
+const EMPTY_MAP: ReadonlyMap<string, DuplicatesSet> = new Map();
+const PACKAGE_JSON = /(?:[/\\]|^)package\.json$/;
 
 // Periodically yield to the event loop to allow parallel I/O, etc.
 // Based on 200k files taking up to 800ms => max 40ms between yields.
 const YIELD_EVERY_NUM_HASTE_FILES = 10000;
 
-type HasteMapOptions = $ReadOnly<{
+export type HasteMapOptions = Readonly<{
   console?: ?Console,
   enableHastePackages: boolean,
-  perfLogger: ?PerfLogger,
-  platforms: $ReadOnlySet<string>,
+  hasteImplModulePath: ?string,
+  perfLogger?: ?PerfLogger,
+  platforms: ReadonlySet<string>,
   rootDir: Path,
   failValidationOnConflicts: boolean,
 }>;
 
-export default class HastePlugin implements HasteMap, FileMapPlugin<null> {
-  +name = 'haste';
-
-  +#rootDir: Path;
-  +#map: Map<string, HasteMapItem> = new Map();
-  +#duplicates: DuplicatesIndex = new Map();
+export default class HastePlugin
+  implements HasteMap, FileMapPlugin<null, string | null>
+{
+  +name: 'haste' = 'haste';
 
   +#console: ?Console;
+  +#duplicates: DuplicatesIndex = new Map();
   +#enableHastePackages: boolean;
-  +#perfLogger: ?PerfLogger;
-  +#pathUtils: RootPathUtils;
-  +#platforms: $ReadOnlySet<string>;
   +#failValidationOnConflicts: boolean;
+  #getModuleNameByPath: string => ?string;
+  +#hasteImplModulePath: ?string;
+  +#map: Map<string, HasteMapItem> = new Map();
+  +#pathUtils: RootPathUtils;
+  +#perfLogger: ?PerfLogger;
+  +#platforms: ReadonlySet<string>;
+  +#rootDir: Path;
 
   constructor(options: HasteMapOptions) {
-    this.#console = options.console ?? null;
+    this.#console = options.console ?? global.console;
     this.#enableHastePackages = options.enableHastePackages;
+    this.#hasteImplModulePath = options.hasteImplModulePath;
     this.#perfLogger = options.perfLogger;
     this.#platforms = options.platforms;
     this.#rootDir = options.rootDir;
@@ -74,26 +80,41 @@ export default class HastePlugin implements HasteMap, FileMapPlugin<null> {
     this.#failValidationOnConflicts = options.failValidationOnConflicts;
   }
 
-  async initialize({files}: FileMapPluginInitOptions<null>): Promise<void> {
+  async initialize({
+    files,
+  }: FileMapPluginInitOptions<null, string | null>): Promise<void> {
     this.#perfLogger?.point('constructHasteMap_start');
     let hasteFiles = 0;
-    for (const {baseName, canonicalPath, metadata} of files.metadataIterator({
+    for (const {
+      baseName,
+      canonicalPath,
+      pluginData: hasteId,
+    } of files.fileIterator({
       // Symlinks and node_modules are never Haste modules or packages.
       includeNodeModules: false,
       includeSymlinks: false,
     })) {
-      if (metadata[H.ID]) {
-        this.setModule(metadata[H.ID], [
-          canonicalPath,
-          this.#enableHastePackages && baseName === 'package.json'
-            ? H.PACKAGE
-            : H.MODULE,
-        ]);
-        if (++hasteFiles % YIELD_EVERY_NUM_HASTE_FILES === 0) {
-          await new Promise(setImmediate);
-        }
+      if (hasteId == null) {
+        continue;
+      }
+      this.setModule(hasteId, [
+        canonicalPath,
+        this.#enableHastePackages && baseName === 'package.json'
+          ? H.PACKAGE
+          : H.MODULE,
+      ]);
+      if (++hasteFiles % YIELD_EVERY_NUM_HASTE_FILES === 0) {
+        await new Promise(setImmediate);
       }
     }
+    this.#getModuleNameByPath = mixedPath => {
+      const result = files.lookup(mixedPath);
+      return result.exists &&
+        result.type === 'f' &&
+        typeof result.pluginData === 'string'
+        ? result.pluginData
+        : null;
+    };
     this.#perfLogger?.point('constructHasteMap_end');
     this.#perfLogger?.annotate({int: {hasteFiles}});
   }
@@ -112,7 +133,7 @@ export default class HastePlugin implements HasteMap, FileMapPlugin<null> {
     supportsNativePlatform?: ?boolean,
     type?: ?HTypeValue,
   ): ?Path {
-    const module = this._getModuleMetadata(
+    const module = this.#getModuleMetadata(
       name,
       platform,
       !!supportsNativePlatform,
@@ -126,6 +147,15 @@ export default class HastePlugin implements HasteMap, FileMapPlugin<null> {
     return null;
   }
 
+  getModuleNameByPath(mixedPath: Path): ?string {
+    if (this.#getModuleNameByPath == null) {
+      throw new Error(
+        'HastePlugin has not been initialized before getModuleNameByPath',
+      );
+    }
+    return this.#getModuleNameByPath(mixedPath) ?? null;
+  }
+
   getPackage(
     name: string,
     platform: ?string,
@@ -142,7 +172,7 @@ export default class HastePlugin implements HasteMap, FileMapPlugin<null> {
    * extra sure. If metadata exists both in the `duplicates` object and the
    * `map`, this would be a bug.
    */
-  _getModuleMetadata(
+  #getModuleMetadata(
     name: string,
     platform: ?string,
     supportsNativePlatform: boolean,
@@ -150,7 +180,7 @@ export default class HastePlugin implements HasteMap, FileMapPlugin<null> {
     const map = this.#map.get(name) || EMPTY_OBJ;
     const dupMap = this.#duplicates.get(name) || EMPTY_MAP;
     if (platform != null) {
-      this._assertNoDuplicates(
+      this.#assertNoDuplicates(
         name,
         platform,
         supportsNativePlatform,
@@ -161,7 +191,7 @@ export default class HastePlugin implements HasteMap, FileMapPlugin<null> {
       }
     }
     if (supportsNativePlatform) {
-      this._assertNoDuplicates(
+      this.#assertNoDuplicates(
         name,
         H.NATIVE_PLATFORM,
         supportsNativePlatform,
@@ -171,7 +201,7 @@ export default class HastePlugin implements HasteMap, FileMapPlugin<null> {
         return map[H.NATIVE_PLATFORM];
       }
     }
-    this._assertNoDuplicates(
+    this.#assertNoDuplicates(
       name,
       H.GENERIC_PLATFORM,
       supportsNativePlatform,
@@ -183,7 +213,7 @@ export default class HastePlugin implements HasteMap, FileMapPlugin<null> {
     return null;
   }
 
-  _assertNoDuplicates(
+  #assertNoDuplicates(
     name: string,
     platform: string,
     supportsNativePlatform: boolean,
@@ -207,19 +237,19 @@ export default class HastePlugin implements HasteMap, FileMapPlugin<null> {
     );
   }
 
-  async bulkUpdate(delta: FileMapDelta): Promise<void> {
+  async bulkUpdate(delta: FileMapDelta<?string>): Promise<void> {
     // Process removals first so that moves aren't treated as duplicates.
-    for (const [normalPath, metadata] of delta.removed) {
-      this.onRemovedFile(normalPath, metadata);
+    for (const [normalPath, maybeHasteId] of delta.removed) {
+      this.onRemovedFile(normalPath, maybeHasteId);
     }
-    for (const [normalPath, metadata] of delta.addedOrModified) {
-      this.onNewOrModifiedFile(normalPath, metadata);
+    for (const [normalPath, maybeHasteId] of delta.addedOrModified) {
+      this.onNewOrModifiedFile(normalPath, maybeHasteId);
     }
   }
 
-  onNewOrModifiedFile(relativeFilePath: string, fileMetadata: FileMetadata) {
-    const id = fileMetadata[H.ID] || null; // Empty string indicates no module
+  onNewOrModifiedFile(relativeFilePath: string, id: ?string) {
     if (id == null) {
+      // Not a Haste module or package
       return;
     }
 
@@ -238,7 +268,7 @@ export default class HastePlugin implements HasteMap, FileMapPlugin<null> {
     let hasteMapItem = this.#map.get(id);
     if (!hasteMapItem) {
       // $FlowFixMe[unclear-type] - Add type coverage
-      hasteMapItem = (Object.create(null): any);
+      hasteMapItem = Object.create(null) as any;
       this.#map.set(id, hasteMapItem);
     }
     const platform =
@@ -294,9 +324,9 @@ export default class HastePlugin implements HasteMap, FileMapPlugin<null> {
     hasteMapItem[platform] = module;
   }
 
-  onRemovedFile(relativeFilePath: string, fileMetadata: FileMetadata) {
-    const moduleName = fileMetadata[H.ID] || null; // Empty string indicates no module
+  onRemovedFile(relativeFilePath: string, moduleName: ?string) {
     if (moduleName == null) {
+      // Not a Haste module or package
       return;
     }
 
@@ -314,7 +344,7 @@ export default class HastePlugin implements HasteMap, FileMapPlugin<null> {
       }
     }
 
-    this._recoverDuplicates(moduleName, relativeFilePath);
+    this.#recoverDuplicates(moduleName, relativeFilePath);
   }
 
   assertValid(): void {
@@ -335,7 +365,7 @@ export default class HastePlugin implements HasteMap, FileMapPlugin<null> {
    * remaining in the group, then we want to restore that single file as the
    * correct resolution for its ID, and cleanup the duplicates index.
    */
-  _recoverDuplicates(moduleName: string, relativeFilePath: string) {
+  #recoverDuplicates(moduleName: string, relativeFilePath: string) {
     let dupsByPlatform = this.#duplicates.get(moduleName);
     if (dupsByPlatform == null) {
       return;
@@ -369,7 +399,7 @@ export default class HastePlugin implements HasteMap, FileMapPlugin<null> {
     let dedupMap: ?HasteMapItem = this.#map.get(moduleName);
 
     if (dedupMap == null) {
-      dedupMap = (Object.create(null): HasteMapItem);
+      dedupMap = Object.create(null) as HasteMapItem;
       this.#map.set(moduleName, dedupMap);
     }
     dedupMap[platform] = uniqueModule;
@@ -386,12 +416,12 @@ export default class HastePlugin implements HasteMap, FileMapPlugin<null> {
     for (const [id, dupsByPlatform] of this.#duplicates.entries()) {
       for (const [platform, conflictingModules] of dupsByPlatform) {
         conflicts.push({
-          id,
-          platform: platform === H.GENERIC_PLATFORM ? null : platform,
           absolutePaths: [...conflictingModules.keys()]
             .map(modulePath => this.#pathUtils.normalToAbsolute(modulePath))
             // Sort for ease of testing
             .sort(),
+          id,
+          platform: platform === H.GENERIC_PLATFORM ? null : platform,
           type: 'duplicate',
         });
       }
@@ -428,12 +458,12 @@ export default class HastePlugin implements HasteMap, FileMapPlugin<null> {
       }
       if (conflictPaths.size) {
         conflicts.push({
-          id,
-          platform: null,
           absolutePaths: [...new Set([...conflictPaths, ...basePaths])]
             .map(modulePath => this.#pathUtils.normalToAbsolute(modulePath))
             // Sort for ease of testing
             .sort(),
+          id,
+          platform: null,
           type: 'shadowing',
         });
       }
@@ -454,7 +484,31 @@ export default class HastePlugin implements HasteMap, FileMapPlugin<null> {
   getCacheKey(): string {
     return JSON.stringify([
       this.#enableHastePackages,
+      this.#hasteImplModulePath != null
+        ? // $FlowFixMe[unsupported-syntax] - dynamic require
+          require(this.#hasteImplModulePath).getCacheKey()
+        : null,
       [...this.#platforms].sort(),
     ]);
   }
+
+  getWorker(): FileMapPluginWorker {
+    return {
+      worker: {
+        modulePath: require.resolve('./haste/worker.js'),
+        setupArgs: {
+          hasteImplModulePath: this.#hasteImplModulePath ?? null,
+        },
+      },
+      filter: ({isNodeModules, normalPath}) => {
+        if (isNodeModules) {
+          return false;
+        }
+        if (PACKAGE_JSON.test(normalPath)) {
+          return this.#enableHastePackages;
+        }
+        return this.#hasteImplModulePath != null;
+      },
+    };
+  }
 }

package/src/plugins/MockPlugin.js

@@ -30,8 +30,8 @@ class MockPlugin {
     console,
     mocksPattern,
     rawMockMap = {
-      mocks: new Map(),
       duplicates: new Map(),
+      mocks: new Map(),
       version: CACHE_VERSION,
     },
     rootDir,
@@ -53,11 +53,11 @@ class MockPlugin {
     } else {
       await this.bulkUpdate({
         addedOrModified: [
-          ...files.metadataIterator({
+          ...files.fileIterator({
             includeNodeModules: false,
             includeSymlinks: false,
           }),
-        ].map(({ canonicalPath, metadata }) => [canonicalPath, metadata]),
+        ].map(({ canonicalPath }) => [canonicalPath, null]),
         removed: [],
       });
     }
@@ -129,10 +129,10 @@ class MockPlugin {
   }
   getSerializableSnapshot() {
     return {
-      mocks: new Map(this.#raw.mocks),
       duplicates: new Map(
         [...this.#raw.duplicates].map(([k, v]) => [k, new Set(v)]),
       ),
+      mocks: new Map(this.#raw.mocks),
       version: this.#raw.version,
     };
   }
@@ -175,5 +175,8 @@ class MockPlugin {
       this.#mocksPattern.flags
     );
   }
+  getWorker() {
+    return null;
+  }
 }
 exports.default = MockPlugin;

package/src/plugins/MockPlugin.js.flow

@@ -13,6 +13,7 @@ import type {
   FileMapDelta,
   FileMapPlugin,
   FileMapPluginInitOptions,
+  FileMapPluginWorker,
   MockMap as IMockMap,
   Path,
   RawMockMap,
@@ -27,8 +28,18 @@ import path from 'path';
 
 export const CACHE_VERSION = 2;
 
-export default class MockPlugin implements FileMapPlugin<RawMockMap>, IMockMap {
-  +name = 'mocks';
+export type MockMapOptions = Readonly<{
+  console: typeof console,
+  mocksPattern: RegExp,
+  rawMockMap?: RawMockMap,
+  rootDir: Path,
+  throwOnModuleCollision: boolean,
+}>;
+
+export default class MockPlugin
+  implements FileMapPlugin<RawMockMap, void>, IMockMap
+{
+  +name: 'mocks' = 'mocks';
 
   +#mocksPattern: RegExp;
   #raw: RawMockMap;
@@ -41,19 +52,13 @@ export default class MockPlugin implements FileMapPlugin<RawMockMap>, IMockMap {
     console,
     mocksPattern,
     rawMockMap = {
-      mocks: new Map(),
       duplicates: new Map(),
+      mocks: new Map(),
       version: CACHE_VERSION,
     },
     rootDir,
     throwOnModuleCollision,
-  }: $ReadOnly<{
-    console: typeof console,
-    mocksPattern: RegExp,
-    rawMockMap?: RawMockMap,
-    rootDir: Path,
-    throwOnModuleCollision: boolean,
-  }>) {
+  }: MockMapOptions) {
     this.#mocksPattern = mocksPattern;
     if (rawMockMap.version !== CACHE_VERSION) {
       throw new Error('Incompatible state passed to MockPlugin');
@@ -76,11 +81,11 @@ export default class MockPlugin implements FileMapPlugin<RawMockMap>, IMockMap {
       // Otherwise, traverse all files to rebuild
       await this.bulkUpdate({
         addedOrModified: [
-          ...files.metadataIterator({
+          ...files.fileIterator({
             includeNodeModules: false,
             includeSymlinks: false,
           }),
-        ].map(({canonicalPath, metadata}) => [canonicalPath, metadata]),
+        ].map(({canonicalPath}) => [canonicalPath, null]),
         removed: [],
       });
     }
@@ -97,7 +102,7 @@ export default class MockPlugin implements FileMapPlugin<RawMockMap>, IMockMap {
     );
   }
 
-  async bulkUpdate(delta: FileMapDelta): Promise<void> {
+  async bulkUpdate(delta: FileMapDelta<>): Promise<void> {
     // Process removals first so that moves aren't treated as duplicates.
     for (const [relativeFilePath] of delta.removed) {
       this.onRemovedFile(relativeFilePath);
@@ -160,10 +165,10 @@ export default class MockPlugin implements FileMapPlugin<RawMockMap>, IMockMap {
 
   getSerializableSnapshot(): RawMockMap {
     return {
-      mocks: new Map(this.#raw.mocks),
       duplicates: new Map(
         [...this.#raw.duplicates].map(([k, v]) => [k, new Set(v)]),
       ),
+      mocks: new Map(this.#raw.mocks),
       version: this.#raw.version,
     };
   }
@@ -186,7 +191,7 @@ export default class MockPlugin implements FileMapPlugin<RawMockMap>, IMockMap {
 
   #getMessageForDuplicates(
     mockName: string,
-    relativePosixPaths: $ReadOnlySet<string>,
+    relativePosixPaths: ReadonlySet<string>,
   ): string {
     return (
       'Duplicate manual mock found for `' +
@@ -213,4 +218,8 @@ export default class MockPlugin implements FileMapPlugin<RawMockMap>, IMockMap {
       this.#mocksPattern.flags
     );
   }
+
+  getWorker(): ?FileMapPluginWorker {
+    return null;
+  }
 }

package/src/plugins/dependencies/dependencyExtractor.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ */
+
+declare const dependencyExtractor: {
+  extract(code: string): Set<string>;
+};
+
+export = dependencyExtractor;

package/src/{lib → plugins/dependencies}/dependencyExtractor.js.flow

@@ -22,18 +22,15 @@ const RIGHT_PARENTHESIS = '\\)';
 const WHITESPACE = '\\s*';
 const OPTIONAL_COMMA = '(:?,\\s*)?';
 
-function createRegExp(
-  parts /*: $ReadOnlyArray<string> */,
-  flags /*: string */,
-) {
+function createRegExp(parts /*: ReadonlyArray<string> */, flags /*: string */) {
   return new RegExp(parts.join(''), flags);
 }
 
-function alternatives(...parts /*: $ReadOnlyArray<string> */) {
+function alternatives(...parts /*: ReadonlyArray<string> */) {
   return `(?:${parts.join('|')})`;
 }
 
-function functionCallStart(...names /*: $ReadOnlyArray<string> */) {
+function functionCallStart(...names /*: ReadonlyArray<string> */) {
   return [
     NOT_A_DOT,
     WORD_SEPARATOR,

package/src/plugins/dependencies/worker.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @oncall react_native
+ */
+
+import type {
+  MetadataWorker,
+  V8Serializable,
+  WorkerMessage,
+} from '../../flow-types';
+
+declare class DependencyExtractorWorker implements MetadataWorker {
+  constructor(opts: Readonly<{dependencyExtractor: null | undefined | string}>);
+  processFile(
+    data: WorkerMessage,
+    utils: Readonly<{getContent: () => Buffer}>,
+  ): V8Serializable;
+}
+export = DependencyExtractorWorker;

package/src/plugins/dependencies/worker.js

@@ -0,0 +1,24 @@
+"use strict";
+
+const defaultDependencyExtractor = require("./dependencyExtractor");
+module.exports = class DependencyExtractorWorker {
+  #dependencyExtractor;
+  constructor({ dependencyExtractor }) {
+    if (dependencyExtractor != null) {
+      this.#dependencyExtractor = require(dependencyExtractor);
+    }
+  }
+  processFile(data, utils) {
+    const content = utils.getContent().toString();
+    const { filePath } = data;
+    const dependencies =
+      this.#dependencyExtractor != null
+        ? this.#dependencyExtractor.extract(
+            content,
+            filePath,
+            defaultDependencyExtractor.extract,
+          )
+        : defaultDependencyExtractor.extract(content);
+    return Array.from(dependencies);
+  }
+};

package/src/plugins/dependencies/worker.js.flow

@@ -0,0 +1,53 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall react_native
+ */
+
+/* eslint-disable import/no-commonjs */
+
+'use strict';
+
+const defaultDependencyExtractor = require('./dependencyExtractor');
+
+/*::
+import type {MetadataWorker, WorkerMessage, V8Serializable, DependencyExtractor} from '../../flow-types';
+*/
+
+module.exports = class DependencyExtractorWorker /*:: implements MetadataWorker */ {
+  /*:: + */ #dependencyExtractor /*: ?DependencyExtractor */;
+
+  constructor(
+    {dependencyExtractor} /*: Readonly<{dependencyExtractor: ?string}> */,
+  ) {
+    if (dependencyExtractor != null) {
+      // $FlowFixMe[unsupported-syntax] - dynamic require
+      this.#dependencyExtractor = require(dependencyExtractor);
+    }
+  }
+
+  processFile(
+    data /*: WorkerMessage */,
+    utils /*: Readonly<{getContent: () => Buffer}> */,
+  ) /*: V8Serializable */ {
+    const content = utils.getContent().toString();
+    const {filePath} = data;
+
+    const dependencies =
+      this.#dependencyExtractor != null
+        ? this.#dependencyExtractor.extract(
+            content,
+            filePath,
+            defaultDependencyExtractor.extract,
+          )
+        : defaultDependencyExtractor.extract(content);
+
+    // Return as array (PerFileData type)
+    return Array.from(dependencies);
+  }
+};

package/src/plugins/haste/HasteConflictsError.js.flow

@@ -14,9 +14,9 @@ import type {HasteConflict} from '../../flow-types';
 import path from 'path';
 
 export class HasteConflictsError extends Error {
-  #conflicts: $ReadOnlyArray<HasteConflict>;
+  #conflicts: ReadonlyArray<HasteConflict>;
 
-  constructor(conflicts: $ReadOnlyArray<HasteConflict>) {
+  constructor(conflicts: ReadonlyArray<HasteConflict>) {
     super(
       `Found ${conflicts.length} Haste conflict(s). Haste module IDs must be globally unique in the codebase.`,
     );

package/src/plugins/haste/computeConflicts.js

@@ -10,7 +10,8 @@ var _path = _interopRequireDefault(require("path"));
 function _interopRequireDefault(e) {
   return e && e.__esModule ? e : { default: e };
 }
-function computeHasteConflicts({ duplicates, map, rootDir }) {
+function computeHasteConflicts(options) {
+  const { duplicates, map, rootDir } = options;
   const conflicts = [];
   for (const [id, dupsByPlatform] of duplicates.entries()) {
     for (const [platform, conflictingModules] of dupsByPlatform) {

package/src/plugins/haste/computeConflicts.js.flow

@@ -21,18 +21,17 @@ type Conflict = {
   type: 'duplicate' | 'shadowing',
 };
 
-export function computeHasteConflicts({
-  duplicates,
-  map,
-  rootDir,
-}: $ReadOnly<{
-  duplicates: $ReadOnlyMap<
-    string,
-    $ReadOnlyMap<string, $ReadOnlyMap<string, number>>,
-  >,
-  map: $ReadOnlyMap<string, HasteMapItem>,
-  rootDir: string,
-}>): Array<Conflict> {
+export function computeHasteConflicts(
+  options: Readonly<{
+    duplicates: ReadonlyMap<
+      string,
+      ReadonlyMap<string, ReadonlyMap<string, number>>,
+    >,
+    map: ReadonlyMap<string, HasteMapItem>,
+    rootDir: string,
+  }>,
+): Array<Conflict> {
+  const {duplicates, map, rootDir} = options;
   const conflicts: Array<Conflict> = [];
 
   // Add duplicates reported by metro-file-map

package/src/plugins/haste/getPlatformExtension.js.flow

@@ -4,14 +4,14 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @format
  * @flow strict
+ * @format
  */
 
 // Extract platform extension: index.ios.js -> ios
 export default function getPlatformExtension(
   file: string,
-  platforms: $ReadOnlySet<string>,
+  platforms: ReadonlySet<string>,
 ): ?string {
   const last = file.lastIndexOf('.');
   const secondToLast = file.lastIndexOf('.', last - 1);