Use gensync fs.stat

packages/babel-core/src/config/caching.js

@@ -50,10 +50,9 @@ export function makeWeakCache<ArgT, ResultT, SideChannel>(
 
 export function makeWeakCacheSync<ArgT, ResultT, SideChannel>(
   handler: (ArgT, CacheConfigurator<SideChannel>) => ResultT,
-  invalidateAsync?: boolean,
 ): (ArgT, SideChannel) => ResultT {
   return synchronize<[ArgT, SideChannel], ResultT>(
-    makeWeakCache<ArgT, ResultT, SideChannel>(handler, invalidateAsync),
+    makeWeakCache<ArgT, ResultT, SideChannel>(handler, false),
   );
 }
 
@@ -70,10 +69,9 @@ export function makeStrongCache<ArgT, ResultT, SideChannel>(
 
 export function makeStrongCacheSync<ArgT, ResultT, SideChannel>(
   handler: (ArgT, CacheConfigurator<SideChannel>) => ResultT,
-  invalidateAsync?: boolean,
 ): (ArgT, SideChannel) => ResultT {
   return synchronize<[ArgT, SideChannel], ResultT>(
-    makeStrongCache<ArgT, ResultT, SideChannel>(handler, invalidateAsync),
+    makeStrongCache<ArgT, ResultT, SideChannel>(handler, false),
   );
 }
 
@@ -89,7 +87,7 @@ function makeCachedFunction<ArgT, ResultT, SideChannel, Cache: *>(
     const callCache =
       invalidateAsync && (yield* isAsync()) ? callCacheAsync : callCacheSync;
 
-    const cached = yield* getCachedValue(callCacheAsync, arg, data);
+    const cached = yield* getCachedValue(callCache, arg, data);
     if (cached.valid) {
       return cached.value;
     }

packages/babel-core/src/config/files/configuration.js

@@ -206,6 +206,7 @@ const readConfigJS = makeStrongCache(function* readConfigJS(
   }
 
   if (typeof options.then === "function") {
+    // When removing this error, ENABLE the invalidateAsync param of makeStrongCache
     throw new Error(
       `You appear to be using an async configuration, ` +
         `which your current version of Babel does not support. ` +

packages/babel-core/src/config/files/utils.js

@@ -1,10 +1,10 @@
 // @flow
 
-import nodeFs from "fs";
 import type { Gensync, Handler } from "gensync";
 
 import { makeStrongCache, type CacheConfigurator } from "../caching";
 import * as fs from "../../gensync-utils/fs";
+import { forwardAsync } from "../../gensync-utils/async";
 
 export function makeStaticFileCache<T>(
   fn: (string, string) => T,
@@ -13,26 +13,24 @@ export function makeStaticFileCache<T>(
     filepath: string,
     cache: CacheConfigurator<?void>,
   ): Handler<null | T> {
-    if (cache.invalidate(() => fileMtimeSync(filepath)) === null) {
+    const cached = yield* forwardAsync(fileMtime, run =>
+      cache.invalidate(() => run(filepath)),
+    );
+
+    if (cached === null) {
       cache.forever();
       return null;
     }
 
     return fn(filepath, yield* fs.readFile(filepath, "utf8"));
-  }): Gensync<any, *>);
+  },
+  /* invalidateAsync */ true): Gensync<any, *>);
 }
 
-// NOTE: While an asynchronous version of `statSync` exists,
-// this function always uses the synchronous version.
-// If we sometimes used the async version, we would need to
-// the cache generated from an async call to Babel if the
-// current call is sync, because the callback passed to
-// cache.invalidate must now be synchronous.
-// This is technically a breaking change in the cache's behavior,
-// and it's probably not worth it anyway.
-function fileMtimeSync(filepath: string): number | null {
+function* fileMtime(filepath: string): Handler<number | null> {
   try {
-    return +nodeFs.statSync(filepath).mtime;
+    const stats = yield* fs.stat(filepath);
+    return +stats.mtime;
   } catch (e) {
     if (e.code !== "ENOENT" && e.code !== "ENOTDIR") throw e;
   }

packages/babel-core/src/config/full.js

@@ -208,7 +208,9 @@ const loadDescriptor = makeWeakCache(function*(
   }
 
   if (typeof item.then === "function") {
-    yield* [];
+    yield* []; // if we want to support async plugins
+
+    // When enabling this, ENABLE the invalidateAsync param of makeStrongCache
     throw new Error(
       `You appear to be using an async plugin, ` +
         `which your current version of Babel does not support. ` +
@@ -285,7 +287,8 @@ const instantiatePlugin = makeWeakCache(function*(
   }
 
   return new Plugin(plugin, options, alias);
-});
+},
+/* invalidateAsync */ true);
 
 const validateIfOptionNeedsFilename = (
   options: ValidatedOptions,

packages/babel-core/src/gensync-utils/fs.js

@@ -1,6 +1,6 @@
 // @flow
 
-import fs from "fs";
+import fs, { Stats } from "fs";
 import gensync from "gensync";
 
 export const readFile = gensync<[string, "utf8"], string>({
@@ -12,3 +12,8 @@ export const exists = gensync<[string], boolean>({
   sync: fs.existsSync,
   errback: (path, cb) => fs.exists(path, res => cb(null, res)),
 });
+
+export const stat = gensync<[string], Stats>({
+  sync: fs.statSync,
+  errback: fs.stat,
+});