module: detect ESM syntax by trying to recompile as SourceTextModule · nodejs/node@b07ad39

return nullptr;

}

// new ModuleWrap(url, context, source, lineOffset, columnOffset, cachedData)

Local<PrimitiveArray> ModuleWrap::GetHostDefinedOptions(

Isolate* isolate, Local<Symbol> id_symbol) {

Local<PrimitiveArray> host_defined_options =

PrimitiveArray::New(isolate, HostDefinedOptions::kLength);

host_defined_options->Set(isolate, HostDefinedOptions::kID, id_symbol);

return host_defined_options;

}

// new ModuleWrap(url, context, source, lineOffset, columnOffset[, cachedData]);

// new ModuleWrap(url, context, source, lineOffset, columOffset,

// hostDefinedOption)

// idSymbol);

// new ModuleWrap(url, context, exportNames, evaluationCallback[, cjsModule])

void ModuleWrap::New(const FunctionCallbackInfo<Value>& args) {

CHECK(args.IsConstructCall());

int column_offset = 0;

bool synthetic = args[2]->IsArray();

bool can_use_builtin_cache = false;

Local<PrimitiveArray> host_defined_options =

PrimitiveArray::New(isolate, HostDefinedOptions::kLength);

Local<Symbol> id_symbol;

// cjsModule])

CHECK(args[3]->IsFunction());

} else {

// new ModuleWrap(url, context, source, lineOffset, columOffset, cachedData)

// new ModuleWrap(url, context, source, lineOffset, columOffset[,

// cachedData]);

// new ModuleWrap(url, context, source, lineOffset, columOffset,

// hostDefinedOption)

// idSymbol);

CHECK(args[2]->IsString());

CHECK(args[3]->IsNumber());

line_offset = args[3].As<Int32>()->Value();

CHECK(args[4]->IsNumber());

column_offset = args[4].As<Int32>()->Value();

if (args[5]->IsSymbol()) {

id_symbol = args[5].As<Symbol>();

can_use_builtin_cache =

(id_symbol ==

realm->isolate_data()->source_text_module_default_hdo());

} else {

id_symbol = Symbol::New(isolate, url);

}

host_defined_options->Set(isolate, HostDefinedOptions::kID, id_symbol);

host_defined_options = GetHostDefinedOptions(isolate, id_symbol);

if (that->SetPrivate(context,

realm->isolate_data()->host_defined_option_symbol(),

module = Module::CreateSyntheticModule(isolate, url, export_names,

SyntheticModuleEvaluationStepsCallback);

} else {

ScriptCompiler::CachedData* cached_data = nullptr;

// When we are compiling for the default loader, this will be

// std::nullopt, and CompileSourceTextModule() should use

// on-disk cache (not present on v20.x).

std::optional<v8::ScriptCompiler::CachedData*> user_cached_data;

if (id_symbol !=

realm->isolate_data()->source_text_module_default_hdo()) {

user_cached_data = nullptr;

}

if (args[5]->IsArrayBufferView()) {

CHECK(!can_use_builtin_cache); // We don't use this option internally.

Local<ArrayBufferView> cached_data_buf = args[5].As<ArrayBufferView>();

uint8_t* data =

static_cast<uint8_t*>(cached_data_buf->Buffer()->Data());

cached_data =

user_cached_data =

new ScriptCompiler::CachedData(data + cached_data_buf->ByteOffset(),

cached_data_buf->ByteLength());

}

Local<String> source_text = args[2].As<String>();

ScriptOrigin origin(isolate,

url,

line_offset,

column_offset,

true, // is cross origin

-1, // script id

Local<Value>(), // source map URL

false, // is opaque (?)

false, // is WASM

true, // is ES Module

host_defined_options);

ScriptCompiler::Source source(source_text, origin, cached_data);

ScriptCompiler::CompileOptions options;

if (source.GetCachedData() == nullptr) {

options = ScriptCompiler::kNoCompileOptions;

} else {

options = ScriptCompiler::kConsumeCodeCache;

}

if (!ScriptCompiler::CompileModule(isolate, &source, options)

bool cache_rejected = false;

if (!CompileSourceTextModule(realm,

source_text,

url,

line_offset,

column_offset,

host_defined_options,

user_cached_data,

&cache_rejected)

.ToLocal(&module)) {

if (try_catch.HasCaught() && !try_catch.HasTerminated()) {

CHECK(!try_catch.Message().IsEmpty());

}

return;

}

if (options == ScriptCompiler::kConsumeCodeCache &&

source.GetCachedData()->rejected) {

if (user_cached_data.has_value() && user_cached_data.value() != nullptr &&

cache_rejected) {

THROW_ERR_VM_MODULE_CACHED_DATA_REJECTED(

realm, "cachedData buffer was rejected");

try_catch.ReThrow();

args.GetReturnValue().Set(that);

}

MaybeLocal<Module> ModuleWrap::CompileSourceTextModule(

Realm* realm,

Local<String> source_text,

Local<String> url,

int line_offset,

int column_offset,

Local<PrimitiveArray> host_defined_options,

std::optional<ScriptCompiler::CachedData*> user_cached_data,

bool* cache_rejected) {

Isolate* isolate = realm->isolate();

EscapableHandleScope scope(isolate);

ScriptOrigin origin(isolate,

url,

line_offset,

column_offset,

true, // is cross origin

-1, // script id

Local<Value>(), // source map URL

false, // is opaque (?)

false, // is WASM

true, // is ES Module

host_defined_options);

ScriptCompiler::CachedData* cached_data = nullptr;

// When compiling for the default loader, user_cached_data is std::nullptr.

// When compiling for vm.Module, it's either nullptr or a pointer to the

// cached data.

if (user_cached_data.has_value()) {

cached_data = user_cached_data.value();

}

ScriptCompiler::Source source(source_text, origin, cached_data);

ScriptCompiler::CompileOptions options;

if (cached_data == nullptr) {

options = ScriptCompiler::kNoCompileOptions;

} else {

options = ScriptCompiler::kConsumeCodeCache;

}

Local<Module> module;

if (!ScriptCompiler::CompileModule(isolate, &source, options)

.ToLocal(&module)) {

return scope.EscapeMaybe(MaybeLocal<Module>());

}

if (options == ScriptCompiler::kConsumeCodeCache) {

*cache_rejected = source.GetCachedData()->rejected;

}

return scope.Escape(module);

}

static Local<Object> createImportAttributesContainer(

Realm* realm,

Isolate* isolate,