| FazBrowse GitHub Viewer | Trending | | Home |
| Tools: [Download Repo ZIP] [Original HTTPS Page] |
1 parent f1aa1ea commit 21bcd0e
8 files changed
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -38,7 +38,7 @@ | |||
| 38 | 38 | ||
| 39 | 39 | # Reset this number to 0 on major V8 upgrades. | |
| 40 | 40 | # Increment by one for each non-official patch applied to deps/v8. | |
| 41 | - 'v8_embedder_string': '-node.10', | ||
| 41 | + 'v8_embedder_string': '-node.11', | ||
| 42 | 42 | ||
| 43 | 43 | ##### V8 defaults for Node.js ##### | |
| 44 | 44 | ||
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -220,6 +220,13 @@ class V8_EXPORT Module : public Data { | |||
| 220 | 220 | Local<Context> context, Local<String> specifier, | |
| 221 | 221 | Local<FixedArray> import_attributes, Local<Module> referrer); | |
| 222 | 222 | ||
| 223 | + using ResolveModuleByIndexCallback = MaybeLocal<Module> (*)( | ||
| 224 | + Local<Context> context, size_t module_request_index, | ||
| 225 | + Local<Module> referrer); | ||
| 226 | + using ResolveSourceByIndexCallback = MaybeLocal<Object> (*)( | ||
| 227 | + Local<Context> context, size_t module_request_index, | ||
| 228 | + Local<Module> referrer); | ||
| 229 | + | ||
| 223 | 230 | /** | |
| 224 | 231 | * Instantiates the module and its dependencies. | |
| 225 | 232 | * | |
@@ -231,6 +238,16 @@ class V8_EXPORT Module : public Data { | |||
| 231 | 238 | Local<Context> context, ResolveModuleCallback module_callback, | |
| 232 | 239 | ResolveSourceCallback source_callback = nullptr); | |
| 233 | 240 | ||
| 241 | + /** | ||
| 242 | + * Similar to the variant that takes ResolveModuleCallback and | ||
| 243 | + * ResolveSourceCallback, but uses the index into the array that is returned | ||
| 244 | + * by GetModuleRequests() instead of the specifier and import attributes to | ||
| 245 | + * identify the requests. | ||
| 246 | + */ | ||
| 247 | + V8_WARN_UNUSED_RESULT Maybe<bool> InstantiateModule( | ||
| 248 | + Local<Context> context, ResolveModuleByIndexCallback module_callback, | ||
| 249 | + ResolveSourceByIndexCallback source_callback = nullptr); | ||
| 250 | + | ||
| 234 | 251 | /** | |
| 235 | 252 | * Evaluates the module and its dependencies. | |
| 236 | 253 | * | |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -2266,14 +2266,34 @@ int Module::GetIdentityHash() const { | |||
| 2266 | 2266 | return self->hash(); | |
| 2267 | 2267 | } | |
| 2268 | 2268 | ||
| 2269 | + Maybe<bool> Module::InstantiateModule( | ||
| 2270 | + Local<Context> context, ResolveModuleByIndexCallback module_callback, | ||
| 2271 | + ResolveSourceByIndexCallback source_callback) { | ||
| 2272 | + auto i_isolate = i::Isolate::Current(); | ||
| 2273 | + EnterV8Scope<> api_scope{i_isolate, context, | ||
| 2274 | + RCCId::kAPI_Module_InstantiateModule}; | ||
| 2275 | + | ||
| 2276 | + i::Module::UserResolveCallbacks callbacks; | ||
| 2277 | + callbacks.module_callback_by_index = module_callback; | ||
| 2278 | + callbacks.source_callback_by_index = source_callback; | ||
| 2279 | + if (!i::Module::Instantiate(i_isolate, Utils::OpenHandle(this), context, | ||
| 2280 | + callbacks)) { | ||
| 2281 | + return {}; | ||
| 2282 | + } | ||
| 2283 | + return Just(true); | ||
| 2284 | + } | ||
| 2285 | + | ||
| 2269 | 2286 | Maybe<bool> Module::InstantiateModule(Local<Context> context, | |
| 2270 | 2287 | ResolveModuleCallback module_callback, | |
| 2271 | 2288 | ResolveSourceCallback source_callback) { | |
| 2272 | 2289 | auto i_isolate = i::Isolate::Current(); | |
| 2273 | 2290 | EnterV8Scope<> api_scope{i_isolate, context, | |
| 2274 | 2291 | RCCId::kAPI_Module_InstantiateModule}; | |
| 2292 | + i::Module::UserResolveCallbacks callbacks; | ||
| 2293 | + callbacks.module_callback = module_callback; | ||
| 2294 | + callbacks.source_callback = source_callback; | ||
| 2275 | 2295 | if (!i::Module::Instantiate(i_isolate, Utils::OpenHandle(this), context, | |
| 2276 | - module_callback, source_callback)) { | ||
| 2296 | + callbacks)) { | ||
| 2277 | 2297 | return {}; | |
| 2278 | 2298 | } | |
| 2279 | 2299 | return Just(true); | |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -205,14 +205,12 @@ MaybeHandle<Cell> Module::ResolveExport(Isolate* isolate, Handle<Module> module, | |||
| 205 | 205 | ||
| 206 | 206 | bool Module::Instantiate(Isolate* isolate, Handle<Module> module, | |
| 207 | 207 | v8::Local<v8::Context> context, | |
| 208 | - v8::Module::ResolveModuleCallback module_callback, | ||
| 209 | - v8::Module::ResolveSourceCallback source_callback) { | ||
| 208 | + const Module::UserResolveCallbacks& callbacks) { | ||
| 210 | 209 | #ifdef DEBUG | |
| 211 | 210 | PrintStatusMessage(*module, "Instantiating module "); | |
| 212 | 211 | #endif // DEBUG | |
| 213 | 212 | ||
| 214 | - if (!PrepareInstantiate(isolate, module, context, module_callback, | ||
| 215 | - source_callback)) { | ||
| 213 | + if (!PrepareInstantiate(isolate, module, context, callbacks)) { | ||
| 216 | 214 | ResetGraph(isolate, module); | |
| 217 | 215 | DCHECK_EQ(module->status(), kUnlinked); | |
| 218 | 216 | return false; | |
@@ -231,11 +229,9 @@ bool Module::Instantiate(Isolate* isolate, Handle<Module> module, | |||
| 231 | 229 | return true; | |
| 232 | 230 | } | |
| 233 | 231 | ||
| 234 | - bool Module::PrepareInstantiate( | ||
| 235 | - Isolate* isolate, DirectHandle<Module> module, | ||
| 236 | - v8::Local<v8::Context> context, | ||
| 237 | - v8::Module::ResolveModuleCallback module_callback, | ||
| 238 | - v8::Module::ResolveSourceCallback source_callback) { | ||
| 232 | + bool Module::PrepareInstantiate(Isolate* isolate, DirectHandle<Module> module, | ||
| 233 | + v8::Local<v8::Context> context, | ||
| 234 | + const UserResolveCallbacks& callbacks) { | ||
| 239 | 235 | DCHECK_NE(module->status(), kEvaluating); | |
| 240 | 236 | DCHECK_NE(module->status(), kLinking); | |
| 241 | 237 | if (module->status() >= kPreLinking) return true; | |
@@ -244,8 +240,7 @@ bool Module::PrepareInstantiate( | |||
| 244 | 240 | ||
| 245 | 241 | if (IsSourceTextModule(*module)) { | |
| 246 | 242 | return SourceTextModule::PrepareInstantiate( | |
| 247 | - isolate, Cast<SourceTextModule>(module), context, module_callback, | ||
| 248 | - source_callback); | ||
| 243 | + isolate, Cast<SourceTextModule>(module), context, callbacks); | ||
| 249 | 244 | } else { | |
| 250 | 245 | return SyntheticModule::PrepareInstantiate( | |
| 251 | 246 | isolate, Cast<SyntheticModule>(module), context); | |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -57,14 +57,20 @@ class Module : public TorqueGeneratedModule<Module, HeapObject> { | |||
| 57 | 57 | // i.e. has a top-level await. | |
| 58 | 58 | V8_WARN_UNUSED_RESULT bool IsGraphAsync(Isolate* isolate) const; | |
| 59 | 59 | ||
| 60 | + struct UserResolveCallbacks { | ||
| 61 | + v8::Module::ResolveModuleCallback module_callback = nullptr; | ||
| 62 | + v8::Module::ResolveSourceCallback source_callback = nullptr; | ||
| 63 | + v8::Module::ResolveModuleByIndexCallback module_callback_by_index = nullptr; | ||
| 64 | + v8::Module::ResolveSourceByIndexCallback source_callback_by_index = nullptr; | ||
| 65 | + }; | ||
| 66 | + | ||
| 60 | 67 | // Implementation of spec operation ModuleDeclarationInstantiation. | |
| 61 | 68 | // Returns false if an exception occurred during instantiation, true | |
| 62 | 69 | // otherwise. (In the case where the callback throws an exception, that | |
| 63 | 70 | // exception is propagated.) | |
| 64 | 71 | static V8_WARN_UNUSED_RESULT bool Instantiate( | |
| 65 | 72 | Isolate* isolate, Handle<Module> module, v8::Local<v8::Context> context, | |
| 66 | - v8::Module::ResolveModuleCallback module_callback, | ||
| 67 | - v8::Module::ResolveSourceCallback source_callback); | ||
| 73 | + const UserResolveCallbacks& callbacks); | ||
| 68 | 74 | ||
| 69 | 75 | // Implementation of spec operation ModuleEvaluation. | |
| 70 | 76 | static V8_WARN_UNUSED_RESULT MaybeDirectHandle<Object> Evaluate( | |
@@ -99,9 +105,7 @@ class Module : public TorqueGeneratedModule<Module, HeapObject> { | |||
| 99 | 105 | ||
| 100 | 106 | static V8_WARN_UNUSED_RESULT bool PrepareInstantiate( | |
| 101 | 107 | Isolate* isolate, DirectHandle<Module> module, | |
| 102 | - v8::Local<v8::Context> context, | ||
| 103 | - v8::Module::ResolveModuleCallback module_callback, | ||
| 104 | - v8::Module::ResolveSourceCallback source_callback); | ||
| 108 | + v8::Local<v8::Context> context, const UserResolveCallbacks& callbacks); | ||
| 105 | 109 | static V8_WARN_UNUSED_RESULT bool FinishInstantiate( | |
| 106 | 110 | Isolate* isolate, Handle<Module> module, | |
| 107 | 111 | ZoneForwardList<Handle<SourceTextModule>>* stack, unsigned* dfs_index, | |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -346,9 +346,10 @@ MaybeHandle<Cell> SourceTextModule::ResolveExportUsingStarExports( | |||
| 346 | 346 | bool SourceTextModule::PrepareInstantiate( | |
| 347 | 347 | Isolate* isolate, DirectHandle<SourceTextModule> module, | |
| 348 | 348 | v8::Local<v8::Context> context, | |
| 349 | - v8::Module::ResolveModuleCallback module_callback, | ||
| 350 | - v8::Module::ResolveSourceCallback source_callback) { | ||
| 351 | - DCHECK_NE(module_callback, nullptr); | ||
| 349 | + const Module::UserResolveCallbacks& callbacks) { | ||
| 350 | + // One of the callbacks must be set, otherwise we cannot resolve. | ||
| 351 | + DCHECK_IMPLIES(callbacks.module_callback == nullptr, | ||
| 352 | + callbacks.module_callback_by_index != nullptr); | ||
| 352 | 353 | // Obtain requested modules. | |
| 353 | 354 | DirectHandle<SourceTextModuleInfo> module_info(module->info(), isolate); | |
| 354 | 355 | DirectHandle<FixedArray> module_requests(module_info->module_requests(), | |
@@ -364,11 +365,23 @@ bool SourceTextModule::PrepareInstantiate( | |||
| 364 | 365 | switch (module_request->phase()) { | |
| 365 | 366 | case ModuleImportPhase::kEvaluation: { | |
| 366 | 367 | v8::Local<v8::Module> api_requested_module; | |
| 367 | - if (!module_callback(context, v8::Utils::ToLocal(specifier), | ||
| 368 | - v8::Utils::FixedArrayToLocal(import_attributes), | ||
| 369 | - v8::Utils::ToLocal(Cast<Module>(module))) | ||
| 370 | - .ToLocal(&api_requested_module)) { | ||
| 371 | - return false; | ||
| 368 | + if (callbacks.module_callback != nullptr) { | ||
| 369 | + if (!callbacks | ||
| 370 | + .module_callback( | ||
| 371 | + context, v8::Utils::ToLocal(specifier), | ||
| 372 | + v8::Utils::FixedArrayToLocal(import_attributes), | ||
| 373 | + v8::Utils::ToLocal(Cast<Module>(module))) | ||
| 374 | + .ToLocal(&api_requested_module)) { | ||
| 375 | + return false; | ||
| 376 | + } | ||
| 377 | + } else { | ||
| 378 | + DCHECK_NOT_NULL(callbacks.module_callback_by_index); | ||
| 379 | + if (!callbacks | ||
| 380 | + .module_callback_by_index( | ||
| 381 | + context, i, v8::Utils::ToLocal(Cast<Module>(module))) | ||
| 382 | + .ToLocal(&api_requested_module)) { | ||
| 383 | + return false; | ||
| 384 | + } | ||
| 372 | 385 | } | |
| 373 | 386 | DirectHandle<Module> requested_module = | |
| 374 | 387 | Utils::OpenDirectHandle(*api_requested_module); | |
@@ -378,11 +391,23 @@ bool SourceTextModule::PrepareInstantiate( | |||
| 378 | 391 | case ModuleImportPhase::kSource: { | |
| 379 | 392 | DCHECK(v8_flags.js_source_phase_imports); | |
| 380 | 393 | v8::Local<v8::Object> api_requested_module_source; | |
| 381 | - if (!source_callback(context, v8::Utils::ToLocal(specifier), | ||
| 382 | - v8::Utils::FixedArrayToLocal(import_attributes), | ||
| 383 | - v8::Utils::ToLocal(Cast<Module>(module))) | ||
| 384 | - .ToLocal(&api_requested_module_source)) { | ||
| 385 | - return false; | ||
| 394 | + if (callbacks.source_callback != nullptr) { | ||
| 395 | + if (!callbacks | ||
| 396 | + .source_callback( | ||
| 397 | + context, v8::Utils::ToLocal(specifier), | ||
| 398 | + v8::Utils::FixedArrayToLocal(import_attributes), | ||
| 399 | + v8::Utils::ToLocal(Cast<Module>(module))) | ||
| 400 | + .ToLocal(&api_requested_module_source)) { | ||
| 401 | + return false; | ||
| 402 | + } | ||
| 403 | + } else { | ||
| 404 | + DCHECK_NOT_NULL(callbacks.source_callback_by_index); | ||
| 405 | + if (!callbacks | ||
| 406 | + .source_callback_by_index( | ||
| 407 | + context, i, v8::Utils::ToLocal(Cast<Module>(module))) | ||
| 408 | + .ToLocal(&api_requested_module_source)) { | ||
| 409 | + return false; | ||
| 410 | + } | ||
| 386 | 411 | } | |
| 387 | 412 | DirectHandle<JSReceiver> requested_module_source = | |
| 388 | 413 | Utils::OpenDirectHandle(*api_requested_module_source); | |
@@ -404,7 +429,7 @@ bool SourceTextModule::PrepareInstantiate( | |||
| 404 | 429 | DirectHandle<Module> requested_module( | |
| 405 | 430 | Cast<Module>(requested_modules->get(i)), isolate); | |
| 406 | 431 | if (!Module::PrepareInstantiate(isolate, requested_module, context, | |
| 407 | - module_callback, source_callback)) { | ||
| 432 | + callbacks)) { | ||
| 408 | 433 | return false; | |
| 409 | 434 | } | |
| 410 | 435 | } | |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -172,8 +172,7 @@ class SourceTextModule | |||
| 172 | 172 | static V8_WARN_UNUSED_RESULT bool PrepareInstantiate( | |
| 173 | 173 | Isolate* isolate, DirectHandle<SourceTextModule> module, | |
| 174 | 174 | v8::Local<v8::Context> context, | |
| 175 | - v8::Module::ResolveModuleCallback module_callback, | ||
| 176 | - v8::Module::ResolveSourceCallback source_callback); | ||
| 175 | + const Module::UserResolveCallbacks& callbacks); | ||
| 177 | 176 | static V8_WARN_UNUSED_RESULT bool FinishInstantiate( | |
| 178 | 177 | Isolate* isolate, Handle<SourceTextModule> module, | |
| 179 | 178 | ZoneForwardList<Handle<SourceTextModule>>* stack, unsigned* dfs_index, | |
| Back | FazBrowse Home | New Git URL |
0 commit comments