lib: convert WeakMaps in cjs loader with private symbol properties · nodejs/node@3a2d8bf

ReflectSet,

RegExpPrototypeExec,

SafeMap,

SafeWeakMap,

String,

StringPrototypeCharAt,

StringPrototypeCharCodeAt,

StringPrototypeStartsWith,

Symbol,

} = primordials;

const {

privateSymbols: {

module_source_private_symbol,

module_export_names_private_symbol,

module_circular_visited_private_symbol,

module_export_private_symbol,

module_parent_private_symbol,

},

} = internalBinding('util');

const { kEvaluated } = internalBinding('module_wrap');

// Map used to store CJS parsing data or for ESM loading.

const importedCJSCache = new SafeWeakMap();

// Internal properties for Module instances.

/**

* Cached {@link Module} source string.

*/

const kModuleSource = module_source_private_symbol;

/**

* Cached {@link Module} export names for ESM loader.

*/

const kModuleExportNames = module_export_names_private_symbol;

/**

* {@link Module} circular dependency visited flag.

*/

const kModuleCircularVisited = module_circular_visited_private_symbol;

/**

* Map of already-loaded CJS modules to use.

* {@link Module} export object snapshot for ESM loader.

*/

const cjsExportsCache = new SafeWeakMap();

const requiredESMSourceCache = new SafeWeakMap();

const kModuleExport = module_export_private_symbol;

/**

* {@link Module} parent module.

*/

const kModuleParent = module_parent_private_symbol;

const kIsMainSymbol = Symbol('kIsMainSymbol');

const kIsCachedByESMLoader = Symbol('kIsCachedByESMLoader');

const kRequiredModuleSymbol = Symbol('kRequiredModuleSymbol');

const kIsExecuting = Symbol('kIsExecuting');

// Set first due to cycle with ESM loader functions.

module.exports = {

cjsExportsCache,

importedCJSCache,

kModuleSource,

kModuleExport,

kModuleExportNames,

kModuleCircularVisited,

initializeCJS,

Module,

wrapSafe,

}

}

/** @type {Map<Module, Module>} */

const moduleParentCache = new SafeWeakMap();

/**

* Create a new module instance.

* @param {string} id

this.id = id;

this.path = path.dirname(id);

setOwnProperty(this, 'exports', {});

moduleParentCache.set(this, parent);

this[kModuleParent] = parent;

updateChildren(parent, this, false);

this.filename = null;

this.loaded = false;

/**

* Get the parent of the current module from our cache.

* @this {Module}

*/

function getModuleParent() {

return moduleParentCache.get(this);

return this[kModuleParent];

}

/**

* Set the parent of the current module in our cache.

* @this {Module}

* @param {Module} value

*/

function setModuleParent(value) {

moduleParentCache.set(this, value);

this[kModuleParent] = value;

}

let debug = require('internal/util/debuglog').debuglog('module', (fn) => {

const requiredESM = module[kRequiredModuleSymbol];

if (requiredESM && requiredESM.getStatus() !== kEvaluated) {

let message = `Cannot require() ES Module ${module.id} in a cycle.`;

const parent = moduleParentCache.get(module);

const parent = module[kModuleParent];

if (parent) {

message += ` (from ${parent.filename})`;

}

const cachedModule = Module._cache[filename];

if (cachedModule !== undefined) {

updateChildren(parent, cachedModule, true);

if (!cachedModule.loaded) {

// If it's not cached by the ESM loader, the loading request

// comes from required CJS, and we can consider it a circular

// dependency when it's cached.

if (!cachedModule[kIsCachedByESMLoader]) {

return getExportsForCircularRequire(cachedModule);

}

// If it's cached by the ESM loader as a way to indirectly pass

// the module in to avoid creating it twice, the loading request

// come from imported CJS. In that case use the importedCJSCache

// to determine if it's loading or not.

const importedCJSMetadata = importedCJSCache.get(cachedModule);

if (importedCJSMetadata.loading) {

return getExportsForCircularRequire(cachedModule);

}

importedCJSMetadata.loading = true;

} else {

if (cachedModule.loaded) {

return cachedModule.exports;

}

// If it's not cached by the ESM loader, the loading request

// comes from required CJS, and we can consider it a circular

// dependency when it's cached.

if (!cachedModule[kIsCachedByESMLoader]) {

return getExportsForCircularRequire(cachedModule);

}

// If it's cached by the ESM loader as a way to indirectly pass

// the module in to avoid creating it twice, the loading request

// come from imported CJS. In that case use the kModuleCircularVisited

// to determine if it's loading or not.

if (cachedModule[kModuleCircularVisited]) {

return getExportsForCircularRequire(cachedModule);

}

// This is an ESM loader created cache entry, mark it as visited and fallthrough to loading the module.

cachedModule[kModuleCircularVisited] = true;

}

if (BuiltinModule.canBeRequiredWithoutScheme(filename)) {

const requireStack = [];

for (let cursor = parent;

cursor;

cursor = moduleParentCache.get(cursor)) {

cursor = cursor[kModuleParent]) {

ArrayPrototypePush(requireStack, cursor.filename || cursor.id);

}

let message = `Cannot find module '${request}'`;

// Create module entry at load time to snapshot exports correctly

const exports = this.exports;

// Preemptively cache for ESM loader.

if (!cjsExportsCache.has(this)) {

cjsExportsCache.set(this, exports);

}

this[kModuleExport] = exports;

};

/**

const isMain = mod[kIsMainSymbol];

// TODO(joyeecheung): we may want to invent optional special handling for default exports here.

// For now, it's good enough to be identical to what `import()` returns.

mod.exports = cascadedLoader.importSyncForRequire(mod, filename, source, isMain, moduleParentCache.get(mod));

mod.exports = cascadedLoader.importSyncForRequire(mod, filename, source, isMain, mod[kModuleParent]);

}

/**

// Only modules being require()'d really need to avoid TLA.

if (loadAsESM) {

// Pass the source into the .mjs extension handler indirectly through the cache.

requiredESMSourceCache.set(this, content);

this[kModuleSource] = content;

loadESMFromCJS(this, filename);

return;

}

* @returns {string}

*/

function getMaybeCachedSource(mod, filename) {

const cached = importedCJSCache.get(mod);

// If already analyzed the source, then it will be cached.

let content;

if (cached?.source) {

content = cached.source;

cached.source = undefined;

if (mod[kModuleSource] !== undefined) {

content = mod[kModuleSource];

mod[kModuleSource] = undefined;

} else {

// TODO(joyeecheung): we can read a buffer instead to speed up

// compilation.

content = requiredESMSourceCache.get(mod) ?? fs.readFileSync(filename, 'utf8');

content = fs.readFileSync(filename, 'utf8');

}

return content;

}

}

// This is an error path because `require` of a `.js` file in a `"type": "module"` scope is not allowed.

const parent = moduleParentCache.get(module);

const parent = module[kModuleParent];

const parentPath = parent?.filename;

const packageJsonPath = path.resolve(pkg.path, 'package.json');

const usesEsm = containsModuleSyntax(content, filename);