diff --git a/packages/jest-haste-map/src/index.ts b/packages/jest-haste-map/src/index.ts
index 70965909d79d..8340576df5bc 100644
--- a/packages/jest-haste-map/src/index.ts
+++ b/packages/jest-haste-map/src/index.ts
@@ -341,43 +341,7 @@ class HasteMap extends EventEmitter {
 
   build(): Promise<InternalHasteMapObject> {
     if (!this._buildPromise) {
-      this._buildPromise = (async () => {
-        const data = await this._buildFileMap();
-
-        // Persist when we don't know if files changed (changedFiles undefined)
-        // or when we know a file was changed or deleted.
-        let hasteMap: InternalHasteMap;
-        if (
-          data.changedFiles === undefined ||
-          data.changedFiles.size > 0 ||
-          data.removedFiles.size > 0
-        ) {
-          hasteMap = await this._buildHasteMap(data);
-          this._persist(hasteMap);
-        } else {
-          hasteMap = data.hasteMap;
-        }
-
-        const rootDir = this._options.rootDir;
-        const hasteFS = new HasteFS({
-          files: hasteMap.files,
-          rootDir,
-        });
-        const moduleMap = new HasteModuleMap({
-          duplicates: hasteMap.duplicates,
-          map: hasteMap.map,
-          mocks: hasteMap.mocks,
-          rootDir,
-        });
-        const __hasteMapForTest =
-          (process.env.NODE_ENV === 'test' && hasteMap) || null;
-        await this._watch(hasteMap);
-        return {
-          __hasteMapForTest,
-          hasteFS,
-          moduleMap,
-        };
-      })();
+      this._buildPromise = this._runBuild();
     }
     return this._buildPromise;
   }
@@ -391,7 +355,7 @@ class HasteMap extends EventEmitter {
     try {
       hasteMap = serializer.readFileSync(this._cachePath);
     } catch (err) {
-      hasteMap = this._createEmptyMap();
+      hasteMap = createEmptyMap();
     }
 
     return hasteMap;
@@ -410,18 +374,12 @@ class HasteMap extends EventEmitter {
   /**
    * 2. crawl the file system.
    */
-  private async _buildFileMap(): Promise<{
+  private _buildFileMap(): Promise<{
     removedFiles: FileData;
     changedFiles?: FileData;
     hasteMap: InternalHasteMap;
   }> {
-    let hasteMap: InternalHasteMap;
-    try {
-      const read = this._options.resetCache ? this._createEmptyMap : this.read;
-      hasteMap = await read.call(this);
-    } catch {
-      hasteMap = this._createEmptyMap();
-    }
+    const hasteMap = this._options.resetCache ? createEmptyMap() : this.read();
     return this._crawl(hasteMap);
   }
 
@@ -642,7 +600,49 @@ class HasteMap extends EventEmitter {
       .then(workerReply, workerError);
   }
 
-  private async _buildHasteMap(data: {
+  private _runBuild(): Promise<InternalHasteMapObject> {
+    let hasteMap: InternalHasteMap;
+    return this._buildFileMap()
+      .then(data => {
+        // Persist when we don't know if files changed (changedFiles undefined)
+        // or when we know a file was changed or deleted.
+        if (
+          data.changedFiles === undefined ||
+          data.changedFiles.size > 0 ||
+          data.removedFiles.size > 0
+        ) {
+          return this._buildHasteMap(data);
+        } else {
+          return data.hasteMap;
+        }
+      })
+      .then(map => {
+        hasteMap = map;
+        return this._watch(hasteMap);
+      })
+      .then(() => {
+        const rootDir = this._options.rootDir;
+        const hasteFS = new HasteFS({
+          files: hasteMap.files,
+          rootDir,
+        });
+        const moduleMap = new HasteModuleMap({
+          duplicates: hasteMap.duplicates,
+          map: hasteMap.map,
+          mocks: hasteMap.mocks,
+          rootDir,
+        });
+        const __hasteMapForTest =
+          (process.env.NODE_ENV === 'test' && hasteMap) || null;
+        return {
+          __hasteMapForTest,
+          hasteFS,
+          moduleMap,
+        };
+      });
+  }
+
+  private _buildHasteMap(data: {
     removedFiles: FileData;
     changedFiles?: FileData;
     hasteMap: InternalHasteMap;
@@ -687,16 +687,18 @@ class HasteMap extends EventEmitter {
       }
     }
 
-    try {
-      await Promise.all(promises);
-      this._cleanup();
-      hasteMap.map = map;
-      hasteMap.mocks = mocks;
-      return hasteMap;
-    } catch (error) {
-      this._cleanup();
-      throw error;
-    }
+    return Promise.all(promises)
+      .then(() => {
+        this._cleanup();
+        hasteMap.map = map;
+        hasteMap.mocks = mocks;
+        this._persist(hasteMap);
+        return hasteMap;
+      })
+      .catch(error => {
+        this._cleanup();
+        throw error;
+      });
   }
 
   private _cleanup() {
@@ -1102,16 +1104,6 @@ class HasteMap extends EventEmitter {
     return true;
   }
 
-  private _createEmptyMap(): InternalHasteMap {
-    return {
-      clocks: new Map(),
-      duplicates: new Map(),
-      files: new Map(),
-      map: new Map(),
-      mocks: new Map(),
-    };
-  }
-
   static H: HType;
   static DuplicateError: typeof DuplicateError;
   static ModuleMap: typeof HasteModuleMap;
@@ -1129,6 +1121,16 @@ class DuplicateError extends Error {
   }
 }
 
+function createEmptyMap(): InternalHasteMap {
+  return {
+    clocks: new Map(),
+    duplicates: new Map(),
+    files: new Map(),
+    map: new Map(),
+    mocks: new Map(),
+  };
+}
+
 function copy<T extends Record<string, any>>(object: T): T {
   return Object.assign(Object.create(null), object);
 }