fixup! module: integrate TypeScript into compile cache

Author: joyeecheung

lib/internal/modules/typescript.js

@@ -93,8 +93,9 @@ function stripTypeScriptTypes(code, options = kEmptyObject) {
 }
 
 /**
+ * @typedef {'strip-only' | 'transform'} TypeScriptMode
  * @typedef {object} TypeScriptOptions
- * @property {'transform'|'strip-only'} mode Mode.
+ * @property {TypeScriptMode} mode Mode.
  * @property {boolean} sourceMap Whether to generate source maps.
  * @property {string|undefined} filename Filename.
  */
@@ -122,7 +123,7 @@ function processTypeScriptCode(code, options) {
 
 /**
  * Get the type enum used for compile cache.
- * @param {'strip-only'|'transform'} mode Mode of transpilation.
+ * @param {TypeScriptMode} mode Mode of transpilation.
  * @param {boolean} sourceMap Whether source maps are enabled.
  * @returns {number}
  */
@@ -158,6 +159,11 @@ function stripTypeScriptModuleTypes(source, filename, emitWarning = true) {
   // as checking process.env equally involves calling into C++ anyway, and
   // the compile cache can be enabled dynamically.
   const type = getCachedCodeType(mode, sourceMap);
+  // Get a compile cache entry into the native compile cache store,
+  // keyed by the filename. If the cache can already be loaded on disk,
+  // cached.transpiled contains the cached string. Otherwise we should do
+  // the transpilation and save it in the native store later using
+  // saveCompileCacheEntry().
   const cached = (filename ? getCompileCacheEntry(source, filename, type) : undefined);
   if (cached?.transpiled) {  // TODO(joyeecheung): return Buffer here.
     return cached.transpiled;
@@ -171,6 +177,11 @@ function stripTypeScriptModuleTypes(source, filename, emitWarning = true) {
 
   const transpiled = processTypeScriptCode(source, options);
   if (cached) {
+    // cached.external contains a pointer to the native cache entry.
+    // The cached object would be unreachable once it's out of scope,
+    // but the pointer inside cached.external would stay around for reuse until
+    // environment shutdown or when the cache is manually flushed
+    // to disk. Unwrap it in JS before passing into C++ since it's faster.
     saveCompileCacheEntry(cached.external, transpiled);
   }
   return transpiled;

src/node_modules.cc

@@ -24,10 +24,13 @@ using v8::Array;
 using v8::Context;
 using v8::FunctionCallbackInfo;
 using v8::HandleScope;
+using v8::Integer;
 using v8::Isolate;
 using v8::Local;
 using v8::LocalVector;
+using v8::Name;
 using v8::NewStringType;
+using v8::Null;
 using v8::Object;
 using v8::ObjectTemplate;
 using v8::Primitive;
@@ -609,20 +612,20 @@ void BindingData::CreatePerContextProperties(Local<Object> target,
                              compile_cache_status_values.data(),
                              compile_cache_status_values.size())));
 
-  LocalVector<v8::Name> cached_code_type_keys(isolate);
+  LocalVector<Name> cached_code_type_keys(isolate);
   LocalVector<Value> cached_code_type_values(isolate);
 
 #define V(type, value)                                                         \
   cached_code_type_keys.push_back(FIXED_ONE_BYTE_STRING(isolate, #type));      \
-  cached_code_type_values.push_back(v8::Integer::New(isolate, value));         \
+  cached_code_type_values.push_back(Integer::New(isolate, value));             \
   DCHECK_EQ(value, cached_code_type_values.size() - 1);
   CACHED_CODE_TYPES(V)
 #undef V
 
   USE(target->Set(context,
                   FIXED_ONE_BYTE_STRING(isolate, "cachedCodeTypes"),
                   Object::New(isolate,
-                              v8::Null(isolate),
+                              Null(isolate),
                               cached_code_type_keys.data(),
                               cached_code_type_values.data(),
                               cached_code_type_keys.size())));