AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity
10e158862c
v8/test/cctest/test-modules.cc

1278 lines
48 KiB
C++
Raw Normal View History

[modules] Expand API to allow linking and use it in d8 This patch gives the ability for the embedder to ask for the module requests of a module, and to pass a ResolveCallback into Module::Instantiate(). In d8, I've implemented a simple module_map that's used along with this API to allow loading, compiling, instantiating, and evaluating a whole tree of modules. No path resolution is yet implemented, meaning that all import paths are relative to whatever directory d8 runs in. And no imports are linked to the exports of the requested module. BUG=v8:1569 Review-Url: https://codereview.chromium.org/2351113004 Cr-Commit-Position: refs/heads/master@{#39569}
2016-09-20 23:38:58 +00:00
// Copyright 2016 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
Move remaining files in src/ TBR=mvstanton@chromium.org,neis@chromium.org,ahaas@chromium.org Bug: v8:9247 Change-Id: I5433c863a54f3412d73df0d38aba3fdbcfac7ebe Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1627973 Commit-Queue: Yang Guo <yangguo@chromium.org> Auto-Submit: Yang Guo <yangguo@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Cr-Commit-Position: refs/heads/master@{#61830}
2019-05-24 13:51:59 +00:00
#include "src/flags/flags.h"
[modules] Expand API to allow linking and use it in d8 This patch gives the ability for the embedder to ask for the module requests of a module, and to pass a ResolveCallback into Module::Instantiate(). In d8, I've implemented a simple module_map that's used along with this API to allow loading, compiling, instantiating, and evaluating a whole tree of modules. No path resolution is yet implemented, meaning that all import paths are relative to whatever directory d8 runs in. And no imports are linked to the exports of the requested module. BUG=v8:1569 Review-Url: https://codereview.chromium.org/2351113004 Cr-Commit-Position: refs/heads/master@{#39569}
2016-09-20 23:38:58 +00:00
#include "test/cctest/cctest.h"
[modules] Do path resolution relative to each module file in d8 BUG=v8:1569 Review-Url: https://codereview.chromium.org/2361593002 Cr-Commit-Position: refs/heads/master@{#39646}
2016-09-22 21:03:19 +00:00
namespace {
[modules] Expand API to allow linking and use it in d8 This patch gives the ability for the embedder to ask for the module requests of a module, and to pass a ResolveCallback into Module::Instantiate(). In d8, I've implemented a simple module_map that's used along with this API to allow loading, compiling, instantiating, and evaluating a whole tree of modules. No path resolution is yet implemented, meaning that all import paths are relative to whatever directory d8 runs in. And no imports are linked to the exports of the requested module. BUG=v8:1569 Review-Url: https://codereview.chromium.org/2351113004 Cr-Commit-Position: refs/heads/master@{#39569}
2016-09-20 23:38:58 +00:00
using v8::Context;
[modules] Add refactored API to get ModuleRequests and expose import assertions This change refactors the v8.h API as discussed in https://docs.google.com/document/d/1yuXgNHSbTAPubT1Mg0JXp5uTrfirkvO1g5cHHCe-LmY/edit#heading=h.q0c9h4p928mn such that a v8::Module exposes module requests as a FixedArray of ModuleRequest objects, which can then be used to obtain their module specifier and source code offset. This replaces the old functions that passed back individual specifier Strings and Locations via repeated calls to getters that take an index. These are marked as deprecated. The new ModuleRequest interface includes a getter for an ImportAssertions FixedArray, which will contain the import assertions for the request if --harmony-import-assertions is set, and will be empty otherwise. One notable change here is that the APIs now return source code offsets rather than v8::Locations. The host must then call the new Module::SourceOffsetToLocation to convert these offsets into line/column numbers. This requires a bit more back-and-forth, but allows the host to defer the cost of converting from source offset to line/column numbers until an error needs to be reported, potentially skipping the work altogether. Bug: v8:10958 Change-Id: I181639737c701e467324e6c781aa4d7bdd87ae8c Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2545577 Commit-Queue: Dan Clark <daniec@microsoft.com> Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Marja Hölttä <marja@chromium.org> Cr-Commit-Position: refs/heads/master@{#71387}
2020-11-24 19:13:00 +00:00
using v8::Data;
using v8::FixedArray;
[modules] Expand API to allow linking and use it in d8 This patch gives the ability for the embedder to ask for the module requests of a module, and to pass a ResolveCallback into Module::Instantiate(). In d8, I've implemented a simple module_map that's used along with this API to allow loading, compiling, instantiating, and evaluating a whole tree of modules. No path resolution is yet implemented, meaning that all import paths are relative to whatever directory d8 runs in. And no imports are linked to the exports of the requested module. BUG=v8:1569 Review-Url: https://codereview.chromium.org/2351113004 Cr-Commit-Position: refs/heads/master@{#39569}
2016-09-20 23:38:58 +00:00
using v8::HandleScope;
[modules] Add refactored API to get ModuleRequests and expose import assertions This change refactors the v8.h API as discussed in https://docs.google.com/document/d/1yuXgNHSbTAPubT1Mg0JXp5uTrfirkvO1g5cHHCe-LmY/edit#heading=h.q0c9h4p928mn such that a v8::Module exposes module requests as a FixedArray of ModuleRequest objects, which can then be used to obtain their module specifier and source code offset. This replaces the old functions that passed back individual specifier Strings and Locations via repeated calls to getters that take an index. These are marked as deprecated. The new ModuleRequest interface includes a getter for an ImportAssertions FixedArray, which will contain the import assertions for the request if --harmony-import-assertions is set, and will be empty otherwise. One notable change here is that the APIs now return source code offsets rather than v8::Locations. The host must then call the new Module::SourceOffsetToLocation to convert these offsets into line/column numbers. This requires a bit more back-and-forth, but allows the host to defer the cost of converting from source offset to line/column numbers until an error needs to be reported, potentially skipping the work altogether. Bug: v8:10958 Change-Id: I181639737c701e467324e6c781aa4d7bdd87ae8c Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2545577 Commit-Queue: Dan Clark <daniec@microsoft.com> Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Marja Hölttä <marja@chromium.org> Cr-Commit-Position: refs/heads/master@{#71387}
2020-11-24 19:13:00 +00:00
using v8::Int32;
[modules] Expand API to allow linking and use it in d8 This patch gives the ability for the embedder to ask for the module requests of a module, and to pass a ResolveCallback into Module::Instantiate(). In d8, I've implemented a simple module_map that's used along with this API to allow loading, compiling, instantiating, and evaluating a whole tree of modules. No path resolution is yet implemented, meaning that all import paths are relative to whatever directory d8 runs in. And no imports are linked to the exports of the requested module. BUG=v8:1569 Review-Url: https://codereview.chromium.org/2351113004 Cr-Commit-Position: refs/heads/master@{#39569}
2016-09-20 23:38:58 +00:00
using v8::Isolate;
using v8::Local;
[modules] Add refactored API to get ModuleRequests and expose import assertions This change refactors the v8.h API as discussed in https://docs.google.com/document/d/1yuXgNHSbTAPubT1Mg0JXp5uTrfirkvO1g5cHHCe-LmY/edit#heading=h.q0c9h4p928mn such that a v8::Module exposes module requests as a FixedArray of ModuleRequest objects, which can then be used to obtain their module specifier and source code offset. This replaces the old functions that passed back individual specifier Strings and Locations via repeated calls to getters that take an index. These are marked as deprecated. The new ModuleRequest interface includes a getter for an ImportAssertions FixedArray, which will contain the import assertions for the request if --harmony-import-assertions is set, and will be empty otherwise. One notable change here is that the APIs now return source code offsets rather than v8::Locations. The host must then call the new Module::SourceOffsetToLocation to convert these offsets into line/column numbers. This requires a bit more back-and-forth, but allows the host to defer the cost of converting from source offset to line/column numbers until an error needs to be reported, potentially skipping the work altogether. Bug: v8:10958 Change-Id: I181639737c701e467324e6c781aa4d7bdd87ae8c Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2545577 Commit-Queue: Dan Clark <daniec@microsoft.com> Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Marja Hölttä <marja@chromium.org> Cr-Commit-Position: refs/heads/master@{#71387}
2020-11-24 19:13:00 +00:00
using v8::Location;
[modules] Expand API to allow linking and use it in d8 This patch gives the ability for the embedder to ask for the module requests of a module, and to pass a ResolveCallback into Module::Instantiate(). In d8, I've implemented a simple module_map that's used along with this API to allow loading, compiling, instantiating, and evaluating a whole tree of modules. No path resolution is yet implemented, meaning that all import paths are relative to whatever directory d8 runs in. And no imports are linked to the exports of the requested module. BUG=v8:1569 Review-Url: https://codereview.chromium.org/2351113004 Cr-Commit-Position: refs/heads/master@{#39569}
2016-09-20 23:38:58 +00:00
using v8::MaybeLocal;
using v8::Module;
[modules] Add refactored API to get ModuleRequests and expose import assertions This change refactors the v8.h API as discussed in https://docs.google.com/document/d/1yuXgNHSbTAPubT1Mg0JXp5uTrfirkvO1g5cHHCe-LmY/edit#heading=h.q0c9h4p928mn such that a v8::Module exposes module requests as a FixedArray of ModuleRequest objects, which can then be used to obtain their module specifier and source code offset. This replaces the old functions that passed back individual specifier Strings and Locations via repeated calls to getters that take an index. These are marked as deprecated. The new ModuleRequest interface includes a getter for an ImportAssertions FixedArray, which will contain the import assertions for the request if --harmony-import-assertions is set, and will be empty otherwise. One notable change here is that the APIs now return source code offsets rather than v8::Locations. The host must then call the new Module::SourceOffsetToLocation to convert these offsets into line/column numbers. This requires a bit more back-and-forth, but allows the host to defer the cost of converting from source offset to line/column numbers until an error needs to be reported, potentially skipping the work altogether. Bug: v8:10958 Change-Id: I181639737c701e467324e6c781aa4d7bdd87ae8c Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2545577 Commit-Queue: Dan Clark <daniec@microsoft.com> Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Marja Hölttä <marja@chromium.org> Cr-Commit-Position: refs/heads/master@{#71387}
2020-11-24 19:13:00 +00:00
using v8::ModuleRequest;
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
using v8::Promise;
[modules] Expand API to allow linking and use it in d8 This patch gives the ability for the embedder to ask for the module requests of a module, and to pass a ResolveCallback into Module::Instantiate(). In d8, I've implemented a simple module_map that's used along with this API to allow loading, compiling, instantiating, and evaluating a whole tree of modules. No path resolution is yet implemented, meaning that all import paths are relative to whatever directory d8 runs in. And no imports are linked to the exports of the requested module. BUG=v8:1569 Review-Url: https://codereview.chromium.org/2351113004 Cr-Commit-Position: refs/heads/master@{#39569}
2016-09-20 23:38:58 +00:00
using v8::ScriptCompiler;
using v8::ScriptOrigin;
using v8::String;
using v8::Value;
[modules] Add an IsModule flag to ScriptOriginOptions. Since the script origin is part of the key used in the compilation cache, this ensures that the cache never confuses a module with a non-module script. BUG=v8:1569,v8:5685 Review-Url: https://codereview.chromium.org/2611643002 Cr-Commit-Position: refs/heads/master@{#42490}
2017-01-19 06:59:20 +00:00
ScriptOrigin ModuleOrigin(Local<v8::Value> resource_name, Isolate* isolate) {
[api] Make ScriptOrigin take isolate as parameter Remove the ambient dependency on the currently entered isolate, let the embedder pass it in explicitly. Bug: v8:11287 Change-Id: I03690390a308a59e2c6ea5c6ae268780d836b717 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2608209 Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Benedikt Meurer <bmeurer@chromium.org> Reviewed-by: Yang Guo <yangguo@chromium.org> Commit-Queue: Yang Guo <yangguo@chromium.org> Cr-Commit-Position: refs/heads/master@{#72105}
2021-01-12 11:54:50 +00:00
ScriptOrigin origin(isolate, resource_name, 0, 0, false, -1,
Local<v8::Value>(), false, false, true);
[modules] Add an IsModule flag to ScriptOriginOptions. Since the script origin is part of the key used in the compilation cache, this ensures that the cache never confuses a module with a non-module script. BUG=v8:1569,v8:5685 Review-Url: https://codereview.chromium.org/2611643002 Cr-Commit-Position: refs/heads/master@{#42490}
2017-01-19 06:59:20 +00:00
return origin;
}
[modules] Implement recent ES revisions. - Instantiation errors are no longer recorded. If instantiation fails, the module(s) are reset to "uninstantiated". When instantiation is re-attempted, the thrown exception will be fresh. - Instantiation can succeed even where there are modules in the graph that previously failed evaluation. Bug: v8:1569 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I429f616918afe5f8ab1a956024f0a22f464b8c44 Reviewed-on: https://chromium-review.googlesource.com/763369 Commit-Queue: Georg Neis <neis@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Cr-Commit-Position: refs/heads/master@{#50301}
2017-12-08 08:46:01 +00:00
static Local<Module> dep1;
static Local<Module> dep2;
MaybeLocal<Module> ResolveCallback(Local<Context> context,
Local<String> specifier,
[modules] Add ResolveModuleCallback that takes import assertions This change completes the necessary API changes for import assertions discussed in https://docs.google.com/document/d/1yuXgNHSbTAPubT1Mg0JXp5uTrfirkvO1g5cHHCe-LmY. The old ResolveCallback is deprecated and replaced with a ResolveModuleCallback that includes import assertions. Until ResolveCallback is removed, InstantiateModule and associated functions are modified to accept both types of callback, using the new one if it was supplied and the old one otherwise. An alternative that I chose not to go with would be to just duplicate InstantiateModule and associated functions for both callback types. SyntheticModule::PrepareInstantiate's callback parameter was unused so I removed it. Bug: v8:10958 Change-Id: I8e9fbaf9c2853b076b13da02473fbbe039b9db57 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2551919 Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Marja Hölttä <marja@chromium.org> Commit-Queue: Dan Clark <daniec@microsoft.com> Cr-Commit-Position: refs/heads/master@{#71506}
2020-11-25 19:10:03 +00:00
Local<FixedArray> import_assertions,
[modules] Implement recent ES revisions. - Instantiation errors are no longer recorded. If instantiation fails, the module(s) are reset to "uninstantiated". When instantiation is re-attempted, the thrown exception will be fresh. - Instantiation can succeed even where there are modules in the graph that previously failed evaluation. Bug: v8:1569 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I429f616918afe5f8ab1a956024f0a22f464b8c44 Reviewed-on: https://chromium-review.googlesource.com/763369 Commit-Queue: Georg Neis <neis@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Cr-Commit-Position: refs/heads/master@{#50301}
2017-12-08 08:46:01 +00:00
Local<Module> referrer) {
[modules] Add ResolveModuleCallback that takes import assertions This change completes the necessary API changes for import assertions discussed in https://docs.google.com/document/d/1yuXgNHSbTAPubT1Mg0JXp5uTrfirkvO1g5cHHCe-LmY. The old ResolveCallback is deprecated and replaced with a ResolveModuleCallback that includes import assertions. Until ResolveCallback is removed, InstantiateModule and associated functions are modified to accept both types of callback, using the new one if it was supplied and the old one otherwise. An alternative that I chose not to go with would be to just duplicate InstantiateModule and associated functions for both callback types. SyntheticModule::PrepareInstantiate's callback parameter was unused so I removed it. Bug: v8:10958 Change-Id: I8e9fbaf9c2853b076b13da02473fbbe039b9db57 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2551919 Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Marja Hölttä <marja@chromium.org> Commit-Queue: Dan Clark <daniec@microsoft.com> Cr-Commit-Position: refs/heads/master@{#71506}
2020-11-25 19:10:03 +00:00
CHECK_EQ(0, import_assertions->Length());
[modules] Allow resolve-callback to signal failure. When asked for a module that previously failed to compile or instantiate, the embedder necessarily has to signal failure. In this case, we expect an exception to be scheduled, which we will rethrow. BUG=v8:1569 Review-Url: https://codereview.chromium.org/2827733002 Cr-Commit-Position: refs/heads/master@{#44729}
2017-04-19 18:28:09 +00:00
Isolate* isolate = CcTest::isolate();
[modules] Implement recent ES revisions. - Instantiation errors are no longer recorded. If instantiation fails, the module(s) are reset to "uninstantiated". When instantiation is re-attempted, the thrown exception will be fresh. - Instantiation can succeed even where there are modules in the graph that previously failed evaluation. Bug: v8:1569 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I429f616918afe5f8ab1a956024f0a22f464b8c44 Reviewed-on: https://chromium-review.googlesource.com/763369 Commit-Queue: Georg Neis <neis@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Cr-Commit-Position: refs/heads/master@{#50301}
2017-12-08 08:46:01 +00:00
if (specifier->StrictEquals(v8_str("./dep1.js"))) {
return dep1;
} else if (specifier->StrictEquals(v8_str("./dep2.js"))) {
return dep2;
} else {
isolate->ThrowException(v8_str("boom"));
[modules] Allow resolve-callback to signal failure. When asked for a module that previously failed to compile or instantiate, the embedder necessarily has to signal failure. In this case, we expect an exception to be scheduled, which we will rethrow. BUG=v8:1569 Review-Url: https://codereview.chromium.org/2827733002 Cr-Commit-Position: refs/heads/master@{#44729}
2017-04-19 18:28:09 +00:00
return MaybeLocal<Module>();
}
[modules] Expand API to allow linking and use it in d8 This patch gives the ability for the embedder to ask for the module requests of a module, and to pass a ResolveCallback into Module::Instantiate(). In d8, I've implemented a simple module_map that's used along with this API to allow loading, compiling, instantiating, and evaluating a whole tree of modules. No path resolution is yet implemented, meaning that all import paths are relative to whatever directory d8 runs in. And no imports are linked to the exports of the requested module. BUG=v8:1569 Review-Url: https://codereview.chromium.org/2351113004 Cr-Commit-Position: refs/heads/master@{#39569}
2016-09-20 23:38:58 +00:00
}
[modules] Implement recent ES revisions. - Instantiation errors are no longer recorded. If instantiation fails, the module(s) are reset to "uninstantiated". When instantiation is re-attempted, the thrown exception will be fresh. - Instantiation can succeed even where there are modules in the graph that previously failed evaluation. Bug: v8:1569 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I429f616918afe5f8ab1a956024f0a22f464b8c44 Reviewed-on: https://chromium-review.googlesource.com/763369 Commit-Queue: Georg Neis <neis@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Cr-Commit-Position: refs/heads/master@{#50301}
2017-12-08 08:46:01 +00:00
TEST(ModuleInstantiationFailures1) {
[runtime] Use TLA in more tests Enable more tests to use top level await modules. Bug: v8:9344 Change-Id: I61c0c0205235969a43af602af327654b7e8a3dad Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2074402 Reviewed-by: Sathya Gunasekaran <gsathya@chromium.org> Commit-Queue: Camillo Bruni <cbruni@chromium.org> Cr-Commit-Position: refs/heads/master@{#66726}
2020-02-27 10:51:32 +00:00
bool prev_top_level_await = i::FLAG_harmony_top_level_await;
for (auto top_level_await : {true, false}) {
i::FLAG_harmony_top_level_await = top_level_await;
Isolate* isolate = CcTest::isolate();
HandleScope scope(isolate);
LocalContext env;
v8::TryCatch try_catch(isolate);
Local<Module> module;
{
Local<String> source_text = v8_str(
"import './foo.js';\n"
"export {} from './bar.js';");
ScriptOrigin origin = ModuleOrigin(v8_str("file.js"), CcTest::isolate());
ScriptCompiler::Source source(source_text, origin);
module = ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
CHECK_EQ(Module::kUninstantiated, module->GetStatus());
[modules] Add refactored API to get ModuleRequests and expose import assertions This change refactors the v8.h API as discussed in https://docs.google.com/document/d/1yuXgNHSbTAPubT1Mg0JXp5uTrfirkvO1g5cHHCe-LmY/edit#heading=h.q0c9h4p928mn such that a v8::Module exposes module requests as a FixedArray of ModuleRequest objects, which can then be used to obtain their module specifier and source code offset. This replaces the old functions that passed back individual specifier Strings and Locations via repeated calls to getters that take an index. These are marked as deprecated. The new ModuleRequest interface includes a getter for an ImportAssertions FixedArray, which will contain the import assertions for the request if --harmony-import-assertions is set, and will be empty otherwise. One notable change here is that the APIs now return source code offsets rather than v8::Locations. The host must then call the new Module::SourceOffsetToLocation to convert these offsets into line/column numbers. This requires a bit more back-and-forth, but allows the host to defer the cost of converting from source offset to line/column numbers until an error needs to be reported, potentially skipping the work altogether. Bug: v8:10958 Change-Id: I181639737c701e467324e6c781aa4d7bdd87ae8c Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2545577 Commit-Queue: Dan Clark <daniec@microsoft.com> Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Marja Hölttä <marja@chromium.org> Cr-Commit-Position: refs/heads/master@{#71387}
2020-11-24 19:13:00 +00:00
Local<FixedArray> module_requests = module->GetModuleRequests();
CHECK_EQ(2, module_requests->Length());
Local<ModuleRequest> module_request_0 =
module_requests->Get(env.local(), 0).As<ModuleRequest>();
CHECK(v8_str("./foo.js")->StrictEquals(module_request_0->GetSpecifier()));
int offset = module_request_0->GetSourceOffset();
CHECK_EQ(7, offset);
Location loc = module->SourceOffsetToLocation(offset);
[runtime] Use TLA in more tests Enable more tests to use top level await modules. Bug: v8:9344 Change-Id: I61c0c0205235969a43af602af327654b7e8a3dad Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2074402 Reviewed-by: Sathya Gunasekaran <gsathya@chromium.org> Commit-Queue: Camillo Bruni <cbruni@chromium.org> Cr-Commit-Position: refs/heads/master@{#66726}
2020-02-27 10:51:32 +00:00
CHECK_EQ(0, loc.GetLineNumber());
CHECK_EQ(7, loc.GetColumnNumber());
[modules] Add refactored API to get ModuleRequests and expose import assertions This change refactors the v8.h API as discussed in https://docs.google.com/document/d/1yuXgNHSbTAPubT1Mg0JXp5uTrfirkvO1g5cHHCe-LmY/edit#heading=h.q0c9h4p928mn such that a v8::Module exposes module requests as a FixedArray of ModuleRequest objects, which can then be used to obtain their module specifier and source code offset. This replaces the old functions that passed back individual specifier Strings and Locations via repeated calls to getters that take an index. These are marked as deprecated. The new ModuleRequest interface includes a getter for an ImportAssertions FixedArray, which will contain the import assertions for the request if --harmony-import-assertions is set, and will be empty otherwise. One notable change here is that the APIs now return source code offsets rather than v8::Locations. The host must then call the new Module::SourceOffsetToLocation to convert these offsets into line/column numbers. This requires a bit more back-and-forth, but allows the host to defer the cost of converting from source offset to line/column numbers until an error needs to be reported, potentially skipping the work altogether. Bug: v8:10958 Change-Id: I181639737c701e467324e6c781aa4d7bdd87ae8c Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2545577 Commit-Queue: Dan Clark <daniec@microsoft.com> Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Marja Hölttä <marja@chromium.org> Cr-Commit-Position: refs/heads/master@{#71387}
2020-11-24 19:13:00 +00:00
CHECK_EQ(0, module_request_0->GetImportAssertions()->Length());
Local<ModuleRequest> module_request_1 =
module_requests->Get(env.local(), 1).As<ModuleRequest>();
CHECK(v8_str("./bar.js")->StrictEquals(module_request_1->GetSpecifier()));
offset = module_request_1->GetSourceOffset();
CHECK_EQ(34, offset);
loc = module->SourceOffsetToLocation(offset);
[runtime] Use TLA in more tests Enable more tests to use top level await modules. Bug: v8:9344 Change-Id: I61c0c0205235969a43af602af327654b7e8a3dad Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2074402 Reviewed-by: Sathya Gunasekaran <gsathya@chromium.org> Commit-Queue: Camillo Bruni <cbruni@chromium.org> Cr-Commit-Position: refs/heads/master@{#66726}
2020-02-27 10:51:32 +00:00
CHECK_EQ(1, loc.GetLineNumber());
CHECK_EQ(15, loc.GetColumnNumber());
[modules] Add refactored API to get ModuleRequests and expose import assertions This change refactors the v8.h API as discussed in https://docs.google.com/document/d/1yuXgNHSbTAPubT1Mg0JXp5uTrfirkvO1g5cHHCe-LmY/edit#heading=h.q0c9h4p928mn such that a v8::Module exposes module requests as a FixedArray of ModuleRequest objects, which can then be used to obtain their module specifier and source code offset. This replaces the old functions that passed back individual specifier Strings and Locations via repeated calls to getters that take an index. These are marked as deprecated. The new ModuleRequest interface includes a getter for an ImportAssertions FixedArray, which will contain the import assertions for the request if --harmony-import-assertions is set, and will be empty otherwise. One notable change here is that the APIs now return source code offsets rather than v8::Locations. The host must then call the new Module::SourceOffsetToLocation to convert these offsets into line/column numbers. This requires a bit more back-and-forth, but allows the host to defer the cost of converting from source offset to line/column numbers until an error needs to be reported, potentially skipping the work altogether. Bug: v8:10958 Change-Id: I181639737c701e467324e6c781aa4d7bdd87ae8c Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2545577 Commit-Queue: Dan Clark <daniec@microsoft.com> Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Marja Hölttä <marja@chromium.org> Cr-Commit-Position: refs/heads/master@{#71387}
2020-11-24 19:13:00 +00:00
CHECK_EQ(0, module_request_1->GetImportAssertions()->Length());
[runtime] Use TLA in more tests Enable more tests to use top level await modules. Bug: v8:9344 Change-Id: I61c0c0205235969a43af602af327654b7e8a3dad Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2074402 Reviewed-by: Sathya Gunasekaran <gsathya@chromium.org> Commit-Queue: Camillo Bruni <cbruni@chromium.org> Cr-Commit-Position: refs/heads/master@{#66726}
2020-02-27 10:51:32 +00:00
}
// Instantiation should fail.
{
v8::TryCatch inner_try_catch(isolate);
CHECK(
module->InstantiateModule(env.local(), ResolveCallback).IsNothing());
CHECK(inner_try_catch.HasCaught());
CHECK(inner_try_catch.Exception()->StrictEquals(v8_str("boom")));
CHECK_EQ(Module::kUninstantiated, module->GetStatus());
}
// Start over again...
{
Local<String> source_text = v8_str(
"import './dep1.js';\n"
"export {} from './bar.js';");
ScriptOrigin origin = ModuleOrigin(v8_str("file.js"), CcTest::isolate());
ScriptCompiler::Source source(source_text, origin);
module = ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
}
// dep1.js
{
Local<String> source_text = v8_str("");
ScriptOrigin origin = ModuleOrigin(v8_str("dep1.js"), CcTest::isolate());
ScriptCompiler::Source source(source_text, origin);
dep1 = ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
}
// Instantiation should fail because a sub-module fails to resolve.
{
v8::TryCatch inner_try_catch(isolate);
CHECK(
module->InstantiateModule(env.local(), ResolveCallback).IsNothing());
CHECK(inner_try_catch.HasCaught());
CHECK(inner_try_catch.Exception()->StrictEquals(v8_str("boom")));
CHECK_EQ(Module::kUninstantiated, module->GetStatus());
}
CHECK(!try_catch.HasCaught());
[modules] Implement recent ES revisions. - Instantiation errors are no longer recorded. If instantiation fails, the module(s) are reset to "uninstantiated". When instantiation is re-attempted, the thrown exception will be fresh. - Instantiation can succeed even where there are modules in the graph that previously failed evaluation. Bug: v8:1569 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I429f616918afe5f8ab1a956024f0a22f464b8c44 Reviewed-on: https://chromium-review.googlesource.com/763369 Commit-Queue: Georg Neis <neis@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Cr-Commit-Position: refs/heads/master@{#50301}
2017-12-08 08:46:01 +00:00
}
[runtime] Use TLA in more tests Enable more tests to use top level await modules. Bug: v8:9344 Change-Id: I61c0c0205235969a43af602af327654b7e8a3dad Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2074402 Reviewed-by: Sathya Gunasekaran <gsathya@chromium.org> Commit-Queue: Camillo Bruni <cbruni@chromium.org> Cr-Commit-Position: refs/heads/master@{#66726}
2020-02-27 10:51:32 +00:00
i::FLAG_harmony_top_level_await = prev_top_level_await;
[modules] Expand API to allow linking and use it in d8 This patch gives the ability for the embedder to ask for the module requests of a module, and to pass a ResolveCallback into Module::Instantiate(). In d8, I've implemented a simple module_map that's used along with this API to allow loading, compiling, instantiating, and evaluating a whole tree of modules. No path resolution is yet implemented, meaning that all import paths are relative to whatever directory d8 runs in. And no imports are linked to the exports of the requested module. BUG=v8:1569 Review-Url: https://codereview.chromium.org/2351113004 Cr-Commit-Position: refs/heads/master@{#39569}
2016-09-20 23:38:58 +00:00
}
[modules] Add ResolveModuleCallback that takes import assertions This change completes the necessary API changes for import assertions discussed in https://docs.google.com/document/d/1yuXgNHSbTAPubT1Mg0JXp5uTrfirkvO1g5cHHCe-LmY. The old ResolveCallback is deprecated and replaced with a ResolveModuleCallback that includes import assertions. Until ResolveCallback is removed, InstantiateModule and associated functions are modified to accept both types of callback, using the new one if it was supplied and the old one otherwise. An alternative that I chose not to go with would be to just duplicate InstantiateModule and associated functions for both callback types. SyntheticModule::PrepareInstantiate's callback parameter was unused so I removed it. Bug: v8:10958 Change-Id: I8e9fbaf9c2853b076b13da02473fbbe039b9db57 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2551919 Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Marja Hölttä <marja@chromium.org> Commit-Queue: Dan Clark <daniec@microsoft.com> Cr-Commit-Position: refs/heads/master@{#71506}
2020-11-25 19:10:03 +00:00
static Local<Module> fooModule;
static Local<Module> barModule;
MaybeLocal<Module> ResolveCallbackWithImportAssertions(
Local<Context> context, Local<String> specifier,
Local<FixedArray> import_assertions, Local<Module> referrer) {
Isolate* isolate = CcTest::isolate();
LocalContext env;
if (specifier->StrictEquals(v8_str("./foo.js"))) {
CHECK_EQ(0, import_assertions->Length());
return fooModule;
} else if (specifier->StrictEquals(v8_str("./bar.js"))) {
CHECK_EQ(3, import_assertions->Length());
Local<String> assertion_key =
[modules][api] Stop filtering import assertions based on list provided by the host The change https://chromium-review.googlesource.com/c/v8/v8/+/2572173 implemented HostGetSupportedImportAssertions [1] in a fairly literal sense, where the host supplies a list of supported import assertions and V8 filters the import assertions in a ModuleRequest and exposes only supported assertions via its API surface. However, we've decided that the interop guarantees provided by doing the filtering in V8 are probably not worth the added complexity. Thus, this change removes the filtering. Going forward, hosts will be expected to ignore unknown asserions received from V8. This is mostly a revert of https://chromium-review.googlesource.com/c/v8/v8/+/2572173, with v8::Isolate::CreateParams::supported_import_assertions being kept for now (since we first have to delete the Blink code that sets it), and a new comment in v8.h instructing hosts to ignore unknown assertions. [1] https://tc39.es/proposal-import-assertions/#sec-hostgetsupportedimportassertions Bug: v8:10958 Change-Id: I7e8e2a7fbfe2d5bf891805cff6c3160d0e6825cd Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2643563 Reviewed-by: Marja Hölttä <marja@chromium.org> Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Mythri Alle <mythria@chromium.org> Commit-Queue: Dan Clark <daniec@microsoft.com> Cr-Commit-Position: refs/heads/master@{#72299}
2021-01-21 21:42:57 +00:00
import_assertions->Get(env.local(), 0).As<Value>().As<String>();
[modules] Add ResolveModuleCallback that takes import assertions This change completes the necessary API changes for import assertions discussed in https://docs.google.com/document/d/1yuXgNHSbTAPubT1Mg0JXp5uTrfirkvO1g5cHHCe-LmY. The old ResolveCallback is deprecated and replaced with a ResolveModuleCallback that includes import assertions. Until ResolveCallback is removed, InstantiateModule and associated functions are modified to accept both types of callback, using the new one if it was supplied and the old one otherwise. An alternative that I chose not to go with would be to just duplicate InstantiateModule and associated functions for both callback types. SyntheticModule::PrepareInstantiate's callback parameter was unused so I removed it. Bug: v8:10958 Change-Id: I8e9fbaf9c2853b076b13da02473fbbe039b9db57 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2551919 Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Marja Hölttä <marja@chromium.org> Commit-Queue: Dan Clark <daniec@microsoft.com> Cr-Commit-Position: refs/heads/master@{#71506}
2020-11-25 19:10:03 +00:00
CHECK(v8_str("a")->StrictEquals(assertion_key));
Local<String> assertion_value =
[modules][api] Stop filtering import assertions based on list provided by the host The change https://chromium-review.googlesource.com/c/v8/v8/+/2572173 implemented HostGetSupportedImportAssertions [1] in a fairly literal sense, where the host supplies a list of supported import assertions and V8 filters the import assertions in a ModuleRequest and exposes only supported assertions via its API surface. However, we've decided that the interop guarantees provided by doing the filtering in V8 are probably not worth the added complexity. Thus, this change removes the filtering. Going forward, hosts will be expected to ignore unknown asserions received from V8. This is mostly a revert of https://chromium-review.googlesource.com/c/v8/v8/+/2572173, with v8::Isolate::CreateParams::supported_import_assertions being kept for now (since we first have to delete the Blink code that sets it), and a new comment in v8.h instructing hosts to ignore unknown assertions. [1] https://tc39.es/proposal-import-assertions/#sec-hostgetsupportedimportassertions Bug: v8:10958 Change-Id: I7e8e2a7fbfe2d5bf891805cff6c3160d0e6825cd Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2643563 Reviewed-by: Marja Hölttä <marja@chromium.org> Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Mythri Alle <mythria@chromium.org> Commit-Queue: Dan Clark <daniec@microsoft.com> Cr-Commit-Position: refs/heads/master@{#72299}
2021-01-21 21:42:57 +00:00
import_assertions->Get(env.local(), 1).As<Value>().As<String>();
[modules] Add ResolveModuleCallback that takes import assertions This change completes the necessary API changes for import assertions discussed in https://docs.google.com/document/d/1yuXgNHSbTAPubT1Mg0JXp5uTrfirkvO1g5cHHCe-LmY. The old ResolveCallback is deprecated and replaced with a ResolveModuleCallback that includes import assertions. Until ResolveCallback is removed, InstantiateModule and associated functions are modified to accept both types of callback, using the new one if it was supplied and the old one otherwise. An alternative that I chose not to go with would be to just duplicate InstantiateModule and associated functions for both callback types. SyntheticModule::PrepareInstantiate's callback parameter was unused so I removed it. Bug: v8:10958 Change-Id: I8e9fbaf9c2853b076b13da02473fbbe039b9db57 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2551919 Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Marja Hölttä <marja@chromium.org> Commit-Queue: Dan Clark <daniec@microsoft.com> Cr-Commit-Position: refs/heads/master@{#71506}
2020-11-25 19:10:03 +00:00
CHECK(v8_str("b")->StrictEquals(assertion_value));
Local<Data> assertion_source_offset_object =
[modules][api] Stop filtering import assertions based on list provided by the host The change https://chromium-review.googlesource.com/c/v8/v8/+/2572173 implemented HostGetSupportedImportAssertions [1] in a fairly literal sense, where the host supplies a list of supported import assertions and V8 filters the import assertions in a ModuleRequest and exposes only supported assertions via its API surface. However, we've decided that the interop guarantees provided by doing the filtering in V8 are probably not worth the added complexity. Thus, this change removes the filtering. Going forward, hosts will be expected to ignore unknown asserions received from V8. This is mostly a revert of https://chromium-review.googlesource.com/c/v8/v8/+/2572173, with v8::Isolate::CreateParams::supported_import_assertions being kept for now (since we first have to delete the Blink code that sets it), and a new comment in v8.h instructing hosts to ignore unknown assertions. [1] https://tc39.es/proposal-import-assertions/#sec-hostgetsupportedimportassertions Bug: v8:10958 Change-Id: I7e8e2a7fbfe2d5bf891805cff6c3160d0e6825cd Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2643563 Reviewed-by: Marja Hölttä <marja@chromium.org> Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Mythri Alle <mythria@chromium.org> Commit-Queue: Dan Clark <daniec@microsoft.com> Cr-Commit-Position: refs/heads/master@{#72299}
2021-01-21 21:42:57 +00:00
import_assertions->Get(env.local(), 2);
[modules] Add ResolveModuleCallback that takes import assertions This change completes the necessary API changes for import assertions discussed in https://docs.google.com/document/d/1yuXgNHSbTAPubT1Mg0JXp5uTrfirkvO1g5cHHCe-LmY. The old ResolveCallback is deprecated and replaced with a ResolveModuleCallback that includes import assertions. Until ResolveCallback is removed, InstantiateModule and associated functions are modified to accept both types of callback, using the new one if it was supplied and the old one otherwise. An alternative that I chose not to go with would be to just duplicate InstantiateModule and associated functions for both callback types. SyntheticModule::PrepareInstantiate's callback parameter was unused so I removed it. Bug: v8:10958 Change-Id: I8e9fbaf9c2853b076b13da02473fbbe039b9db57 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2551919 Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Marja Hölttä <marja@chromium.org> Commit-Queue: Dan Clark <daniec@microsoft.com> Cr-Commit-Position: refs/heads/master@{#71506}
2020-11-25 19:10:03 +00:00
Local<Int32> assertion_source_offset_int32 =
assertion_source_offset_object.As<Value>()
->ToInt32(context)
.ToLocalChecked();
int32_t assertion_source_offset = assertion_source_offset_int32->Value();
CHECK_EQ(65, assertion_source_offset);
Location loc = referrer->SourceOffsetToLocation(assertion_source_offset);
CHECK_EQ(1, loc.GetLineNumber());
CHECK_EQ(35, loc.GetColumnNumber());
return barModule;
} else {
isolate->ThrowException(v8_str("boom"));
return MaybeLocal<Module>();
}
}
TEST(ModuleInstantiationWithImportAssertions) {
[modules] Add refactored API to get ModuleRequests and expose import assertions This change refactors the v8.h API as discussed in https://docs.google.com/document/d/1yuXgNHSbTAPubT1Mg0JXp5uTrfirkvO1g5cHHCe-LmY/edit#heading=h.q0c9h4p928mn such that a v8::Module exposes module requests as a FixedArray of ModuleRequest objects, which can then be used to obtain their module specifier and source code offset. This replaces the old functions that passed back individual specifier Strings and Locations via repeated calls to getters that take an index. These are marked as deprecated. The new ModuleRequest interface includes a getter for an ImportAssertions FixedArray, which will contain the import assertions for the request if --harmony-import-assertions is set, and will be empty otherwise. One notable change here is that the APIs now return source code offsets rather than v8::Locations. The host must then call the new Module::SourceOffsetToLocation to convert these offsets into line/column numbers. This requires a bit more back-and-forth, but allows the host to defer the cost of converting from source offset to line/column numbers until an error needs to be reported, potentially skipping the work altogether. Bug: v8:10958 Change-Id: I181639737c701e467324e6c781aa4d7bdd87ae8c Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2545577 Commit-Queue: Dan Clark <daniec@microsoft.com> Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Marja Hölttä <marja@chromium.org> Cr-Commit-Position: refs/heads/master@{#71387}
2020-11-24 19:13:00 +00:00
bool prev_top_level_await = i::FLAG_harmony_top_level_await;
bool prev_import_assertions = i::FLAG_harmony_import_assertions;
i::FLAG_harmony_import_assertions = true;
for (auto top_level_await : {true, false}) {
i::FLAG_harmony_top_level_await = top_level_await;
[modules][api] Stop filtering import assertions based on list provided by the host The change https://chromium-review.googlesource.com/c/v8/v8/+/2572173 implemented HostGetSupportedImportAssertions [1] in a fairly literal sense, where the host supplies a list of supported import assertions and V8 filters the import assertions in a ModuleRequest and exposes only supported assertions via its API surface. However, we've decided that the interop guarantees provided by doing the filtering in V8 are probably not worth the added complexity. Thus, this change removes the filtering. Going forward, hosts will be expected to ignore unknown asserions received from V8. This is mostly a revert of https://chromium-review.googlesource.com/c/v8/v8/+/2572173, with v8::Isolate::CreateParams::supported_import_assertions being kept for now (since we first have to delete the Blink code that sets it), and a new comment in v8.h instructing hosts to ignore unknown assertions. [1] https://tc39.es/proposal-import-assertions/#sec-hostgetsupportedimportassertions Bug: v8:10958 Change-Id: I7e8e2a7fbfe2d5bf891805cff6c3160d0e6825cd Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2643563 Reviewed-by: Marja Hölttä <marja@chromium.org> Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Mythri Alle <mythria@chromium.org> Commit-Queue: Dan Clark <daniec@microsoft.com> Cr-Commit-Position: refs/heads/master@{#72299}
2021-01-21 21:42:57 +00:00
Isolate* isolate = CcTest::isolate();
[modules] Add refactored API to get ModuleRequests and expose import assertions This change refactors the v8.h API as discussed in https://docs.google.com/document/d/1yuXgNHSbTAPubT1Mg0JXp5uTrfirkvO1g5cHHCe-LmY/edit#heading=h.q0c9h4p928mn such that a v8::Module exposes module requests as a FixedArray of ModuleRequest objects, which can then be used to obtain their module specifier and source code offset. This replaces the old functions that passed back individual specifier Strings and Locations via repeated calls to getters that take an index. These are marked as deprecated. The new ModuleRequest interface includes a getter for an ImportAssertions FixedArray, which will contain the import assertions for the request if --harmony-import-assertions is set, and will be empty otherwise. One notable change here is that the APIs now return source code offsets rather than v8::Locations. The host must then call the new Module::SourceOffsetToLocation to convert these offsets into line/column numbers. This requires a bit more back-and-forth, but allows the host to defer the cost of converting from source offset to line/column numbers until an error needs to be reported, potentially skipping the work altogether. Bug: v8:10958 Change-Id: I181639737c701e467324e6c781aa4d7bdd87ae8c Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2545577 Commit-Queue: Dan Clark <daniec@microsoft.com> Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Marja Hölttä <marja@chromium.org> Cr-Commit-Position: refs/heads/master@{#71387}
2020-11-24 19:13:00 +00:00
HandleScope scope(isolate);
[modules][api] Stop filtering import assertions based on list provided by the host The change https://chromium-review.googlesource.com/c/v8/v8/+/2572173 implemented HostGetSupportedImportAssertions [1] in a fairly literal sense, where the host supplies a list of supported import assertions and V8 filters the import assertions in a ModuleRequest and exposes only supported assertions via its API surface. However, we've decided that the interop guarantees provided by doing the filtering in V8 are probably not worth the added complexity. Thus, this change removes the filtering. Going forward, hosts will be expected to ignore unknown asserions received from V8. This is mostly a revert of https://chromium-review.googlesource.com/c/v8/v8/+/2572173, with v8::Isolate::CreateParams::supported_import_assertions being kept for now (since we first have to delete the Blink code that sets it), and a new comment in v8.h instructing hosts to ignore unknown assertions. [1] https://tc39.es/proposal-import-assertions/#sec-hostgetsupportedimportassertions Bug: v8:10958 Change-Id: I7e8e2a7fbfe2d5bf891805cff6c3160d0e6825cd Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2643563 Reviewed-by: Marja Hölttä <marja@chromium.org> Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Mythri Alle <mythria@chromium.org> Commit-Queue: Dan Clark <daniec@microsoft.com> Cr-Commit-Position: refs/heads/master@{#72299}
2021-01-21 21:42:57 +00:00
LocalContext env;
[modules] Add refactored API to get ModuleRequests and expose import assertions This change refactors the v8.h API as discussed in https://docs.google.com/document/d/1yuXgNHSbTAPubT1Mg0JXp5uTrfirkvO1g5cHHCe-LmY/edit#heading=h.q0c9h4p928mn such that a v8::Module exposes module requests as a FixedArray of ModuleRequest objects, which can then be used to obtain their module specifier and source code offset. This replaces the old functions that passed back individual specifier Strings and Locations via repeated calls to getters that take an index. These are marked as deprecated. The new ModuleRequest interface includes a getter for an ImportAssertions FixedArray, which will contain the import assertions for the request if --harmony-import-assertions is set, and will be empty otherwise. One notable change here is that the APIs now return source code offsets rather than v8::Locations. The host must then call the new Module::SourceOffsetToLocation to convert these offsets into line/column numbers. This requires a bit more back-and-forth, but allows the host to defer the cost of converting from source offset to line/column numbers until an error needs to be reported, potentially skipping the work altogether. Bug: v8:10958 Change-Id: I181639737c701e467324e6c781aa4d7bdd87ae8c Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2545577 Commit-Queue: Dan Clark <daniec@microsoft.com> Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Marja Hölttä <marja@chromium.org> Cr-Commit-Position: refs/heads/master@{#71387}
2020-11-24 19:13:00 +00:00
v8::TryCatch try_catch(isolate);
Local<Module> module;
{
Local<String> source_text = v8_str(
"import './foo.js' assert { };\n"
[modules][api] Stop filtering import assertions based on list provided by the host The change https://chromium-review.googlesource.com/c/v8/v8/+/2572173 implemented HostGetSupportedImportAssertions [1] in a fairly literal sense, where the host supplies a list of supported import assertions and V8 filters the import assertions in a ModuleRequest and exposes only supported assertions via its API surface. However, we've decided that the interop guarantees provided by doing the filtering in V8 are probably not worth the added complexity. Thus, this change removes the filtering. Going forward, hosts will be expected to ignore unknown asserions received from V8. This is mostly a revert of https://chromium-review.googlesource.com/c/v8/v8/+/2572173, with v8::Isolate::CreateParams::supported_import_assertions being kept for now (since we first have to delete the Blink code that sets it), and a new comment in v8.h instructing hosts to ignore unknown assertions. [1] https://tc39.es/proposal-import-assertions/#sec-hostgetsupportedimportassertions Bug: v8:10958 Change-Id: I7e8e2a7fbfe2d5bf891805cff6c3160d0e6825cd Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2643563 Reviewed-by: Marja Hölttä <marja@chromium.org> Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Mythri Alle <mythria@chromium.org> Commit-Queue: Dan Clark <daniec@microsoft.com> Cr-Commit-Position: refs/heads/master@{#72299}
2021-01-21 21:42:57 +00:00
"export {} from './bar.js' assert { a: 'b' };");
[modules] Add refactored API to get ModuleRequests and expose import assertions This change refactors the v8.h API as discussed in https://docs.google.com/document/d/1yuXgNHSbTAPubT1Mg0JXp5uTrfirkvO1g5cHHCe-LmY/edit#heading=h.q0c9h4p928mn such that a v8::Module exposes module requests as a FixedArray of ModuleRequest objects, which can then be used to obtain their module specifier and source code offset. This replaces the old functions that passed back individual specifier Strings and Locations via repeated calls to getters that take an index. These are marked as deprecated. The new ModuleRequest interface includes a getter for an ImportAssertions FixedArray, which will contain the import assertions for the request if --harmony-import-assertions is set, and will be empty otherwise. One notable change here is that the APIs now return source code offsets rather than v8::Locations. The host must then call the new Module::SourceOffsetToLocation to convert these offsets into line/column numbers. This requires a bit more back-and-forth, but allows the host to defer the cost of converting from source offset to line/column numbers until an error needs to be reported, potentially skipping the work altogether. Bug: v8:10958 Change-Id: I181639737c701e467324e6c781aa4d7bdd87ae8c Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2545577 Commit-Queue: Dan Clark <daniec@microsoft.com> Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Marja Hölttä <marja@chromium.org> Cr-Commit-Position: refs/heads/master@{#71387}
2020-11-24 19:13:00 +00:00
ScriptOrigin origin = ModuleOrigin(v8_str("file.js"), CcTest::isolate());
ScriptCompiler::Source source(source_text, origin);
module = ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
CHECK_EQ(Module::kUninstantiated, module->GetStatus());
Local<FixedArray> module_requests = module->GetModuleRequests();
CHECK_EQ(2, module_requests->Length());
Local<ModuleRequest> module_request_0 =
[modules][api] Stop filtering import assertions based on list provided by the host The change https://chromium-review.googlesource.com/c/v8/v8/+/2572173 implemented HostGetSupportedImportAssertions [1] in a fairly literal sense, where the host supplies a list of supported import assertions and V8 filters the import assertions in a ModuleRequest and exposes only supported assertions via its API surface. However, we've decided that the interop guarantees provided by doing the filtering in V8 are probably not worth the added complexity. Thus, this change removes the filtering. Going forward, hosts will be expected to ignore unknown asserions received from V8. This is mostly a revert of https://chromium-review.googlesource.com/c/v8/v8/+/2572173, with v8::Isolate::CreateParams::supported_import_assertions being kept for now (since we first have to delete the Blink code that sets it), and a new comment in v8.h instructing hosts to ignore unknown assertions. [1] https://tc39.es/proposal-import-assertions/#sec-hostgetsupportedimportassertions Bug: v8:10958 Change-Id: I7e8e2a7fbfe2d5bf891805cff6c3160d0e6825cd Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2643563 Reviewed-by: Marja Hölttä <marja@chromium.org> Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Mythri Alle <mythria@chromium.org> Commit-Queue: Dan Clark <daniec@microsoft.com> Cr-Commit-Position: refs/heads/master@{#72299}
2021-01-21 21:42:57 +00:00
module_requests->Get(env.local(), 0).As<ModuleRequest>();
[modules] Add refactored API to get ModuleRequests and expose import assertions This change refactors the v8.h API as discussed in https://docs.google.com/document/d/1yuXgNHSbTAPubT1Mg0JXp5uTrfirkvO1g5cHHCe-LmY/edit#heading=h.q0c9h4p928mn such that a v8::Module exposes module requests as a FixedArray of ModuleRequest objects, which can then be used to obtain their module specifier and source code offset. This replaces the old functions that passed back individual specifier Strings and Locations via repeated calls to getters that take an index. These are marked as deprecated. The new ModuleRequest interface includes a getter for an ImportAssertions FixedArray, which will contain the import assertions for the request if --harmony-import-assertions is set, and will be empty otherwise. One notable change here is that the APIs now return source code offsets rather than v8::Locations. The host must then call the new Module::SourceOffsetToLocation to convert these offsets into line/column numbers. This requires a bit more back-and-forth, but allows the host to defer the cost of converting from source offset to line/column numbers until an error needs to be reported, potentially skipping the work altogether. Bug: v8:10958 Change-Id: I181639737c701e467324e6c781aa4d7bdd87ae8c Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2545577 Commit-Queue: Dan Clark <daniec@microsoft.com> Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Marja Hölttä <marja@chromium.org> Cr-Commit-Position: refs/heads/master@{#71387}
2020-11-24 19:13:00 +00:00
CHECK(v8_str("./foo.js")->StrictEquals(module_request_0->GetSpecifier()));
int offset = module_request_0->GetSourceOffset();
CHECK_EQ(7, offset);
Location loc = module->SourceOffsetToLocation(offset);
CHECK_EQ(0, loc.GetLineNumber());
CHECK_EQ(7, loc.GetColumnNumber());
CHECK_EQ(0, module_request_0->GetImportAssertions()->Length());
Local<ModuleRequest> module_request_1 =
[modules][api] Stop filtering import assertions based on list provided by the host The change https://chromium-review.googlesource.com/c/v8/v8/+/2572173 implemented HostGetSupportedImportAssertions [1] in a fairly literal sense, where the host supplies a list of supported import assertions and V8 filters the import assertions in a ModuleRequest and exposes only supported assertions via its API surface. However, we've decided that the interop guarantees provided by doing the filtering in V8 are probably not worth the added complexity. Thus, this change removes the filtering. Going forward, hosts will be expected to ignore unknown asserions received from V8. This is mostly a revert of https://chromium-review.googlesource.com/c/v8/v8/+/2572173, with v8::Isolate::CreateParams::supported_import_assertions being kept for now (since we first have to delete the Blink code that sets it), and a new comment in v8.h instructing hosts to ignore unknown assertions. [1] https://tc39.es/proposal-import-assertions/#sec-hostgetsupportedimportassertions Bug: v8:10958 Change-Id: I7e8e2a7fbfe2d5bf891805cff6c3160d0e6825cd Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2643563 Reviewed-by: Marja Hölttä <marja@chromium.org> Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Mythri Alle <mythria@chromium.org> Commit-Queue: Dan Clark <daniec@microsoft.com> Cr-Commit-Position: refs/heads/master@{#72299}
2021-01-21 21:42:57 +00:00
module_requests->Get(env.local(), 1).As<ModuleRequest>();
[modules] Add refactored API to get ModuleRequests and expose import assertions This change refactors the v8.h API as discussed in https://docs.google.com/document/d/1yuXgNHSbTAPubT1Mg0JXp5uTrfirkvO1g5cHHCe-LmY/edit#heading=h.q0c9h4p928mn such that a v8::Module exposes module requests as a FixedArray of ModuleRequest objects, which can then be used to obtain their module specifier and source code offset. This replaces the old functions that passed back individual specifier Strings and Locations via repeated calls to getters that take an index. These are marked as deprecated. The new ModuleRequest interface includes a getter for an ImportAssertions FixedArray, which will contain the import assertions for the request if --harmony-import-assertions is set, and will be empty otherwise. One notable change here is that the APIs now return source code offsets rather than v8::Locations. The host must then call the new Module::SourceOffsetToLocation to convert these offsets into line/column numbers. This requires a bit more back-and-forth, but allows the host to defer the cost of converting from source offset to line/column numbers until an error needs to be reported, potentially skipping the work altogether. Bug: v8:10958 Change-Id: I181639737c701e467324e6c781aa4d7bdd87ae8c Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2545577 Commit-Queue: Dan Clark <daniec@microsoft.com> Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Marja Hölttä <marja@chromium.org> Cr-Commit-Position: refs/heads/master@{#71387}
2020-11-24 19:13:00 +00:00
CHECK(v8_str("./bar.js")->StrictEquals(module_request_1->GetSpecifier()));
offset = module_request_1->GetSourceOffset();
CHECK_EQ(45, offset);
loc = module->SourceOffsetToLocation(offset);
CHECK_EQ(1, loc.GetLineNumber());
CHECK_EQ(15, loc.GetColumnNumber());
Local<FixedArray> import_assertions_1 =
module_request_1->GetImportAssertions();
CHECK_EQ(3, import_assertions_1->Length());
Local<String> assertion_key =
[modules][api] Stop filtering import assertions based on list provided by the host The change https://chromium-review.googlesource.com/c/v8/v8/+/2572173 implemented HostGetSupportedImportAssertions [1] in a fairly literal sense, where the host supplies a list of supported import assertions and V8 filters the import assertions in a ModuleRequest and exposes only supported assertions via its API surface. However, we've decided that the interop guarantees provided by doing the filtering in V8 are probably not worth the added complexity. Thus, this change removes the filtering. Going forward, hosts will be expected to ignore unknown asserions received from V8. This is mostly a revert of https://chromium-review.googlesource.com/c/v8/v8/+/2572173, with v8::Isolate::CreateParams::supported_import_assertions being kept for now (since we first have to delete the Blink code that sets it), and a new comment in v8.h instructing hosts to ignore unknown assertions. [1] https://tc39.es/proposal-import-assertions/#sec-hostgetsupportedimportassertions Bug: v8:10958 Change-Id: I7e8e2a7fbfe2d5bf891805cff6c3160d0e6825cd Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2643563 Reviewed-by: Marja Hölttä <marja@chromium.org> Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Mythri Alle <mythria@chromium.org> Commit-Queue: Dan Clark <daniec@microsoft.com> Cr-Commit-Position: refs/heads/master@{#72299}
2021-01-21 21:42:57 +00:00
import_assertions_1->Get(env.local(), 0).As<String>();
[modules] Add refactored API to get ModuleRequests and expose import assertions This change refactors the v8.h API as discussed in https://docs.google.com/document/d/1yuXgNHSbTAPubT1Mg0JXp5uTrfirkvO1g5cHHCe-LmY/edit#heading=h.q0c9h4p928mn such that a v8::Module exposes module requests as a FixedArray of ModuleRequest objects, which can then be used to obtain their module specifier and source code offset. This replaces the old functions that passed back individual specifier Strings and Locations via repeated calls to getters that take an index. These are marked as deprecated. The new ModuleRequest interface includes a getter for an ImportAssertions FixedArray, which will contain the import assertions for the request if --harmony-import-assertions is set, and will be empty otherwise. One notable change here is that the APIs now return source code offsets rather than v8::Locations. The host must then call the new Module::SourceOffsetToLocation to convert these offsets into line/column numbers. This requires a bit more back-and-forth, but allows the host to defer the cost of converting from source offset to line/column numbers until an error needs to be reported, potentially skipping the work altogether. Bug: v8:10958 Change-Id: I181639737c701e467324e6c781aa4d7bdd87ae8c Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2545577 Commit-Queue: Dan Clark <daniec@microsoft.com> Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Marja Hölttä <marja@chromium.org> Cr-Commit-Position: refs/heads/master@{#71387}
2020-11-24 19:13:00 +00:00
CHECK(v8_str("a")->StrictEquals(assertion_key));
Local<String> assertion_value =
[modules][api] Stop filtering import assertions based on list provided by the host The change https://chromium-review.googlesource.com/c/v8/v8/+/2572173 implemented HostGetSupportedImportAssertions [1] in a fairly literal sense, where the host supplies a list of supported import assertions and V8 filters the import assertions in a ModuleRequest and exposes only supported assertions via its API surface. However, we've decided that the interop guarantees provided by doing the filtering in V8 are probably not worth the added complexity. Thus, this change removes the filtering. Going forward, hosts will be expected to ignore unknown asserions received from V8. This is mostly a revert of https://chromium-review.googlesource.com/c/v8/v8/+/2572173, with v8::Isolate::CreateParams::supported_import_assertions being kept for now (since we first have to delete the Blink code that sets it), and a new comment in v8.h instructing hosts to ignore unknown assertions. [1] https://tc39.es/proposal-import-assertions/#sec-hostgetsupportedimportassertions Bug: v8:10958 Change-Id: I7e8e2a7fbfe2d5bf891805cff6c3160d0e6825cd Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2643563 Reviewed-by: Marja Hölttä <marja@chromium.org> Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Mythri Alle <mythria@chromium.org> Commit-Queue: Dan Clark <daniec@microsoft.com> Cr-Commit-Position: refs/heads/master@{#72299}
2021-01-21 21:42:57 +00:00
import_assertions_1->Get(env.local(), 1).As<String>();
[modules] Add refactored API to get ModuleRequests and expose import assertions This change refactors the v8.h API as discussed in https://docs.google.com/document/d/1yuXgNHSbTAPubT1Mg0JXp5uTrfirkvO1g5cHHCe-LmY/edit#heading=h.q0c9h4p928mn such that a v8::Module exposes module requests as a FixedArray of ModuleRequest objects, which can then be used to obtain their module specifier and source code offset. This replaces the old functions that passed back individual specifier Strings and Locations via repeated calls to getters that take an index. These are marked as deprecated. The new ModuleRequest interface includes a getter for an ImportAssertions FixedArray, which will contain the import assertions for the request if --harmony-import-assertions is set, and will be empty otherwise. One notable change here is that the APIs now return source code offsets rather than v8::Locations. The host must then call the new Module::SourceOffsetToLocation to convert these offsets into line/column numbers. This requires a bit more back-and-forth, but allows the host to defer the cost of converting from source offset to line/column numbers until an error needs to be reported, potentially skipping the work altogether. Bug: v8:10958 Change-Id: I181639737c701e467324e6c781aa4d7bdd87ae8c Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2545577 Commit-Queue: Dan Clark <daniec@microsoft.com> Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Marja Hölttä <marja@chromium.org> Cr-Commit-Position: refs/heads/master@{#71387}
2020-11-24 19:13:00 +00:00
CHECK(v8_str("b")->StrictEquals(assertion_value));
Allow casting to Primitive types from Data Although every Primitive is a Data, the Cast operations for the subclasses of Primitive do not allow casting directly from Data to the subclasses without first going through Value. Because of this, Primitives extracted from a V8::FixedArray require two casts to get to the "real" type. Thus, as a convenience to embedders, this change makes it possible to cast directly from Data to all the subtypes of Primitive. Also, this change makes the parameter names in the declarations match those in the definitions, though there does not seem to be a universally followed convention regarding these. Bug: v8:10958 Change-Id: I18dc3fbb9a9bccb2cb3b75efd829af64d46d8eb9 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2573816 Reviewed-by: Marja Hölttä <marja@chromium.org> Reviewed-by: Camillo Bruni <cbruni@chromium.org> Commit-Queue: Dan Clark <daniec@microsoft.com> Cr-Commit-Position: refs/heads/master@{#71649}
2020-12-04 02:50:17 +00:00
int32_t assertion_source_offset =
[modules][api] Stop filtering import assertions based on list provided by the host The change https://chromium-review.googlesource.com/c/v8/v8/+/2572173 implemented HostGetSupportedImportAssertions [1] in a fairly literal sense, where the host supplies a list of supported import assertions and V8 filters the import assertions in a ModuleRequest and exposes only supported assertions via its API surface. However, we've decided that the interop guarantees provided by doing the filtering in V8 are probably not worth the added complexity. Thus, this change removes the filtering. Going forward, hosts will be expected to ignore unknown asserions received from V8. This is mostly a revert of https://chromium-review.googlesource.com/c/v8/v8/+/2572173, with v8::Isolate::CreateParams::supported_import_assertions being kept for now (since we first have to delete the Blink code that sets it), and a new comment in v8.h instructing hosts to ignore unknown assertions. [1] https://tc39.es/proposal-import-assertions/#sec-hostgetsupportedimportassertions Bug: v8:10958 Change-Id: I7e8e2a7fbfe2d5bf891805cff6c3160d0e6825cd Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2643563 Reviewed-by: Marja Hölttä <marja@chromium.org> Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Mythri Alle <mythria@chromium.org> Commit-Queue: Dan Clark <daniec@microsoft.com> Cr-Commit-Position: refs/heads/master@{#72299}
2021-01-21 21:42:57 +00:00
import_assertions_1->Get(env.local(), 2).As<Int32>()->Value();
[modules] Add refactored API to get ModuleRequests and expose import assertions This change refactors the v8.h API as discussed in https://docs.google.com/document/d/1yuXgNHSbTAPubT1Mg0JXp5uTrfirkvO1g5cHHCe-LmY/edit#heading=h.q0c9h4p928mn such that a v8::Module exposes module requests as a FixedArray of ModuleRequest objects, which can then be used to obtain their module specifier and source code offset. This replaces the old functions that passed back individual specifier Strings and Locations via repeated calls to getters that take an index. These are marked as deprecated. The new ModuleRequest interface includes a getter for an ImportAssertions FixedArray, which will contain the import assertions for the request if --harmony-import-assertions is set, and will be empty otherwise. One notable change here is that the APIs now return source code offsets rather than v8::Locations. The host must then call the new Module::SourceOffsetToLocation to convert these offsets into line/column numbers. This requires a bit more back-and-forth, but allows the host to defer the cost of converting from source offset to line/column numbers until an error needs to be reported, potentially skipping the work altogether. Bug: v8:10958 Change-Id: I181639737c701e467324e6c781aa4d7bdd87ae8c Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2545577 Commit-Queue: Dan Clark <daniec@microsoft.com> Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Marja Hölttä <marja@chromium.org> Cr-Commit-Position: refs/heads/master@{#71387}
2020-11-24 19:13:00 +00:00
CHECK_EQ(65, assertion_source_offset);
loc = module->SourceOffsetToLocation(assertion_source_offset);
CHECK_EQ(1, loc.GetLineNumber());
CHECK_EQ(35, loc.GetColumnNumber());
}
[modules] Add ResolveModuleCallback that takes import assertions This change completes the necessary API changes for import assertions discussed in https://docs.google.com/document/d/1yuXgNHSbTAPubT1Mg0JXp5uTrfirkvO1g5cHHCe-LmY. The old ResolveCallback is deprecated and replaced with a ResolveModuleCallback that includes import assertions. Until ResolveCallback is removed, InstantiateModule and associated functions are modified to accept both types of callback, using the new one if it was supplied and the old one otherwise. An alternative that I chose not to go with would be to just duplicate InstantiateModule and associated functions for both callback types. SyntheticModule::PrepareInstantiate's callback parameter was unused so I removed it. Bug: v8:10958 Change-Id: I8e9fbaf9c2853b076b13da02473fbbe039b9db57 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2551919 Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Marja Hölttä <marja@chromium.org> Commit-Queue: Dan Clark <daniec@microsoft.com> Cr-Commit-Position: refs/heads/master@{#71506}
2020-11-25 19:10:03 +00:00
// foo.js
[modules] Add refactored API to get ModuleRequests and expose import assertions This change refactors the v8.h API as discussed in https://docs.google.com/document/d/1yuXgNHSbTAPubT1Mg0JXp5uTrfirkvO1g5cHHCe-LmY/edit#heading=h.q0c9h4p928mn such that a v8::Module exposes module requests as a FixedArray of ModuleRequest objects, which can then be used to obtain their module specifier and source code offset. This replaces the old functions that passed back individual specifier Strings and Locations via repeated calls to getters that take an index. These are marked as deprecated. The new ModuleRequest interface includes a getter for an ImportAssertions FixedArray, which will contain the import assertions for the request if --harmony-import-assertions is set, and will be empty otherwise. One notable change here is that the APIs now return source code offsets rather than v8::Locations. The host must then call the new Module::SourceOffsetToLocation to convert these offsets into line/column numbers. This requires a bit more back-and-forth, but allows the host to defer the cost of converting from source offset to line/column numbers until an error needs to be reported, potentially skipping the work altogether. Bug: v8:10958 Change-Id: I181639737c701e467324e6c781aa4d7bdd87ae8c Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2545577 Commit-Queue: Dan Clark <daniec@microsoft.com> Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Marja Hölttä <marja@chromium.org> Cr-Commit-Position: refs/heads/master@{#71387}
2020-11-24 19:13:00 +00:00
{
[modules] Add ResolveModuleCallback that takes import assertions This change completes the necessary API changes for import assertions discussed in https://docs.google.com/document/d/1yuXgNHSbTAPubT1Mg0JXp5uTrfirkvO1g5cHHCe-LmY. The old ResolveCallback is deprecated and replaced with a ResolveModuleCallback that includes import assertions. Until ResolveCallback is removed, InstantiateModule and associated functions are modified to accept both types of callback, using the new one if it was supplied and the old one otherwise. An alternative that I chose not to go with would be to just duplicate InstantiateModule and associated functions for both callback types. SyntheticModule::PrepareInstantiate's callback parameter was unused so I removed it. Bug: v8:10958 Change-Id: I8e9fbaf9c2853b076b13da02473fbbe039b9db57 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2551919 Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Marja Hölttä <marja@chromium.org> Commit-Queue: Dan Clark <daniec@microsoft.com> Cr-Commit-Position: refs/heads/master@{#71506}
2020-11-25 19:10:03 +00:00
Local<String> source_text = v8_str("Object.expando = 40");
ScriptOrigin origin = ModuleOrigin(v8_str("foo.js"), CcTest::isolate());
ScriptCompiler::Source source(source_text, origin);
fooModule =
ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
[modules] Add refactored API to get ModuleRequests and expose import assertions This change refactors the v8.h API as discussed in https://docs.google.com/document/d/1yuXgNHSbTAPubT1Mg0JXp5uTrfirkvO1g5cHHCe-LmY/edit#heading=h.q0c9h4p928mn such that a v8::Module exposes module requests as a FixedArray of ModuleRequest objects, which can then be used to obtain their module specifier and source code offset. This replaces the old functions that passed back individual specifier Strings and Locations via repeated calls to getters that take an index. These are marked as deprecated. The new ModuleRequest interface includes a getter for an ImportAssertions FixedArray, which will contain the import assertions for the request if --harmony-import-assertions is set, and will be empty otherwise. One notable change here is that the APIs now return source code offsets rather than v8::Locations. The host must then call the new Module::SourceOffsetToLocation to convert these offsets into line/column numbers. This requires a bit more back-and-forth, but allows the host to defer the cost of converting from source offset to line/column numbers until an error needs to be reported, potentially skipping the work altogether. Bug: v8:10958 Change-Id: I181639737c701e467324e6c781aa4d7bdd87ae8c Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2545577 Commit-Queue: Dan Clark <daniec@microsoft.com> Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Marja Hölttä <marja@chromium.org> Cr-Commit-Position: refs/heads/master@{#71387}
2020-11-24 19:13:00 +00:00
}
[modules] Add ResolveModuleCallback that takes import assertions This change completes the necessary API changes for import assertions discussed in https://docs.google.com/document/d/1yuXgNHSbTAPubT1Mg0JXp5uTrfirkvO1g5cHHCe-LmY. The old ResolveCallback is deprecated and replaced with a ResolveModuleCallback that includes import assertions. Until ResolveCallback is removed, InstantiateModule and associated functions are modified to accept both types of callback, using the new one if it was supplied and the old one otherwise. An alternative that I chose not to go with would be to just duplicate InstantiateModule and associated functions for both callback types. SyntheticModule::PrepareInstantiate's callback parameter was unused so I removed it. Bug: v8:10958 Change-Id: I8e9fbaf9c2853b076b13da02473fbbe039b9db57 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2551919 Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Marja Hölttä <marja@chromium.org> Commit-Queue: Dan Clark <daniec@microsoft.com> Cr-Commit-Position: refs/heads/master@{#71506}
2020-11-25 19:10:03 +00:00
// bar.js
{
Local<String> source_text = v8_str("Object.expando += 2");
ScriptOrigin origin = ModuleOrigin(v8_str("bar.js"), CcTest::isolate());
ScriptCompiler::Source source(source_text, origin);
barModule =
ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
}
CHECK(module
->InstantiateModule(env.local(),
ResolveCallbackWithImportAssertions)
.FromJust());
CHECK_EQ(Module::kInstantiated, module->GetStatus());
MaybeLocal<Value> result = module->Evaluate(env.local());
CHECK_EQ(Module::kEvaluated, module->GetStatus());
if (i::FLAG_harmony_top_level_await) {
Local<Promise> promise = Local<Promise>::Cast(result.ToLocalChecked());
CHECK_EQ(promise->State(), v8::Promise::kFulfilled);
CHECK(promise->Result()->IsUndefined());
} else {
CHECK(!result.IsEmpty());
[modules][api] Stop filtering import assertions based on list provided by the host The change https://chromium-review.googlesource.com/c/v8/v8/+/2572173 implemented HostGetSupportedImportAssertions [1] in a fairly literal sense, where the host supplies a list of supported import assertions and V8 filters the import assertions in a ModuleRequest and exposes only supported assertions via its API surface. However, we've decided that the interop guarantees provided by doing the filtering in V8 are probably not worth the added complexity. Thus, this change removes the filtering. Going forward, hosts will be expected to ignore unknown asserions received from V8. This is mostly a revert of https://chromium-review.googlesource.com/c/v8/v8/+/2572173, with v8::Isolate::CreateParams::supported_import_assertions being kept for now (since we first have to delete the Blink code that sets it), and a new comment in v8.h instructing hosts to ignore unknown assertions. [1] https://tc39.es/proposal-import-assertions/#sec-hostgetsupportedimportassertions Bug: v8:10958 Change-Id: I7e8e2a7fbfe2d5bf891805cff6c3160d0e6825cd Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2643563 Reviewed-by: Marja Hölttä <marja@chromium.org> Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Mythri Alle <mythria@chromium.org> Commit-Queue: Dan Clark <daniec@microsoft.com> Cr-Commit-Position: refs/heads/master@{#72299}
2021-01-21 21:42:57 +00:00
ExpectInt32("Object.expando", 42);
[modules] Add ResolveModuleCallback that takes import assertions This change completes the necessary API changes for import assertions discussed in https://docs.google.com/document/d/1yuXgNHSbTAPubT1Mg0JXp5uTrfirkvO1g5cHHCe-LmY. The old ResolveCallback is deprecated and replaced with a ResolveModuleCallback that includes import assertions. Until ResolveCallback is removed, InstantiateModule and associated functions are modified to accept both types of callback, using the new one if it was supplied and the old one otherwise. An alternative that I chose not to go with would be to just duplicate InstantiateModule and associated functions for both callback types. SyntheticModule::PrepareInstantiate's callback parameter was unused so I removed it. Bug: v8:10958 Change-Id: I8e9fbaf9c2853b076b13da02473fbbe039b9db57 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2551919 Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Marja Hölttä <marja@chromium.org> Commit-Queue: Dan Clark <daniec@microsoft.com> Cr-Commit-Position: refs/heads/master@{#71506}
2020-11-25 19:10:03 +00:00
}
[modules] Add refactored API to get ModuleRequests and expose import assertions This change refactors the v8.h API as discussed in https://docs.google.com/document/d/1yuXgNHSbTAPubT1Mg0JXp5uTrfirkvO1g5cHHCe-LmY/edit#heading=h.q0c9h4p928mn such that a v8::Module exposes module requests as a FixedArray of ModuleRequest objects, which can then be used to obtain their module specifier and source code offset. This replaces the old functions that passed back individual specifier Strings and Locations via repeated calls to getters that take an index. These are marked as deprecated. The new ModuleRequest interface includes a getter for an ImportAssertions FixedArray, which will contain the import assertions for the request if --harmony-import-assertions is set, and will be empty otherwise. One notable change here is that the APIs now return source code offsets rather than v8::Locations. The host must then call the new Module::SourceOffsetToLocation to convert these offsets into line/column numbers. This requires a bit more back-and-forth, but allows the host to defer the cost of converting from source offset to line/column numbers until an error needs to be reported, potentially skipping the work altogether. Bug: v8:10958 Change-Id: I181639737c701e467324e6c781aa4d7bdd87ae8c Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2545577 Commit-Queue: Dan Clark <daniec@microsoft.com> Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Marja Hölttä <marja@chromium.org> Cr-Commit-Position: refs/heads/master@{#71387}
2020-11-24 19:13:00 +00:00
CHECK(!try_catch.HasCaught());
}
i::FLAG_harmony_top_level_await = prev_top_level_await;
i::FLAG_harmony_import_assertions = prev_import_assertions;
}
[modules] Implement recent ES revisions. - Instantiation errors are no longer recorded. If instantiation fails, the module(s) are reset to "uninstantiated". When instantiation is re-attempted, the thrown exception will be fresh. - Instantiation can succeed even where there are modules in the graph that previously failed evaluation. Bug: v8:1569 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I429f616918afe5f8ab1a956024f0a22f464b8c44 Reviewed-on: https://chromium-review.googlesource.com/763369 Commit-Queue: Georg Neis <neis@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Cr-Commit-Position: refs/heads/master@{#50301}
2017-12-08 08:46:01 +00:00
TEST(ModuleInstantiationFailures2) {
[runtime] Use TLA in more tests Enable more tests to use top level await modules. Bug: v8:9344 Change-Id: I61c0c0205235969a43af602af327654b7e8a3dad Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2074402 Reviewed-by: Sathya Gunasekaran <gsathya@chromium.org> Commit-Queue: Camillo Bruni <cbruni@chromium.org> Cr-Commit-Position: refs/heads/master@{#66726}
2020-02-27 10:51:32 +00:00
bool prev_top_level_await = i::FLAG_harmony_top_level_await;
for (auto top_level_await : {true, false}) {
i::FLAG_harmony_top_level_await = top_level_await;
Isolate* isolate = CcTest::isolate();
HandleScope scope(isolate);
LocalContext env;
v8::TryCatch try_catch(isolate);
// root1.js
Local<Module> root;
{
Local<String> source_text =
v8_str("import './dep1.js'; import './dep2.js'");
ScriptOrigin origin = ModuleOrigin(v8_str("root1.js"), CcTest::isolate());
ScriptCompiler::Source source(source_text, origin);
root = ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
}
// dep1.js
{
Local<String> source_text = v8_str("export let x = 42");
ScriptOrigin origin = ModuleOrigin(v8_str("dep1.js"), CcTest::isolate());
ScriptCompiler::Source source(source_text, origin);
dep1 = ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
}
// dep2.js
{
Local<String> source_text = v8_str("import {foo} from './dep3.js'");
ScriptOrigin origin = ModuleOrigin(v8_str("dep2.js"), CcTest::isolate());
ScriptCompiler::Source source(source_text, origin);
dep2 = ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
}
{
v8::TryCatch inner_try_catch(isolate);
CHECK(root->InstantiateModule(env.local(), ResolveCallback).IsNothing());
CHECK(inner_try_catch.HasCaught());
CHECK(inner_try_catch.Exception()->StrictEquals(v8_str("boom")));
CHECK_EQ(Module::kUninstantiated, root->GetStatus());
CHECK_EQ(Module::kUninstantiated, dep1->GetStatus());
CHECK_EQ(Module::kUninstantiated, dep2->GetStatus());
}
// Change dep2.js
{
Local<String> source_text = v8_str("import {foo} from './dep2.js'");
ScriptOrigin origin = ModuleOrigin(v8_str("dep2.js"), CcTest::isolate());
ScriptCompiler::Source source(source_text, origin);
dep2 = ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
}
{
v8::TryCatch inner_try_catch(isolate);
CHECK(root->InstantiateModule(env.local(), ResolveCallback).IsNothing());
CHECK(inner_try_catch.HasCaught());
CHECK(!inner_try_catch.Exception()->StrictEquals(v8_str("boom")));
CHECK_EQ(Module::kUninstantiated, root->GetStatus());
CHECK_EQ(Module::kInstantiated, dep1->GetStatus());
CHECK_EQ(Module::kUninstantiated, dep2->GetStatus());
}
// Change dep2.js again
{
Local<String> source_text = v8_str("import {foo} from './dep3.js'");
ScriptOrigin origin = ModuleOrigin(v8_str("dep2.js"), CcTest::isolate());
ScriptCompiler::Source source(source_text, origin);
dep2 = ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
}
{
v8::TryCatch inner_try_catch(isolate);
CHECK(root->InstantiateModule(env.local(), ResolveCallback).IsNothing());
CHECK(inner_try_catch.HasCaught());
CHECK(inner_try_catch.Exception()->StrictEquals(v8_str("boom")));
CHECK_EQ(Module::kUninstantiated, root->GetStatus());
CHECK_EQ(Module::kInstantiated, dep1->GetStatus());
CHECK_EQ(Module::kUninstantiated, dep2->GetStatus());
}
[modules] Implement recent ES revisions. - Instantiation errors are no longer recorded. If instantiation fails, the module(s) are reset to "uninstantiated". When instantiation is re-attempted, the thrown exception will be fresh. - Instantiation can succeed even where there are modules in the graph that previously failed evaluation. Bug: v8:1569 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I429f616918afe5f8ab1a956024f0a22f464b8c44 Reviewed-on: https://chromium-review.googlesource.com/763369 Commit-Queue: Georg Neis <neis@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Cr-Commit-Position: refs/heads/master@{#50301}
2017-12-08 08:46:01 +00:00
}
[runtime] Use TLA in more tests Enable more tests to use top level await modules. Bug: v8:9344 Change-Id: I61c0c0205235969a43af602af327654b7e8a3dad Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2074402 Reviewed-by: Sathya Gunasekaran <gsathya@chromium.org> Commit-Queue: Camillo Bruni <cbruni@chromium.org> Cr-Commit-Position: refs/heads/master@{#66726}
2020-02-27 10:51:32 +00:00
i::FLAG_harmony_top_level_await = prev_top_level_await;
[modules] Implement recent ES revisions. - Instantiation errors are no longer recorded. If instantiation fails, the module(s) are reset to "uninstantiated". When instantiation is re-attempted, the thrown exception will be fresh. - Instantiation can succeed even where there are modules in the graph that previously failed evaluation. Bug: v8:1569 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I429f616918afe5f8ab1a956024f0a22f464b8c44 Reviewed-on: https://chromium-review.googlesource.com/763369 Commit-Queue: Georg Neis <neis@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Cr-Commit-Position: refs/heads/master@{#50301}
2017-12-08 08:46:01 +00:00
}
[modules] Expand API to allow linking and use it in d8 This patch gives the ability for the embedder to ask for the module requests of a module, and to pass a ResolveCallback into Module::Instantiate(). In d8, I've implemented a simple module_map that's used along with this API to allow loading, compiling, instantiating, and evaluating a whole tree of modules. No path resolution is yet implemented, meaning that all import paths are relative to whatever directory d8 runs in. And no imports are linked to the exports of the requested module. BUG=v8:1569 Review-Url: https://codereview.chromium.org/2351113004 Cr-Commit-Position: refs/heads/master@{#39569}
2016-09-20 23:38:58 +00:00
static MaybeLocal<Module> CompileSpecifierAsModuleResolveCallback(
[modules] Add ResolveModuleCallback that takes import assertions This change completes the necessary API changes for import assertions discussed in https://docs.google.com/document/d/1yuXgNHSbTAPubT1Mg0JXp5uTrfirkvO1g5cHHCe-LmY. The old ResolveCallback is deprecated and replaced with a ResolveModuleCallback that includes import assertions. Until ResolveCallback is removed, InstantiateModule and associated functions are modified to accept both types of callback, using the new one if it was supplied and the old one otherwise. An alternative that I chose not to go with would be to just duplicate InstantiateModule and associated functions for both callback types. SyntheticModule::PrepareInstantiate's callback parameter was unused so I removed it. Bug: v8:10958 Change-Id: I8e9fbaf9c2853b076b13da02473fbbe039b9db57 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2551919 Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Marja Hölttä <marja@chromium.org> Commit-Queue: Dan Clark <daniec@microsoft.com> Cr-Commit-Position: refs/heads/master@{#71506}
2020-11-25 19:10:03 +00:00
Local<Context> context, Local<String> specifier,
Local<FixedArray> import_assertions, Local<Module> referrer) {
CHECK_EQ(0, import_assertions->Length());
[modules] Add an IsModule flag to ScriptOriginOptions. Since the script origin is part of the key used in the compilation cache, this ensures that the cache never confuses a module with a non-module script. BUG=v8:1569,v8:5685 Review-Url: https://codereview.chromium.org/2611643002 Cr-Commit-Position: refs/heads/master@{#42490}
2017-01-19 06:59:20 +00:00
ScriptOrigin origin = ModuleOrigin(v8_str("module.js"), CcTest::isolate());
[modules] Expand API to allow linking and use it in d8 This patch gives the ability for the embedder to ask for the module requests of a module, and to pass a ResolveCallback into Module::Instantiate(). In d8, I've implemented a simple module_map that's used along with this API to allow loading, compiling, instantiating, and evaluating a whole tree of modules. No path resolution is yet implemented, meaning that all import paths are relative to whatever directory d8 runs in. And no imports are linked to the exports of the requested module. BUG=v8:1569 Review-Url: https://codereview.chromium.org/2351113004 Cr-Commit-Position: refs/heads/master@{#39569}
2016-09-20 23:38:58 +00:00
ScriptCompiler::Source source(specifier, origin);
return ScriptCompiler::CompileModule(CcTest::isolate(), &source)
.ToLocalChecked();
}
TEST(ModuleEvaluation) {
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
bool prev_top_level_await = i::FLAG_harmony_top_level_await;
for (auto top_level_await : {true, false}) {
i::FLAG_harmony_top_level_await = top_level_await;
Revert "[top-level-await] Implement top-level-await in V8" This reverts commit 591d1c9de4b3f2e4159c01d57f2c1e6e37d7cb41. Reason for revert: breaks blink Original change's description: > [top-level-await] Implement top-level-await in V8 > > Implements AsyncModules in SourceTextModule. However, there is no > support in the parser or D8 for actually creating / resolving > AsyncModules. Also adds a flag '--top-level-await,' but the only > external facing change with the flag enabled is that Module::Evaluate > returns a promise. > > Bug: v8:9344 > Change-Id: Idc722efc1e2aa780d04bdb985bb7920ab969d34e > Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1728037 > Reviewed-by: Ulan Degenbaev <ulan@chromium.org> > Reviewed-by: Georg Neis <neis@chromium.org> > Commit-Queue: Joshua Litt <joshualitt@chromium.org> > Cr-Commit-Position: refs/heads/master@{#63686} TBR=ulan@chromium.org,adamk@chromium.org,neis@chromium.org,joshualitt@chromium.org Change-Id: I6ceeb3a293a948af04bf200ab784ceb03386a3fd No-Presubmit: true No-Tree-Checks: true No-Try: true Bug: v8:9344 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797656 Reviewed-by: Zhi An Ng <zhin@chromium.org> Commit-Queue: Zhi An Ng <zhin@chromium.org> Cr-Commit-Position: refs/heads/master@{#63692}
2019-09-11 16:58:40 +00:00
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
Isolate* isolate = CcTest::isolate();
HandleScope scope(isolate);
LocalContext env;
v8::TryCatch try_catch(isolate);
Revert "[top-level-await] Implement top-level-await in V8" This reverts commit 591d1c9de4b3f2e4159c01d57f2c1e6e37d7cb41. Reason for revert: breaks blink Original change's description: > [top-level-await] Implement top-level-await in V8 > > Implements AsyncModules in SourceTextModule. However, there is no > support in the parser or D8 for actually creating / resolving > AsyncModules. Also adds a flag '--top-level-await,' but the only > external facing change with the flag enabled is that Module::Evaluate > returns a promise. > > Bug: v8:9344 > Change-Id: Idc722efc1e2aa780d04bdb985bb7920ab969d34e > Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1728037 > Reviewed-by: Ulan Degenbaev <ulan@chromium.org> > Reviewed-by: Georg Neis <neis@chromium.org> > Commit-Queue: Joshua Litt <joshualitt@chromium.org> > Cr-Commit-Position: refs/heads/master@{#63686} TBR=ulan@chromium.org,adamk@chromium.org,neis@chromium.org,joshualitt@chromium.org Change-Id: I6ceeb3a293a948af04bf200ab784ceb03386a3fd No-Presubmit: true No-Tree-Checks: true No-Try: true Bug: v8:9344 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797656 Reviewed-by: Zhi An Ng <zhin@chromium.org> Commit-Queue: Zhi An Ng <zhin@chromium.org> Cr-Commit-Position: refs/heads/master@{#63692}
2019-09-11 16:58:40 +00:00
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
Local<String> source_text = v8_str(
"import 'Object.expando = 5';"
"import 'Object.expando *= 2';");
[modules] Make Module::Evaluate return the completion value. This is more useful than always returning undefined. BUG=v8:1569,v8:5978 Change-Id: Id10cf87f7865db1a85de412460eaead4e4bf3b62 Reviewed-on: https://chromium-review.googlesource.com/446846 Reviewed-by: Adam Klein <adamk@chromium.org> Commit-Queue: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#43498}
2017-02-28 10:11:54 +00:00
ScriptOrigin origin = ModuleOrigin(v8_str("file.js"), CcTest::isolate());
ScriptCompiler::Source source(source_text, origin);
Local<Module> module =
ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
[api] Expose a module's status and exception. V8 now takes care of recording a module's status, as proposed in https://github.com/tc39/ecma262/pull/916. R=adamk@chromium.org Bug: v8:1569, chromium:594639 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: Id884f1c817e1dc3eea79a5d5a7f5cd996db1dbb0 Reviewed-on: https://chromium-review.googlesource.com/548500 Commit-Queue: Georg Neis <neis@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Cr-Commit-Position: refs/heads/master@{#46293}
2017-06-28 14:19:39 +00:00
CHECK_EQ(Module::kUninstantiated, module->GetStatus());
Update module APIs to return Maybe<bool> All APIs that can throw exceptions should return Maybe<> values BUG=none R=neis@chromium.org,gsathya@chromium.org Change-Id: I6a6e5888cd71257bb02bdcfcc587c909d0c1d8f4 Reviewed-on: https://chromium-review.googlesource.com/517785 Commit-Queue: Jochen Eisinger <jochen@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Reviewed-by: Sathya Gunasekaran <gsathya@chromium.org> Cr-Commit-Position: refs/heads/master@{#45557}
2017-05-29 11:57:50 +00:00
CHECK(module
->InstantiateModule(env.local(),
CompileSpecifierAsModuleResolveCallback)
.FromJust());
[api] Expose a module's status and exception. V8 now takes care of recording a module's status, as proposed in https://github.com/tc39/ecma262/pull/916. R=adamk@chromium.org Bug: v8:1569, chromium:594639 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: Id884f1c817e1dc3eea79a5d5a7f5cd996db1dbb0 Reviewed-on: https://chromium-review.googlesource.com/548500 Commit-Queue: Georg Neis <neis@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Cr-Commit-Position: refs/heads/master@{#46293}
2017-06-28 14:19:39 +00:00
CHECK_EQ(Module::kInstantiated, module->GetStatus());
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
MaybeLocal<Value> result = module->Evaluate(env.local());
[api] Expose a module's status and exception. V8 now takes care of recording a module's status, as proposed in https://github.com/tc39/ecma262/pull/916. R=adamk@chromium.org Bug: v8:1569, chromium:594639 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: Id884f1c817e1dc3eea79a5d5a7f5cd996db1dbb0 Reviewed-on: https://chromium-review.googlesource.com/548500 Commit-Queue: Georg Neis <neis@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Cr-Commit-Position: refs/heads/master@{#46293}
2017-06-28 14:19:39 +00:00
CHECK_EQ(Module::kEvaluated, module->GetStatus());
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
if (i::FLAG_harmony_top_level_await) {
[api] Use shorter 8::Local::As<*> casts in more places Bug: v8:11195 Change-Id: I19211af9e440940f85351fb38920eb620c222213 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2555010 Reviewed-by: Ross McIlroy <rmcilroy@chromium.org> Reviewed-by: Victor Gomes <victorgomes@chromium.org> Commit-Queue: Camillo Bruni <cbruni@chromium.org> Cr-Commit-Position: refs/heads/master@{#71465}
2020-11-27 16:06:57 +00:00
Local<Promise> promise = result.ToLocalChecked().As<Promise>();
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
CHECK_EQ(promise->State(), v8::Promise::kFulfilled);
CHECK(promise->Result()->IsUndefined());
} else {
CHECK(!result.IsEmpty());
ExpectInt32("Object.expando", 10);
}
CHECK(!try_catch.HasCaught());
[modules] Make Module::Evaluate return the completion value. This is more useful than always returning undefined. BUG=v8:1569,v8:5978 Change-Id: Id10cf87f7865db1a85de412460eaead4e4bf3b62 Reviewed-on: https://chromium-review.googlesource.com/446846 Reviewed-by: Adam Klein <adamk@chromium.org> Commit-Queue: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#43498}
2017-02-28 10:11:54 +00:00
}
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
i::FLAG_harmony_top_level_await = prev_top_level_await;
Revert "[top-level-await] Implement top-level-await in V8" This reverts commit 591d1c9de4b3f2e4159c01d57f2c1e6e37d7cb41. Reason for revert: breaks blink Original change's description: > [top-level-await] Implement top-level-await in V8 > > Implements AsyncModules in SourceTextModule. However, there is no > support in the parser or D8 for actually creating / resolving > AsyncModules. Also adds a flag '--top-level-await,' but the only > external facing change with the flag enabled is that Module::Evaluate > returns a promise. > > Bug: v8:9344 > Change-Id: Idc722efc1e2aa780d04bdb985bb7920ab969d34e > Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1728037 > Reviewed-by: Ulan Degenbaev <ulan@chromium.org> > Reviewed-by: Georg Neis <neis@chromium.org> > Commit-Queue: Joshua Litt <joshualitt@chromium.org> > Cr-Commit-Position: refs/heads/master@{#63686} TBR=ulan@chromium.org,adamk@chromium.org,neis@chromium.org,joshualitt@chromium.org Change-Id: I6ceeb3a293a948af04bf200ab784ceb03386a3fd No-Presubmit: true No-Tree-Checks: true No-Try: true Bug: v8:9344 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797656 Reviewed-by: Zhi An Ng <zhin@chromium.org> Commit-Queue: Zhi An Ng <zhin@chromium.org> Cr-Commit-Position: refs/heads/master@{#63692}
2019-09-11 16:58:40 +00:00
}
[top-level-await] Implement top-level-await in V8 Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: Idc722efc1e2aa780d04bdb985bb7920ab969d34e Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1728037 Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Commit-Queue: Joshua Litt <joshualitt@chromium.org> Cr-Commit-Position: refs/heads/master@{#63686}
2019-09-11 13:20:41 +00:00
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
TEST(ModuleEvaluationError1) {
bool prev_top_level_await = i::FLAG_harmony_top_level_await;
for (auto top_level_await : {true, false}) {
i::FLAG_harmony_top_level_await = top_level_await;
Isolate* isolate = CcTest::isolate();
HandleScope scope(isolate);
LocalContext env;
v8::TryCatch try_catch(isolate);
[modules] Make Module::Evaluate return the completion value. This is more useful than always returning undefined. BUG=v8:1569,v8:5978 Change-Id: Id10cf87f7865db1a85de412460eaead4e4bf3b62 Reviewed-on: https://chromium-review.googlesource.com/446846 Reviewed-by: Adam Klein <adamk@chromium.org> Commit-Queue: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#43498}
2017-02-28 10:11:54 +00:00
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
Local<String> source_text =
v8_str("Object.x = (Object.x || 0) + 1; throw 'boom';");
[modules] Make Module::Evaluate return the completion value. This is more useful than always returning undefined. BUG=v8:1569,v8:5978 Change-Id: Id10cf87f7865db1a85de412460eaead4e4bf3b62 Reviewed-on: https://chromium-review.googlesource.com/446846 Reviewed-by: Adam Klein <adamk@chromium.org> Commit-Queue: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#43498}
2017-02-28 10:11:54 +00:00
ScriptOrigin origin = ModuleOrigin(v8_str("file.js"), CcTest::isolate());
ScriptCompiler::Source source(source_text, origin);
Local<Module> module =
ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
[api] Expose a module's status and exception. V8 now takes care of recording a module's status, as proposed in https://github.com/tc39/ecma262/pull/916. R=adamk@chromium.org Bug: v8:1569, chromium:594639 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: Id884f1c817e1dc3eea79a5d5a7f5cd996db1dbb0 Reviewed-on: https://chromium-review.googlesource.com/548500 Commit-Queue: Georg Neis <neis@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Cr-Commit-Position: refs/heads/master@{#46293}
2017-06-28 14:19:39 +00:00
CHECK_EQ(Module::kUninstantiated, module->GetStatus());
Update module APIs to return Maybe<bool> All APIs that can throw exceptions should return Maybe<> values BUG=none R=neis@chromium.org,gsathya@chromium.org Change-Id: I6a6e5888cd71257bb02bdcfcc587c909d0c1d8f4 Reviewed-on: https://chromium-review.googlesource.com/517785 Commit-Queue: Jochen Eisinger <jochen@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Reviewed-by: Sathya Gunasekaran <gsathya@chromium.org> Cr-Commit-Position: refs/heads/master@{#45557}
2017-05-29 11:57:50 +00:00
CHECK(module
->InstantiateModule(env.local(),
CompileSpecifierAsModuleResolveCallback)
.FromJust());
[api] Expose a module's status and exception. V8 now takes care of recording a module's status, as proposed in https://github.com/tc39/ecma262/pull/916. R=adamk@chromium.org Bug: v8:1569, chromium:594639 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: Id884f1c817e1dc3eea79a5d5a7f5cd996db1dbb0 Reviewed-on: https://chromium-review.googlesource.com/548500 Commit-Queue: Georg Neis <neis@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Cr-Commit-Position: refs/heads/master@{#46293}
2017-06-28 14:19:39 +00:00
CHECK_EQ(Module::kInstantiated, module->GetStatus());
Revert "[top-level-await] Implement top-level-await in V8" This reverts commit 591d1c9de4b3f2e4159c01d57f2c1e6e37d7cb41. Reason for revert: breaks blink Original change's description: > [top-level-await] Implement top-level-await in V8 > > Implements AsyncModules in SourceTextModule. However, there is no > support in the parser or D8 for actually creating / resolving > AsyncModules. Also adds a flag '--top-level-await,' but the only > external facing change with the flag enabled is that Module::Evaluate > returns a promise. > > Bug: v8:9344 > Change-Id: Idc722efc1e2aa780d04bdb985bb7920ab969d34e > Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1728037 > Reviewed-by: Ulan Degenbaev <ulan@chromium.org> > Reviewed-by: Georg Neis <neis@chromium.org> > Commit-Queue: Joshua Litt <joshualitt@chromium.org> > Cr-Commit-Position: refs/heads/master@{#63686} TBR=ulan@chromium.org,adamk@chromium.org,neis@chromium.org,joshualitt@chromium.org Change-Id: I6ceeb3a293a948af04bf200ab784ceb03386a3fd No-Presubmit: true No-Tree-Checks: true No-Try: true Bug: v8:9344 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797656 Reviewed-by: Zhi An Ng <zhin@chromium.org> Commit-Queue: Zhi An Ng <zhin@chromium.org> Cr-Commit-Position: refs/heads/master@{#63692}
2019-09-11 16:58:40 +00:00
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
{
v8::TryCatch inner_try_catch(isolate);
[top-level-await] Stop throwing exceptions with TLA. Bug: v8:9970 Change-Id: I0e542fc63211e78800eab82257ccab9583305433 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1946534 Reviewed-by: Georg Neis <neis@chromium.org> Reviewed-by: Igor Sheludko <ishell@chromium.org> Commit-Queue: Joshua Litt <joshualitt@chromium.org> Cr-Commit-Position: refs/heads/master@{#65351}
2019-12-04 17:44:12 +00:00
MaybeLocal<Value> result = module->Evaluate(env.local());
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
CHECK_EQ(Module::kErrored, module->GetStatus());
Local<Value> exception = module->GetException();
CHECK(exception->StrictEquals(v8_str("boom")));
ExpectInt32("Object.x", 1);
[top-level-await] Stop throwing exceptions with TLA. Bug: v8:9970 Change-Id: I0e542fc63211e78800eab82257ccab9583305433 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1946534 Reviewed-by: Georg Neis <neis@chromium.org> Reviewed-by: Igor Sheludko <ishell@chromium.org> Commit-Queue: Joshua Litt <joshualitt@chromium.org> Cr-Commit-Position: refs/heads/master@{#65351}
2019-12-04 17:44:12 +00:00
if (i::FLAG_harmony_top_level_await) {
// With top level await, we do not throw and errored evaluation returns
// a rejected promise with the exception.
CHECK(!inner_try_catch.HasCaught());
[api] Use shorter 8::Local::As<*> casts in more places Bug: v8:11195 Change-Id: I19211af9e440940f85351fb38920eb620c222213 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2555010 Reviewed-by: Ross McIlroy <rmcilroy@chromium.org> Reviewed-by: Victor Gomes <victorgomes@chromium.org> Commit-Queue: Camillo Bruni <cbruni@chromium.org> Cr-Commit-Position: refs/heads/master@{#71465}
2020-11-27 16:06:57 +00:00
Local<Promise> promise = result.ToLocalChecked().As<Promise>();
[top-level-await] Stop throwing exceptions with TLA. Bug: v8:9970 Change-Id: I0e542fc63211e78800eab82257ccab9583305433 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1946534 Reviewed-by: Georg Neis <neis@chromium.org> Reviewed-by: Igor Sheludko <ishell@chromium.org> Commit-Queue: Joshua Litt <joshualitt@chromium.org> Cr-Commit-Position: refs/heads/master@{#65351}
2019-12-04 17:44:12 +00:00
CHECK_EQ(promise->State(), v8::Promise::kRejected);
CHECK_EQ(promise->Result(), module->GetException());
} else {
CHECK(inner_try_catch.HasCaught());
CHECK(inner_try_catch.Exception()->StrictEquals(v8_str("boom")));
CHECK(result.IsEmpty());
}
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
}
{
v8::TryCatch inner_try_catch(isolate);
[top-level-await] Stop throwing exceptions with TLA. Bug: v8:9970 Change-Id: I0e542fc63211e78800eab82257ccab9583305433 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1946534 Reviewed-by: Georg Neis <neis@chromium.org> Reviewed-by: Igor Sheludko <ishell@chromium.org> Commit-Queue: Joshua Litt <joshualitt@chromium.org> Cr-Commit-Position: refs/heads/master@{#65351}
2019-12-04 17:44:12 +00:00
MaybeLocal<Value> result = module->Evaluate(env.local());
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
CHECK_EQ(Module::kErrored, module->GetStatus());
Local<Value> exception = module->GetException();
CHECK(exception->StrictEquals(v8_str("boom")));
ExpectInt32("Object.x", 1);
if (i::FLAG_harmony_top_level_await) {
[top-level-await] Stop throwing exceptions with TLA. Bug: v8:9970 Change-Id: I0e542fc63211e78800eab82257ccab9583305433 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1946534 Reviewed-by: Georg Neis <neis@chromium.org> Reviewed-by: Igor Sheludko <ishell@chromium.org> Commit-Queue: Joshua Litt <joshualitt@chromium.org> Cr-Commit-Position: refs/heads/master@{#65351}
2019-12-04 17:44:12 +00:00
// With top level await, we do not throw and errored evaluation returns
// a rejected promise with the exception.
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
CHECK(!inner_try_catch.HasCaught());
[api] Use shorter 8::Local::As<*> casts in more places Bug: v8:11195 Change-Id: I19211af9e440940f85351fb38920eb620c222213 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2555010 Reviewed-by: Ross McIlroy <rmcilroy@chromium.org> Reviewed-by: Victor Gomes <victorgomes@chromium.org> Commit-Queue: Camillo Bruni <cbruni@chromium.org> Cr-Commit-Position: refs/heads/master@{#71465}
2020-11-27 16:06:57 +00:00
Local<Promise> promise = result.ToLocalChecked().As<Promise>();
[top-level-await] Stop throwing exceptions with TLA. Bug: v8:9970 Change-Id: I0e542fc63211e78800eab82257ccab9583305433 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1946534 Reviewed-by: Georg Neis <neis@chromium.org> Reviewed-by: Igor Sheludko <ishell@chromium.org> Commit-Queue: Joshua Litt <joshualitt@chromium.org> Cr-Commit-Position: refs/heads/master@{#65351}
2019-12-04 17:44:12 +00:00
CHECK_EQ(promise->State(), v8::Promise::kRejected);
CHECK_EQ(promise->Result(), module->GetException());
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
} else {
CHECK(inner_try_catch.HasCaught());
CHECK(inner_try_catch.Exception()->StrictEquals(v8_str("boom")));
[top-level-await] Stop throwing exceptions with TLA. Bug: v8:9970 Change-Id: I0e542fc63211e78800eab82257ccab9583305433 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1946534 Reviewed-by: Georg Neis <neis@chromium.org> Reviewed-by: Igor Sheludko <ishell@chromium.org> Commit-Queue: Joshua Litt <joshualitt@chromium.org> Cr-Commit-Position: refs/heads/master@{#65351}
2019-12-04 17:44:12 +00:00
CHECK(result.IsEmpty());
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
}
}
CHECK(!try_catch.HasCaught());
}
i::FLAG_harmony_top_level_await = prev_top_level_await;
[top-level-await] Implement top-level-await in V8 Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: Idc722efc1e2aa780d04bdb985bb7920ab969d34e Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1728037 Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Commit-Queue: Joshua Litt <joshualitt@chromium.org> Cr-Commit-Position: refs/heads/master@{#63686}
2019-09-11 13:20:41 +00:00
}
[api,modules] Allow GetModuleNamespace on unevaluated modules. Bug: v8:7217 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I97b067254355eb91e12b92eba92631cbc3ce8000 Reviewed-on: https://chromium-review.googlesource.com/839280 Commit-Queue: Georg Neis <neis@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Cr-Commit-Position: refs/heads/master@{#50395}
2017-12-21 14:49:09 +00:00
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
static Local<Module> failure_module;
static Local<Module> dependent_module;
MaybeLocal<Module> ResolveCallbackForModuleEvaluationError2(
[modules] Add ResolveModuleCallback that takes import assertions This change completes the necessary API changes for import assertions discussed in https://docs.google.com/document/d/1yuXgNHSbTAPubT1Mg0JXp5uTrfirkvO1g5cHHCe-LmY. The old ResolveCallback is deprecated and replaced with a ResolveModuleCallback that includes import assertions. Until ResolveCallback is removed, InstantiateModule and associated functions are modified to accept both types of callback, using the new one if it was supplied and the old one otherwise. An alternative that I chose not to go with would be to just duplicate InstantiateModule and associated functions for both callback types. SyntheticModule::PrepareInstantiate's callback parameter was unused so I removed it. Bug: v8:10958 Change-Id: I8e9fbaf9c2853b076b13da02473fbbe039b9db57 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2551919 Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Marja Hölttä <marja@chromium.org> Commit-Queue: Dan Clark <daniec@microsoft.com> Cr-Commit-Position: refs/heads/master@{#71506}
2020-11-25 19:10:03 +00:00
Local<Context> context, Local<String> specifier,
Local<FixedArray> import_assertions, Local<Module> referrer) {
CHECK_EQ(0, import_assertions->Length());
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
if (specifier->StrictEquals(v8_str("./failure.js"))) {
return failure_module;
} else {
CHECK(specifier->StrictEquals(v8_str("./dependent.js")));
return dependent_module;
[api,modules] Allow GetModuleNamespace on unevaluated modules. Bug: v8:7217 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I97b067254355eb91e12b92eba92631cbc3ce8000 Reviewed-on: https://chromium-review.googlesource.com/839280 Commit-Queue: Georg Neis <neis@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Cr-Commit-Position: refs/heads/master@{#50395}
2017-12-21 14:49:09 +00:00
}
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
}
[api,modules] Allow GetModuleNamespace on unevaluated modules. Bug: v8:7217 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I97b067254355eb91e12b92eba92631cbc3ce8000 Reviewed-on: https://chromium-review.googlesource.com/839280 Commit-Queue: Georg Neis <neis@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Cr-Commit-Position: refs/heads/master@{#50395}
2017-12-21 14:49:09 +00:00
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
TEST(ModuleEvaluationError2) {
bool prev_top_level_await = i::FLAG_harmony_top_level_await;
for (auto top_level_await : {true, false}) {
i::FLAG_harmony_top_level_await = top_level_await;
Isolate* isolate = CcTest::isolate();
HandleScope scope(isolate);
LocalContext env;
v8::TryCatch try_catch(isolate);
Local<String> failure_text = v8_str("throw 'boom';");
ScriptOrigin failure_origin =
ModuleOrigin(v8_str("failure.js"), CcTest::isolate());
ScriptCompiler::Source failure_source(failure_text, failure_origin);
failure_module = ScriptCompiler::CompileModule(isolate, &failure_source)
.ToLocalChecked();
CHECK_EQ(Module::kUninstantiated, failure_module->GetStatus());
CHECK(failure_module
->InstantiateModule(env.local(),
ResolveCallbackForModuleEvaluationError2)
.FromJust());
CHECK_EQ(Module::kInstantiated, failure_module->GetStatus());
{
v8::TryCatch inner_try_catch(isolate);
[top-level-await] Stop throwing exceptions with TLA. Bug: v8:9970 Change-Id: I0e542fc63211e78800eab82257ccab9583305433 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1946534 Reviewed-by: Georg Neis <neis@chromium.org> Reviewed-by: Igor Sheludko <ishell@chromium.org> Commit-Queue: Joshua Litt <joshualitt@chromium.org> Cr-Commit-Position: refs/heads/master@{#65351}
2019-12-04 17:44:12 +00:00
MaybeLocal<Value> result = failure_module->Evaluate(env.local());
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
CHECK_EQ(Module::kErrored, failure_module->GetStatus());
Local<Value> exception = failure_module->GetException();
CHECK(exception->StrictEquals(v8_str("boom")));
[top-level-await] Stop throwing exceptions with TLA. Bug: v8:9970 Change-Id: I0e542fc63211e78800eab82257ccab9583305433 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1946534 Reviewed-by: Georg Neis <neis@chromium.org> Reviewed-by: Igor Sheludko <ishell@chromium.org> Commit-Queue: Joshua Litt <joshualitt@chromium.org> Cr-Commit-Position: refs/heads/master@{#65351}
2019-12-04 17:44:12 +00:00
if (i::FLAG_harmony_top_level_await) {
// With top level await, we do not throw and errored evaluation returns
// a rejected promise with the exception.
CHECK(!inner_try_catch.HasCaught());
[api] Use shorter 8::Local::As<*> casts in more places Bug: v8:11195 Change-Id: I19211af9e440940f85351fb38920eb620c222213 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2555010 Reviewed-by: Ross McIlroy <rmcilroy@chromium.org> Reviewed-by: Victor Gomes <victorgomes@chromium.org> Commit-Queue: Camillo Bruni <cbruni@chromium.org> Cr-Commit-Position: refs/heads/master@{#71465}
2020-11-27 16:06:57 +00:00
Local<Promise> promise = result.ToLocalChecked().As<Promise>();
[top-level-await] Stop throwing exceptions with TLA. Bug: v8:9970 Change-Id: I0e542fc63211e78800eab82257ccab9583305433 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1946534 Reviewed-by: Georg Neis <neis@chromium.org> Reviewed-by: Igor Sheludko <ishell@chromium.org> Commit-Queue: Joshua Litt <joshualitt@chromium.org> Cr-Commit-Position: refs/heads/master@{#65351}
2019-12-04 17:44:12 +00:00
CHECK_EQ(promise->State(), v8::Promise::kRejected);
CHECK_EQ(promise->Result(), failure_module->GetException());
} else {
CHECK(inner_try_catch.HasCaught());
CHECK(inner_try_catch.Exception()->StrictEquals(v8_str("boom")));
CHECK(result.IsEmpty());
}
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
}
Local<String> dependent_text =
v8_str("import './failure.js'; export const c = 123;");
ScriptOrigin dependent_origin =
ModuleOrigin(v8_str("dependent.js"), CcTest::isolate());
ScriptCompiler::Source dependent_source(dependent_text, dependent_origin);
dependent_module = ScriptCompiler::CompileModule(isolate, &dependent_source)
.ToLocalChecked();
CHECK_EQ(Module::kUninstantiated, dependent_module->GetStatus());
CHECK(dependent_module
->InstantiateModule(env.local(),
ResolveCallbackForModuleEvaluationError2)
Revert "[top-level-await] Implement top-level-await in V8" This reverts commit 591d1c9de4b3f2e4159c01d57f2c1e6e37d7cb41. Reason for revert: breaks blink Original change's description: > [top-level-await] Implement top-level-await in V8 > > Implements AsyncModules in SourceTextModule. However, there is no > support in the parser or D8 for actually creating / resolving > AsyncModules. Also adds a flag '--top-level-await,' but the only > external facing change with the flag enabled is that Module::Evaluate > returns a promise. > > Bug: v8:9344 > Change-Id: Idc722efc1e2aa780d04bdb985bb7920ab969d34e > Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1728037 > Reviewed-by: Ulan Degenbaev <ulan@chromium.org> > Reviewed-by: Georg Neis <neis@chromium.org> > Commit-Queue: Joshua Litt <joshualitt@chromium.org> > Cr-Commit-Position: refs/heads/master@{#63686} TBR=ulan@chromium.org,adamk@chromium.org,neis@chromium.org,joshualitt@chromium.org Change-Id: I6ceeb3a293a948af04bf200ab784ceb03386a3fd No-Presubmit: true No-Tree-Checks: true No-Try: true Bug: v8:9344 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797656 Reviewed-by: Zhi An Ng <zhin@chromium.org> Commit-Queue: Zhi An Ng <zhin@chromium.org> Cr-Commit-Position: refs/heads/master@{#63692}
2019-09-11 16:58:40 +00:00
.FromJust());
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
CHECK_EQ(Module::kInstantiated, dependent_module->GetStatus());
{
v8::TryCatch inner_try_catch(isolate);
[top-level-await] Stop throwing exceptions with TLA. Bug: v8:9970 Change-Id: I0e542fc63211e78800eab82257ccab9583305433 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1946534 Reviewed-by: Georg Neis <neis@chromium.org> Reviewed-by: Igor Sheludko <ishell@chromium.org> Commit-Queue: Joshua Litt <joshualitt@chromium.org> Cr-Commit-Position: refs/heads/master@{#65351}
2019-12-04 17:44:12 +00:00
MaybeLocal<Value> result = dependent_module->Evaluate(env.local());
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
CHECK_EQ(Module::kErrored, dependent_module->GetStatus());
Local<Value> exception = dependent_module->GetException();
CHECK(exception->StrictEquals(v8_str("boom")));
CHECK_EQ(exception, failure_module->GetException());
if (i::FLAG_harmony_top_level_await) {
[top-level-await] Stop throwing exceptions with TLA. Bug: v8:9970 Change-Id: I0e542fc63211e78800eab82257ccab9583305433 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1946534 Reviewed-by: Georg Neis <neis@chromium.org> Reviewed-by: Igor Sheludko <ishell@chromium.org> Commit-Queue: Joshua Litt <joshualitt@chromium.org> Cr-Commit-Position: refs/heads/master@{#65351}
2019-12-04 17:44:12 +00:00
// With top level await, we do not throw and errored evaluation returns
// a rejected promise with the exception.
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
CHECK(!inner_try_catch.HasCaught());
[api] Use shorter 8::Local::As<*> casts in more places Bug: v8:11195 Change-Id: I19211af9e440940f85351fb38920eb620c222213 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2555010 Reviewed-by: Ross McIlroy <rmcilroy@chromium.org> Reviewed-by: Victor Gomes <victorgomes@chromium.org> Commit-Queue: Camillo Bruni <cbruni@chromium.org> Cr-Commit-Position: refs/heads/master@{#71465}
2020-11-27 16:06:57 +00:00
Local<Promise> promise = result.ToLocalChecked().As<Promise>();
[top-level-await] Stop throwing exceptions with TLA. Bug: v8:9970 Change-Id: I0e542fc63211e78800eab82257ccab9583305433 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1946534 Reviewed-by: Georg Neis <neis@chromium.org> Reviewed-by: Igor Sheludko <ishell@chromium.org> Commit-Queue: Joshua Litt <joshualitt@chromium.org> Cr-Commit-Position: refs/heads/master@{#65351}
2019-12-04 17:44:12 +00:00
CHECK_EQ(promise->State(), v8::Promise::kRejected);
CHECK_EQ(promise->Result(), failure_module->GetException());
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
} else {
CHECK(inner_try_catch.HasCaught());
CHECK(inner_try_catch.Exception()->StrictEquals(v8_str("boom")));
[top-level-await] Stop throwing exceptions with TLA. Bug: v8:9970 Change-Id: I0e542fc63211e78800eab82257ccab9583305433 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1946534 Reviewed-by: Georg Neis <neis@chromium.org> Reviewed-by: Igor Sheludko <ishell@chromium.org> Commit-Queue: Joshua Litt <joshualitt@chromium.org> Cr-Commit-Position: refs/heads/master@{#65351}
2019-12-04 17:44:12 +00:00
CHECK(result.IsEmpty());
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
}
}
CHECK(!try_catch.HasCaught());
[api,modules] Allow GetModuleNamespace on unevaluated modules. Bug: v8:7217 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I97b067254355eb91e12b92eba92631cbc3ce8000 Reviewed-on: https://chromium-review.googlesource.com/839280 Commit-Queue: Georg Neis <neis@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Cr-Commit-Position: refs/heads/master@{#50395}
2017-12-21 14:49:09 +00:00
}
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
i::FLAG_harmony_top_level_await = prev_top_level_await;
}
[api,modules] Allow GetModuleNamespace on unevaluated modules. Bug: v8:7217 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I97b067254355eb91e12b92eba92631cbc3ce8000 Reviewed-on: https://chromium-review.googlesource.com/839280 Commit-Queue: Georg Neis <neis@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Cr-Commit-Position: refs/heads/master@{#50395}
2017-12-21 14:49:09 +00:00
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
TEST(ModuleEvaluationCompletion1) {
bool prev_top_level_await = i::FLAG_harmony_top_level_await;
for (auto top_level_await : {true, false}) {
i::FLAG_harmony_top_level_await = top_level_await;
Isolate* isolate = CcTest::isolate();
HandleScope scope(isolate);
LocalContext env;
v8::TryCatch try_catch(isolate);
const char* sources[] = {
"",
"var a = 1",
"import '42'",
"export * from '42'",
"export {} from '42'",
"export {}",
"var a = 1; export {a}",
"export function foo() {}",
"export class C extends null {}",
"export let a = 1",
"export default 1",
"export default function foo() {}",
"export default function () {}",
"export default (function () {})",
"export default class C extends null {}",
"export default (class C extends null {})",
"for (var i = 0; i < 5; ++i) {}",
};
for (auto src : sources) {
Local<String> source_text = v8_str(src);
ScriptOrigin origin = ModuleOrigin(v8_str("file.js"), CcTest::isolate());
ScriptCompiler::Source source(source_text, origin);
Local<Module> module =
ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
CHECK_EQ(Module::kUninstantiated, module->GetStatus());
CHECK(module
->InstantiateModule(env.local(),
CompileSpecifierAsModuleResolveCallback)
.FromJust());
CHECK_EQ(Module::kInstantiated, module->GetStatus());
// Evaluate twice.
Local<Value> result_1 = module->Evaluate(env.local()).ToLocalChecked();
CHECK_EQ(Module::kEvaluated, module->GetStatus());
Local<Value> result_2 = module->Evaluate(env.local()).ToLocalChecked();
CHECK_EQ(Module::kEvaluated, module->GetStatus());
if (i::FLAG_harmony_top_level_await) {
[api] Use shorter 8::Local::As<*> casts in more places Bug: v8:11195 Change-Id: I19211af9e440940f85351fb38920eb620c222213 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2555010 Reviewed-by: Ross McIlroy <rmcilroy@chromium.org> Reviewed-by: Victor Gomes <victorgomes@chromium.org> Commit-Queue: Camillo Bruni <cbruni@chromium.org> Cr-Commit-Position: refs/heads/master@{#71465}
2020-11-27 16:06:57 +00:00
Local<Promise> promise = result_1.As<Promise>();
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
CHECK_EQ(promise->State(), v8::Promise::kFulfilled);
CHECK(promise->Result()->IsUndefined());
// Second evaluation should return the same promise.
[api] Use shorter 8::Local::As<*> casts in more places Bug: v8:11195 Change-Id: I19211af9e440940f85351fb38920eb620c222213 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2555010 Reviewed-by: Ross McIlroy <rmcilroy@chromium.org> Reviewed-by: Victor Gomes <victorgomes@chromium.org> Commit-Queue: Camillo Bruni <cbruni@chromium.org> Cr-Commit-Position: refs/heads/master@{#71465}
2020-11-27 16:06:57 +00:00
Local<Promise> promise_too = result_2.As<Promise>();
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
CHECK_EQ(promise, promise_too);
CHECK_EQ(promise_too->State(), v8::Promise::kFulfilled);
CHECK(promise_too->Result()->IsUndefined());
} else {
CHECK(result_1->IsUndefined());
CHECK(result_2->IsUndefined());
}
}
CHECK(!try_catch.HasCaught());
Revert "[top-level-await] Implement top-level-await in V8" This reverts commit 591d1c9de4b3f2e4159c01d57f2c1e6e37d7cb41. Reason for revert: breaks blink Original change's description: > [top-level-await] Implement top-level-await in V8 > > Implements AsyncModules in SourceTextModule. However, there is no > support in the parser or D8 for actually creating / resolving > AsyncModules. Also adds a flag '--top-level-await,' but the only > external facing change with the flag enabled is that Module::Evaluate > returns a promise. > > Bug: v8:9344 > Change-Id: Idc722efc1e2aa780d04bdb985bb7920ab969d34e > Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1728037 > Reviewed-by: Ulan Degenbaev <ulan@chromium.org> > Reviewed-by: Georg Neis <neis@chromium.org> > Commit-Queue: Joshua Litt <joshualitt@chromium.org> > Cr-Commit-Position: refs/heads/master@{#63686} TBR=ulan@chromium.org,adamk@chromium.org,neis@chromium.org,joshualitt@chromium.org Change-Id: I6ceeb3a293a948af04bf200ab784ceb03386a3fd No-Presubmit: true No-Tree-Checks: true No-Try: true Bug: v8:9344 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797656 Reviewed-by: Zhi An Ng <zhin@chromium.org> Commit-Queue: Zhi An Ng <zhin@chromium.org> Cr-Commit-Position: refs/heads/master@{#63692}
2019-09-11 16:58:40 +00:00
}
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
i::FLAG_harmony_top_level_await = prev_top_level_await;
}
[api,modules] Allow GetModuleNamespace on unevaluated modules. Bug: v8:7217 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I97b067254355eb91e12b92eba92631cbc3ce8000 Reviewed-on: https://chromium-review.googlesource.com/839280 Commit-Queue: Georg Neis <neis@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Cr-Commit-Position: refs/heads/master@{#50395}
2017-12-21 14:49:09 +00:00
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
TEST(ModuleEvaluationCompletion2) {
bool prev_top_level_await = i::FLAG_harmony_top_level_await;
for (auto top_level_await : {true, false}) {
i::FLAG_harmony_top_level_await = top_level_await;
Isolate* isolate = CcTest::isolate();
HandleScope scope(isolate);
LocalContext env;
v8::TryCatch try_catch(isolate);
const char* sources[] = {
"'gaga'; ",
"'gaga'; var a = 1",
"'gaga'; import '42'",
"'gaga'; export * from '42'",
"'gaga'; export {} from '42'",
"'gaga'; export {}",
"'gaga'; var a = 1; export {a}",
"'gaga'; export function foo() {}",
"'gaga'; export class C extends null {}",
"'gaga'; export let a = 1",
"'gaga'; export default 1",
"'gaga'; export default function foo() {}",
"'gaga'; export default function () {}",
"'gaga'; export default (function () {})",
"'gaga'; export default class C extends null {}",
"'gaga'; export default (class C extends null {})",
};
for (auto src : sources) {
Local<String> source_text = v8_str(src);
ScriptOrigin origin = ModuleOrigin(v8_str("file.js"), CcTest::isolate());
ScriptCompiler::Source source(source_text, origin);
Local<Module> module =
ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
CHECK_EQ(Module::kUninstantiated, module->GetStatus());
CHECK(module
->InstantiateModule(env.local(),
CompileSpecifierAsModuleResolveCallback)
.FromJust());
CHECK_EQ(Module::kInstantiated, module->GetStatus());
Local<Value> result_1 = module->Evaluate(env.local()).ToLocalChecked();
CHECK_EQ(Module::kEvaluated, module->GetStatus());
Local<Value> result_2 = module->Evaluate(env.local()).ToLocalChecked();
CHECK_EQ(Module::kEvaluated, module->GetStatus());
if (i::FLAG_harmony_top_level_await) {
[api] Use shorter 8::Local::As<*> casts in more places Bug: v8:11195 Change-Id: I19211af9e440940f85351fb38920eb620c222213 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2555010 Reviewed-by: Ross McIlroy <rmcilroy@chromium.org> Reviewed-by: Victor Gomes <victorgomes@chromium.org> Commit-Queue: Camillo Bruni <cbruni@chromium.org> Cr-Commit-Position: refs/heads/master@{#71465}
2020-11-27 16:06:57 +00:00
Local<Promise> promise = result_1.As<Promise>();
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
CHECK_EQ(promise->State(), v8::Promise::kFulfilled);
CHECK(promise->Result()->IsUndefined());
// Second Evaluation should return the same promise.
[api] Use shorter 8::Local::As<*> casts in more places Bug: v8:11195 Change-Id: I19211af9e440940f85351fb38920eb620c222213 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2555010 Reviewed-by: Ross McIlroy <rmcilroy@chromium.org> Reviewed-by: Victor Gomes <victorgomes@chromium.org> Commit-Queue: Camillo Bruni <cbruni@chromium.org> Cr-Commit-Position: refs/heads/master@{#71465}
2020-11-27 16:06:57 +00:00
Local<Promise> promise_too = result_2.As<Promise>();
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
CHECK_EQ(promise, promise_too);
CHECK_EQ(promise_too->State(), v8::Promise::kFulfilled);
CHECK(promise_too->Result()->IsUndefined());
} else {
CHECK(result_1->StrictEquals(v8_str("gaga")));
CHECK(result_2->IsUndefined());
}
}
CHECK(!try_catch.HasCaught());
Revert "[top-level-await] Implement top-level-await in V8" This reverts commit 591d1c9de4b3f2e4159c01d57f2c1e6e37d7cb41. Reason for revert: breaks blink Original change's description: > [top-level-await] Implement top-level-await in V8 > > Implements AsyncModules in SourceTextModule. However, there is no > support in the parser or D8 for actually creating / resolving > AsyncModules. Also adds a flag '--top-level-await,' but the only > external facing change with the flag enabled is that Module::Evaluate > returns a promise. > > Bug: v8:9344 > Change-Id: Idc722efc1e2aa780d04bdb985bb7920ab969d34e > Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1728037 > Reviewed-by: Ulan Degenbaev <ulan@chromium.org> > Reviewed-by: Georg Neis <neis@chromium.org> > Commit-Queue: Joshua Litt <joshualitt@chromium.org> > Cr-Commit-Position: refs/heads/master@{#63686} TBR=ulan@chromium.org,adamk@chromium.org,neis@chromium.org,joshualitt@chromium.org Change-Id: I6ceeb3a293a948af04bf200ab784ceb03386a3fd No-Presubmit: true No-Tree-Checks: true No-Try: true Bug: v8:9344 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797656 Reviewed-by: Zhi An Ng <zhin@chromium.org> Commit-Queue: Zhi An Ng <zhin@chromium.org> Cr-Commit-Position: refs/heads/master@{#63692}
2019-09-11 16:58:40 +00:00
}
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
i::FLAG_harmony_top_level_await = prev_top_level_await;
}
[api,modules] Allow GetModuleNamespace on unevaluated modules. Bug: v8:7217 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I97b067254355eb91e12b92eba92631cbc3ce8000 Reviewed-on: https://chromium-review.googlesource.com/839280 Commit-Queue: Georg Neis <neis@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Cr-Commit-Position: refs/heads/master@{#50395}
2017-12-21 14:49:09 +00:00
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
TEST(ModuleNamespace) {
bool prev_top_level_await = i::FLAG_harmony_top_level_await;
for (auto top_level_await : {true, false}) {
i::FLAG_harmony_top_level_await = top_level_await;
[api,modules] Allow GetModuleNamespace on unevaluated modules. Bug: v8:7217 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I97b067254355eb91e12b92eba92631cbc3ce8000 Reviewed-on: https://chromium-review.googlesource.com/839280 Commit-Queue: Georg Neis <neis@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Cr-Commit-Position: refs/heads/master@{#50395}
2017-12-21 14:49:09 +00:00
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
Isolate* isolate = CcTest::isolate();
HandleScope scope(isolate);
LocalContext env;
v8::TryCatch try_catch(isolate);
Revert "[top-level-await] Implement top-level-await in V8" This reverts commit 591d1c9de4b3f2e4159c01d57f2c1e6e37d7cb41. Reason for revert: breaks blink Original change's description: > [top-level-await] Implement top-level-await in V8 > > Implements AsyncModules in SourceTextModule. However, there is no > support in the parser or D8 for actually creating / resolving > AsyncModules. Also adds a flag '--top-level-await,' but the only > external facing change with the flag enabled is that Module::Evaluate > returns a promise. > > Bug: v8:9344 > Change-Id: Idc722efc1e2aa780d04bdb985bb7920ab969d34e > Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1728037 > Reviewed-by: Ulan Degenbaev <ulan@chromium.org> > Reviewed-by: Georg Neis <neis@chromium.org> > Commit-Queue: Joshua Litt <joshualitt@chromium.org> > Cr-Commit-Position: refs/heads/master@{#63686} TBR=ulan@chromium.org,adamk@chromium.org,neis@chromium.org,joshualitt@chromium.org Change-Id: I6ceeb3a293a948af04bf200ab784ceb03386a3fd No-Presubmit: true No-Tree-Checks: true No-Try: true Bug: v8:9344 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797656 Reviewed-by: Zhi An Ng <zhin@chromium.org> Commit-Queue: Zhi An Ng <zhin@chromium.org> Cr-Commit-Position: refs/heads/master@{#63692}
2019-09-11 16:58:40 +00:00
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
Local<v8::Object> ReferenceError =
CompileRun("ReferenceError")->ToObject(env.local()).ToLocalChecked();
[api,modules] Allow GetModuleNamespace on unevaluated modules. Bug: v8:7217 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I97b067254355eb91e12b92eba92631cbc3ce8000 Reviewed-on: https://chromium-review.googlesource.com/839280 Commit-Queue: Georg Neis <neis@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Cr-Commit-Position: refs/heads/master@{#50395}
2017-12-21 14:49:09 +00:00
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
Local<String> source_text = v8_str(
"import {a, b} from 'export var a = 1; export let b = 2';"
"export function geta() {return a};"
"export function getb() {return b};"
"export let radio = 3;"
"export var gaga = 4;");
ScriptOrigin origin = ModuleOrigin(v8_str("file.js"), CcTest::isolate());
ScriptCompiler::Source source(source_text, origin);
Local<Module> module =
ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
CHECK_EQ(Module::kUninstantiated, module->GetStatus());
CHECK(module
->InstantiateModule(env.local(),
CompileSpecifierAsModuleResolveCallback)
.FromJust());
CHECK_EQ(Module::kInstantiated, module->GetStatus());
Local<Value> ns = module->GetModuleNamespace();
CHECK_EQ(Module::kInstantiated, module->GetStatus());
Local<v8::Object> nsobj = ns->ToObject(env.local()).ToLocalChecked();
[api] Change CreationContext to return a MaybeHandle The current API returns a Handle<NativeContext> which can be optionally null and all the users of this API never actually checked for this null value. Previously, this wasn't a problem as all the possible JSObjects that were user visible would return a valid NativeContext but now there are wasm objects that don't have a valid constructor so don't have a NativeContext. Bug: v8:11451, chromium:1166077 Change-Id: I4fd5edf8f1a750e6f0abb931fd41358e5ae4dfcf Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2692695 Commit-Queue: Sathya Gunasekaran <gsathya@chromium.org> Reviewed-by: Toon Verwaest <verwaest@chromium.org> Reviewed-by: Benedikt Meurer <bmeurer@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Cr-Commit-Position: refs/heads/master@{#72769}
2021-02-16 10:27:07 +00:00
CHECK_EQ(nsobj->GetCreationContext().ToLocalChecked(), env.local());
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
// a, b
CHECK(nsobj->Get(env.local(), v8_str("a")).ToLocalChecked()->IsUndefined());
CHECK(nsobj->Get(env.local(), v8_str("b")).ToLocalChecked()->IsUndefined());
// geta
{
auto geta = nsobj->Get(env.local(), v8_str("geta")).ToLocalChecked();
auto a = geta.As<v8::Function>()
->Call(env.local(), geta, 0, nullptr)
.ToLocalChecked();
CHECK(a->IsUndefined());
}
// getb
{
v8::TryCatch inner_try_catch(isolate);
auto getb = nsobj->Get(env.local(), v8_str("getb")).ToLocalChecked();
CHECK(getb.As<v8::Function>()
->Call(env.local(), getb, 0, nullptr)
.IsEmpty());
CHECK(inner_try_catch.HasCaught());
CHECK(inner_try_catch.Exception()
->InstanceOf(env.local(), ReferenceError)
.FromJust());
}
// radio
{
v8::TryCatch inner_try_catch(isolate);
// https://bugs.chromium.org/p/v8/issues/detail?id=7235
// CHECK(nsobj->Get(env.local(), v8_str("radio")).IsEmpty());
CHECK(nsobj->Get(env.local(), v8_str("radio"))
.ToLocalChecked()
->IsUndefined());
CHECK(inner_try_catch.HasCaught());
CHECK(inner_try_catch.Exception()
->InstanceOf(env.local(), ReferenceError)
.FromJust());
}
// gaga
{
auto gaga = nsobj->Get(env.local(), v8_str("gaga")).ToLocalChecked();
CHECK(gaga->IsUndefined());
}
CHECK(!try_catch.HasCaught());
CHECK_EQ(Module::kInstantiated, module->GetStatus());
module->Evaluate(env.local()).ToLocalChecked();
CHECK_EQ(Module::kEvaluated, module->GetStatus());
Revert "[top-level-await] Implement top-level-await in V8" This reverts commit 591d1c9de4b3f2e4159c01d57f2c1e6e37d7cb41. Reason for revert: breaks blink Original change's description: > [top-level-await] Implement top-level-await in V8 > > Implements AsyncModules in SourceTextModule. However, there is no > support in the parser or D8 for actually creating / resolving > AsyncModules. Also adds a flag '--top-level-await,' but the only > external facing change with the flag enabled is that Module::Evaluate > returns a promise. > > Bug: v8:9344 > Change-Id: Idc722efc1e2aa780d04bdb985bb7920ab969d34e > Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1728037 > Reviewed-by: Ulan Degenbaev <ulan@chromium.org> > Reviewed-by: Georg Neis <neis@chromium.org> > Commit-Queue: Joshua Litt <joshualitt@chromium.org> > Cr-Commit-Position: refs/heads/master@{#63686} TBR=ulan@chromium.org,adamk@chromium.org,neis@chromium.org,joshualitt@chromium.org Change-Id: I6ceeb3a293a948af04bf200ab784ceb03386a3fd No-Presubmit: true No-Tree-Checks: true No-Try: true Bug: v8:9344 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797656 Reviewed-by: Zhi An Ng <zhin@chromium.org> Commit-Queue: Zhi An Ng <zhin@chromium.org> Cr-Commit-Position: refs/heads/master@{#63692}
2019-09-11 16:58:40 +00:00
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
// geta
{
auto geta = nsobj->Get(env.local(), v8_str("geta")).ToLocalChecked();
auto a = geta.As<v8::Function>()
->Call(env.local(), geta, 0, nullptr)
.ToLocalChecked();
CHECK_EQ(1, a->Int32Value(env.local()).FromJust());
}
// getb
{
auto getb = nsobj->Get(env.local(), v8_str("getb")).ToLocalChecked();
auto b = getb.As<v8::Function>()
->Call(env.local(), getb, 0, nullptr)
.ToLocalChecked();
CHECK_EQ(2, b->Int32Value(env.local()).FromJust());
}
// radio
{
auto radio = nsobj->Get(env.local(), v8_str("radio")).ToLocalChecked();
CHECK_EQ(3, radio->Int32Value(env.local()).FromJust());
}
// gaga
{
auto gaga = nsobj->Get(env.local(), v8_str("gaga")).ToLocalChecked();
CHECK_EQ(4, gaga->Int32Value(env.local()).FromJust());
}
CHECK(!try_catch.HasCaught());
[api,modules] Allow GetModuleNamespace on unevaluated modules. Bug: v8:7217 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I97b067254355eb91e12b92eba92631cbc3ce8000 Reviewed-on: https://chromium-review.googlesource.com/839280 Commit-Queue: Georg Neis <neis@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Cr-Commit-Position: refs/heads/master@{#50395}
2017-12-21 14:49:09 +00:00
}
Reland "[top-level-await] Implement top-level-await in V8" The first land did not correctly handle exceptions for already evaluated modules. Original description: Implements AsyncModules in SourceTextModule. However, there is no support in the parser or D8 for actually creating / resolving AsyncModules. Also adds a flag '--top-level-await,' but the only external facing change with the flag enabled is that Module::Evaluate returns a promise. Bug: v8:9344 Change-Id: I24725816ee4a6c3616c3c8b08a75a60ca9f27727 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1797658 Commit-Queue: Joshua Litt <joshualitt@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Cr-Commit-Position: refs/heads/master@{#63803}
2019-09-13 15:20:47 +00:00
i::FLAG_harmony_top_level_await = prev_top_level_await;
[api,modules] Allow GetModuleNamespace on unevaluated modules. Bug: v8:7217 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I97b067254355eb91e12b92eba92631cbc3ce8000 Reviewed-on: https://chromium-review.googlesource.com/839280 Commit-Queue: Georg Neis <neis@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Cr-Commit-Position: refs/heads/master@{#50395}
2017-12-21 14:49:09 +00:00
}
[top-level-await] Add support for parsing top level await Adds support for parsing top level await to V8, as well as many tests. This is the final cl in the series to add support for top level await to v8. Spec is here: https://tc39.es/proposal-top-level-await/#sec-execute-async-module Bug: v8:9344 Change-Id: Ie8f17ad8c7c60d1f6996d134ae154416cc1f31e3 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1703878 Reviewed-by: Georg Neis <neis@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Commit-Queue: Joshua Litt <joshualitt@chromium.org> Cr-Commit-Position: refs/heads/master@{#63946}
2019-09-23 15:42:10 +00:00
TEST(ModuleEvaluationTopLevelAwait) {
bool previous_top_level_await_flag_value = i::FLAG_harmony_top_level_await;
i::FLAG_harmony_top_level_await = true;
Isolate* isolate = CcTest::isolate();
HandleScope scope(isolate);
LocalContext env;
v8::TryCatch try_catch(isolate);
const char* sources[] = {
"await 42",
"import 'await 42';",
"import '42'; import 'await 42';",
};
for (auto src : sources) {
Local<String> source_text = v8_str(src);
ScriptOrigin origin = ModuleOrigin(v8_str("file.js"), CcTest::isolate());
ScriptCompiler::Source source(source_text, origin);
Local<Module> module =
ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
CHECK_EQ(Module::kUninstantiated, module->GetStatus());
CHECK(module
->InstantiateModule(env.local(),
CompileSpecifierAsModuleResolveCallback)
.FromJust());
CHECK_EQ(Module::kInstantiated, module->GetStatus());
Local<Promise> promise =
Local<Promise>::Cast(module->Evaluate(env.local()).ToLocalChecked());
CHECK_EQ(Module::kEvaluated, module->GetStatus());
CHECK_EQ(promise->State(), v8::Promise::kFulfilled);
CHECK(promise->Result()->IsUndefined());
CHECK(!try_catch.HasCaught());
}
i::FLAG_harmony_top_level_await = previous_top_level_await_flag_value;
}
TEST(ModuleEvaluationTopLevelAwaitError) {
bool previous_top_level_await_flag_value = i::FLAG_harmony_top_level_await;
i::FLAG_harmony_top_level_await = true;
Isolate* isolate = CcTest::isolate();
HandleScope scope(isolate);
LocalContext env;
const char* sources[] = {
"await 42; throw 'boom';",
"import 'await 42; throw \"boom\";';",
"import '42'; import 'await 42; throw \"boom\";';",
};
for (auto src : sources) {
v8::TryCatch try_catch(isolate);
Local<String> source_text = v8_str(src);
ScriptOrigin origin = ModuleOrigin(v8_str("file.js"), CcTest::isolate());
ScriptCompiler::Source source(source_text, origin);
Local<Module> module =
ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
CHECK_EQ(Module::kUninstantiated, module->GetStatus());
CHECK(module
->InstantiateModule(env.local(),
CompileSpecifierAsModuleResolveCallback)
.FromJust());
CHECK_EQ(Module::kInstantiated, module->GetStatus());
Local<Promise> promise =
Local<Promise>::Cast(module->Evaluate(env.local()).ToLocalChecked());
CHECK_EQ(Module::kErrored, module->GetStatus());
CHECK_EQ(promise->State(), v8::Promise::kRejected);
CHECK(promise->Result()->StrictEquals(v8_str("boom")));
CHECK(module->GetException()->StrictEquals(v8_str("boom")));
[d8] Claim TLA TODOs Bug: v8:9344 Change-Id: Iee66fc27b9f1c45ac3ac09dd82d88926414cc8f0 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2061558 Reviewed-by: Toon Verwaest <verwaest@chromium.org> Reviewed-by: Mathias Bynens <mathias@chromium.org> Commit-Queue: Camillo Bruni <cbruni@chromium.org> Cr-Commit-Position: refs/heads/master@{#66418}
2020-02-18 14:03:02 +00:00
// TODO(cbruni) I am not sure, but this might not be supposed to throw
[top-level-await] Add support for parsing top level await Adds support for parsing top level await to V8, as well as many tests. This is the final cl in the series to add support for top level await to v8. Spec is here: https://tc39.es/proposal-top-level-await/#sec-execute-async-module Bug: v8:9344 Change-Id: Ie8f17ad8c7c60d1f6996d134ae154416cc1f31e3 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1703878 Reviewed-by: Georg Neis <neis@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Commit-Queue: Joshua Litt <joshualitt@chromium.org> Cr-Commit-Position: refs/heads/master@{#63946}
2019-09-23 15:42:10 +00:00
// because it is async.
CHECK(!try_catch.HasCaught());
}
i::FLAG_harmony_top_level_await = previous_top_level_await_flag_value;
}
namespace {
struct DynamicImportData {
DynamicImportData(Isolate* isolate_, Local<Promise::Resolver> resolver_,
Local<Context> context_, bool should_resolve_)
: isolate(isolate_), should_resolve(should_resolve_) {
resolver.Reset(isolate, resolver_);
context.Reset(isolate, context_);
}
Isolate* isolate;
v8::Global<Promise::Resolver> resolver;
v8::Global<Context> context;
bool should_resolve;
};
void DoHostImportModuleDynamically(void* import_data) {
std::unique_ptr<DynamicImportData> import_data_(
static_cast<DynamicImportData*>(import_data));
Isolate* isolate(import_data_->isolate);
HandleScope handle_scope(isolate);
Local<Promise::Resolver> resolver(import_data_->resolver.Get(isolate));
Local<Context> realm(import_data_->context.Get(isolate));
Context::Scope context_scope(realm);
if (import_data_->should_resolve) {
resolver->Resolve(realm, True(isolate)).ToChecked();
} else {
resolver->Reject(realm, v8_str("boom")).ToChecked();
}
}
v8::MaybeLocal<v8::Promise> HostImportModuleDynamicallyCallbackResolve(
Local<Context> context, Local<v8::ScriptOrModule> referrer,
[modules][api] Add version of HostImportModuleDynamically with import assertions This change completes support for import assertions for dynamic import(). A new version of the HostImportModuleDynamically callback taking import assertions is added to the public API. The name is very verbose; we could consider removing the "ImportAssertions" part when the old API is removed. Bytecode generation is updated to pass the assertions, if present, to Runtime_DynamicImportCall. Isolate::RunHostImportModuleDynamicallyCallback extracts the assertions from the options bag, filters out the assertions not present in the list specified by the host in HostGetSupportedImportAssertions, and sorts them by code point order of the keys per https://tc39.es/proposal-import-assertions/#sec-import-call-runtime-semantics-evaluation. The resulting array is passed to the host in the callback. Bug: v8:10958 Change-Id: I931df00f954a9f9c65bff5bcf461ba1c8f11e94e Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2620578 Commit-Queue: Dan Clark <daniec@microsoft.com> Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Mythri Alle <mythria@chromium.org> Reviewed-by: Marja Hölttä <marja@chromium.org> Cr-Commit-Position: refs/heads/master@{#72307}
2021-01-26 01:38:33 +00:00
Local<String> specifier, Local<FixedArray> import_assertions) {
[top-level-await] Add support for parsing top level await Adds support for parsing top level await to V8, as well as many tests. This is the final cl in the series to add support for top level await to v8. Spec is here: https://tc39.es/proposal-top-level-await/#sec-execute-async-module Bug: v8:9344 Change-Id: Ie8f17ad8c7c60d1f6996d134ae154416cc1f31e3 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1703878 Reviewed-by: Georg Neis <neis@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Commit-Queue: Joshua Litt <joshualitt@chromium.org> Cr-Commit-Position: refs/heads/master@{#63946}
2019-09-23 15:42:10 +00:00
Isolate* isolate = context->GetIsolate();
Local<v8::Promise::Resolver> resolver =
v8::Promise::Resolver::New(context).ToLocalChecked();
DynamicImportData* data =
new DynamicImportData(isolate, resolver, context, true);
isolate->EnqueueMicrotask(DoHostImportModuleDynamically, data);
return resolver->GetPromise();
}
v8::MaybeLocal<v8::Promise> HostImportModuleDynamicallyCallbackReject(
Local<Context> context, Local<v8::ScriptOrModule> referrer,
[modules][api] Add version of HostImportModuleDynamically with import assertions This change completes support for import assertions for dynamic import(). A new version of the HostImportModuleDynamically callback taking import assertions is added to the public API. The name is very verbose; we could consider removing the "ImportAssertions" part when the old API is removed. Bytecode generation is updated to pass the assertions, if present, to Runtime_DynamicImportCall. Isolate::RunHostImportModuleDynamicallyCallback extracts the assertions from the options bag, filters out the assertions not present in the list specified by the host in HostGetSupportedImportAssertions, and sorts them by code point order of the keys per https://tc39.es/proposal-import-assertions/#sec-import-call-runtime-semantics-evaluation. The resulting array is passed to the host in the callback. Bug: v8:10958 Change-Id: I931df00f954a9f9c65bff5bcf461ba1c8f11e94e Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2620578 Commit-Queue: Dan Clark <daniec@microsoft.com> Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Mythri Alle <mythria@chromium.org> Reviewed-by: Marja Hölttä <marja@chromium.org> Cr-Commit-Position: refs/heads/master@{#72307}
2021-01-26 01:38:33 +00:00
Local<String> specifier, Local<FixedArray> import_assertions) {
[top-level-await] Add support for parsing top level await Adds support for parsing top level await to V8, as well as many tests. This is the final cl in the series to add support for top level await to v8. Spec is here: https://tc39.es/proposal-top-level-await/#sec-execute-async-module Bug: v8:9344 Change-Id: Ie8f17ad8c7c60d1f6996d134ae154416cc1f31e3 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1703878 Reviewed-by: Georg Neis <neis@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Commit-Queue: Joshua Litt <joshualitt@chromium.org> Cr-Commit-Position: refs/heads/master@{#63946}
2019-09-23 15:42:10 +00:00
Isolate* isolate = context->GetIsolate();
Local<v8::Promise::Resolver> resolver =
v8::Promise::Resolver::New(context).ToLocalChecked();
DynamicImportData* data =
new DynamicImportData(isolate, resolver, context, false);
isolate->EnqueueMicrotask(DoHostImportModuleDynamically, data);
return resolver->GetPromise();
}
} // namespace
TEST(ModuleEvaluationTopLevelAwaitDynamicImport) {
bool previous_top_level_await_flag_value = i::FLAG_harmony_top_level_await;
i::FLAG_harmony_top_level_await = true;
Isolate* isolate = CcTest::isolate();
HandleScope scope(isolate);
isolate->SetMicrotasksPolicy(v8::MicrotasksPolicy::kExplicit);
isolate->SetHostImportModuleDynamicallyCallback(
HostImportModuleDynamicallyCallbackResolve);
LocalContext env;
v8::TryCatch try_catch(isolate);
const char* sources[] = {
"await import('foo');",
"import 'await import(\"foo\");';",
"import '42'; import 'await import(\"foo\");';",
};
for (auto src : sources) {
Local<String> source_text = v8_str(src);
ScriptOrigin origin = ModuleOrigin(v8_str("file.js"), CcTest::isolate());
ScriptCompiler::Source source(source_text, origin);
Local<Module> module =
ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
CHECK_EQ(Module::kUninstantiated, module->GetStatus());
CHECK(module
->InstantiateModule(env.local(),
CompileSpecifierAsModuleResolveCallback)
.FromJust());
CHECK_EQ(Module::kInstantiated, module->GetStatus());
Local<Promise> promise =
Local<Promise>::Cast(module->Evaluate(env.local()).ToLocalChecked());
CHECK_EQ(Module::kEvaluated, module->GetStatus());
CHECK_EQ(promise->State(), v8::Promise::kPending);
CHECK(!try_catch.HasCaught());
[weakrefs] Call Isolate::ClearKeptObjects() as part of microtask checkpoint In the spec, WeakRefs that are dereferenced are kept alive until there's no JS on the stack, and then the host is expected to call ClearKeptObjects to clear those strong references [1]. HTML calls ClearKeptObjects at the end of a PerformMicrotaskCheckpoint [2]. In V8, leaving this up to the embedder is error prone in the same way the deprecated FinalizationGroup callback APIs were error prone: it depends on the embedder doing the right thing. This CL moves the call to ClearKeptObjects to be after running of microtasks within V8. However, the Isolate::ClearKeptObjects API should not be removed or deprecated in case an embedder uses an entirely custom MicrotaskQueue implementation and invokes MicrotaskQueue::PerformCheckpoint manually. [1] https://tc39.es/proposal-weakrefs/#sec-clear-kept-objects [2] https://github.com/whatwg/html/pull/4571 Bug: v8:8179 Change-Id: Ie243804157b56241ca69ed8fad300e839a0c9f75 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2055967 Commit-Queue: Shu-yu Guo <syg@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Ross McIlroy <rmcilroy@chromium.org> Cr-Commit-Position: refs/heads/master@{#66327}
2020-02-19 01:22:49 +00:00
isolate->PerformMicrotaskCheckpoint();
[top-level-await] Add support for parsing top level await Adds support for parsing top level await to V8, as well as many tests. This is the final cl in the series to add support for top level await to v8. Spec is here: https://tc39.es/proposal-top-level-await/#sec-execute-async-module Bug: v8:9344 Change-Id: Ie8f17ad8c7c60d1f6996d134ae154416cc1f31e3 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1703878 Reviewed-by: Georg Neis <neis@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Commit-Queue: Joshua Litt <joshualitt@chromium.org> Cr-Commit-Position: refs/heads/master@{#63946}
2019-09-23 15:42:10 +00:00
CHECK_EQ(promise->State(), v8::Promise::kFulfilled);
}
i::FLAG_harmony_top_level_await = previous_top_level_await_flag_value;
}
TEST(ModuleEvaluationTopLevelAwaitDynamicImportError) {
bool previous_top_level_await_flag_value = i::FLAG_harmony_top_level_await;
i::FLAG_harmony_top_level_await = true;
Isolate* isolate = CcTest::isolate();
HandleScope scope(isolate);
isolate->SetMicrotasksPolicy(v8::MicrotasksPolicy::kExplicit);
isolate->SetHostImportModuleDynamicallyCallback(
HostImportModuleDynamicallyCallbackReject);
LocalContext env;
v8::TryCatch try_catch(isolate);
const char* sources[] = {
"await import('foo');",
"import 'await import(\"foo\");';",
"import '42'; import 'await import(\"foo\");';",
};
for (auto src : sources) {
Local<String> source_text = v8_str(src);
ScriptOrigin origin = ModuleOrigin(v8_str("file.js"), CcTest::isolate());
ScriptCompiler::Source source(source_text, origin);
Local<Module> module =
ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
CHECK_EQ(Module::kUninstantiated, module->GetStatus());
CHECK(module
->InstantiateModule(env.local(),
CompileSpecifierAsModuleResolveCallback)
.FromJust());
CHECK_EQ(Module::kInstantiated, module->GetStatus());
Local<Promise> promise =
Local<Promise>::Cast(module->Evaluate(env.local()).ToLocalChecked());
CHECK_EQ(Module::kEvaluated, module->GetStatus());
CHECK_EQ(promise->State(), v8::Promise::kPending);
CHECK(!try_catch.HasCaught());
[weakrefs] Call Isolate::ClearKeptObjects() as part of microtask checkpoint In the spec, WeakRefs that are dereferenced are kept alive until there's no JS on the stack, and then the host is expected to call ClearKeptObjects to clear those strong references [1]. HTML calls ClearKeptObjects at the end of a PerformMicrotaskCheckpoint [2]. In V8, leaving this up to the embedder is error prone in the same way the deprecated FinalizationGroup callback APIs were error prone: it depends on the embedder doing the right thing. This CL moves the call to ClearKeptObjects to be after running of microtasks within V8. However, the Isolate::ClearKeptObjects API should not be removed or deprecated in case an embedder uses an entirely custom MicrotaskQueue implementation and invokes MicrotaskQueue::PerformCheckpoint manually. [1] https://tc39.es/proposal-weakrefs/#sec-clear-kept-objects [2] https://github.com/whatwg/html/pull/4571 Bug: v8:8179 Change-Id: Ie243804157b56241ca69ed8fad300e839a0c9f75 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2055967 Commit-Queue: Shu-yu Guo <syg@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Ross McIlroy <rmcilroy@chromium.org> Cr-Commit-Position: refs/heads/master@{#66327}
2020-02-19 01:22:49 +00:00
isolate->PerformMicrotaskCheckpoint();
[top-level-await] Add support for parsing top level await Adds support for parsing top level await to V8, as well as many tests. This is the final cl in the series to add support for top level await to v8. Spec is here: https://tc39.es/proposal-top-level-await/#sec-execute-async-module Bug: v8:9344 Change-Id: Ie8f17ad8c7c60d1f6996d134ae154416cc1f31e3 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1703878 Reviewed-by: Georg Neis <neis@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Commit-Queue: Joshua Litt <joshualitt@chromium.org> Cr-Commit-Position: refs/heads/master@{#63946}
2019-09-23 15:42:10 +00:00
CHECK_EQ(Module::kErrored, module->GetStatus());
CHECK_EQ(promise->State(), v8::Promise::kRejected);
CHECK(promise->Result()->StrictEquals(v8_str("boom")));
CHECK(module->GetException()->StrictEquals(v8_str("boom")));
CHECK(!try_catch.HasCaught());
}
i::FLAG_harmony_top_level_await = previous_top_level_await_flag_value;
}
[top-level-await] fix handling termination exceptions Properly handle termination exceptions in TLA modules. Bug: v8:9978 Change-Id: Ica70a55d1f54ec89d175d7c846e9a405eaffe0a0 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1920750 Commit-Queue: Georg Neis <neis@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Reviewed-by: Yang Guo <yangguo@chromium.org> Reviewed-by: Joshua Litt <joshualitt@chromium.org> Cr-Commit-Position: refs/heads/master@{#65135}
2019-11-24 17:51:12 +00:00
TEST(TerminateExecutionTopLevelAwaitSync) {
bool previous_top_level_await_flag_value = i::FLAG_harmony_top_level_await;
i::FLAG_harmony_top_level_await = true;
Isolate* isolate = CcTest::isolate();
HandleScope scope(isolate);
LocalContext env;
v8::TryCatch try_catch(isolate);
env.local()
->Global()
->Set(env.local(), v8_str("terminate"),
v8::Function::New(env.local(),
[](const v8::FunctionCallbackInfo<Value>& info) {
info.GetIsolate()->TerminateExecution();
})
.ToLocalChecked())
.ToChecked();
Local<String> source_text = v8_str("terminate(); while (true) {}");
ScriptOrigin origin = ModuleOrigin(v8_str("file.js"), CcTest::isolate());
ScriptCompiler::Source source(source_text, origin);
Local<Module> module =
ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
CHECK(module
->InstantiateModule(env.local(),
CompileSpecifierAsModuleResolveCallback)
.FromJust());
CHECK(module->Evaluate(env.local()).IsEmpty());
CHECK(try_catch.HasCaught());
CHECK(try_catch.HasTerminated());
CHECK_EQ(module->GetStatus(), Module::kErrored);
CHECK_EQ(module->GetException(), v8::Null(isolate));
i::FLAG_harmony_top_level_await = previous_top_level_await_flag_value;
}
TEST(TerminateExecutionTopLevelAwaitAsync) {
bool previous_top_level_await_flag_value = i::FLAG_harmony_top_level_await;
i::FLAG_harmony_top_level_await = true;
Isolate* isolate = CcTest::isolate();
HandleScope scope(isolate);
LocalContext env;
v8::TryCatch try_catch(isolate);
env.local()
->Global()
->Set(env.local(), v8_str("terminate"),
v8::Function::New(env.local(),
[](const v8::FunctionCallbackInfo<Value>& info) {
info.GetIsolate()->TerminateExecution();
})
.ToLocalChecked())
.ToChecked();
Local<Promise::Resolver> eval_promise =
Promise::Resolver::New(env.local()).ToLocalChecked();
env.local()
->Global()
->Set(env.local(), v8_str("evalPromise"), eval_promise)
.ToChecked();
Local<String> source_text =
v8_str("await evalPromise; terminate(); while (true) {}");
ScriptOrigin origin = ModuleOrigin(v8_str("file.js"), CcTest::isolate());
ScriptCompiler::Source source(source_text, origin);
Local<Module> module =
ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
CHECK(module
->InstantiateModule(env.local(),
CompileSpecifierAsModuleResolveCallback)
.FromJust());
Local<Promise> promise =
Local<Promise>::Cast(module->Evaluate(env.local()).ToLocalChecked());
CHECK_EQ(module->GetStatus(), Module::kEvaluated);
CHECK_EQ(promise->State(), Promise::PromiseState::kPending);
CHECK(!try_catch.HasCaught());
CHECK(!try_catch.HasTerminated());
eval_promise->Resolve(env.local(), v8::Undefined(isolate)).ToChecked();
CHECK(try_catch.HasCaught());
CHECK(try_catch.HasTerminated());
CHECK_EQ(promise->State(), Promise::PromiseState::kPending);
// The termination exception doesn't trigger the module's
// catch handler, so the module isn't transitioned to kErrored.
CHECK_EQ(module->GetStatus(), Module::kEvaluated);
i::FLAG_harmony_top_level_await = previous_top_level_await_flag_value;
}
[top-level-await] Implement v8::Module::IsGraphAsync() This is a predicate checking if any module in a module graph is [[Async]], i.e. contains a top-level await. It is needed for ServiceWorker integration, as ServiceWorkers disallows top-level await in its modules to prevent stalling during registration. https://github.com/w3c/ServiceWorker/pull/1444 Bug: v8:9344 Change-Id: Id84489bc73717b4c9950059c8ff6def9297499d0 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2451212 Commit-Queue: Shu-yu Guo <syg@chromium.org> Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Cr-Commit-Position: refs/heads/master@{#70390}
2020-10-07 16:37:03 +00:00
static Local<Module> async_leaf_module;
static Local<Module> sync_leaf_module;
static Local<Module> cycle_self_module;
static Local<Module> cycle_one_module;
static Local<Module> cycle_two_module;
MaybeLocal<Module> ResolveCallbackForIsGraphAsyncTopLevelAwait(
[modules] Add ResolveModuleCallback that takes import assertions This change completes the necessary API changes for import assertions discussed in https://docs.google.com/document/d/1yuXgNHSbTAPubT1Mg0JXp5uTrfirkvO1g5cHHCe-LmY. The old ResolveCallback is deprecated and replaced with a ResolveModuleCallback that includes import assertions. Until ResolveCallback is removed, InstantiateModule and associated functions are modified to accept both types of callback, using the new one if it was supplied and the old one otherwise. An alternative that I chose not to go with would be to just duplicate InstantiateModule and associated functions for both callback types. SyntheticModule::PrepareInstantiate's callback parameter was unused so I removed it. Bug: v8:10958 Change-Id: I8e9fbaf9c2853b076b13da02473fbbe039b9db57 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2551919 Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Marja Hölttä <marja@chromium.org> Commit-Queue: Dan Clark <daniec@microsoft.com> Cr-Commit-Position: refs/heads/master@{#71506}
2020-11-25 19:10:03 +00:00
Local<Context> context, Local<String> specifier,
Local<FixedArray> import_assertions, Local<Module> referrer) {
CHECK_EQ(0, import_assertions->Length());
[top-level-await] Implement v8::Module::IsGraphAsync() This is a predicate checking if any module in a module graph is [[Async]], i.e. contains a top-level await. It is needed for ServiceWorker integration, as ServiceWorkers disallows top-level await in its modules to prevent stalling during registration. https://github.com/w3c/ServiceWorker/pull/1444 Bug: v8:9344 Change-Id: Id84489bc73717b4c9950059c8ff6def9297499d0 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2451212 Commit-Queue: Shu-yu Guo <syg@chromium.org> Reviewed-by: Camillo Bruni <cbruni@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Cr-Commit-Position: refs/heads/master@{#70390}
2020-10-07 16:37:03 +00:00
if (specifier->StrictEquals(v8_str("./async_leaf.js"))) {
return async_leaf_module;
} else if (specifier->StrictEquals(v8_str("./sync_leaf.js"))) {
return sync_leaf_module;
} else if (specifier->StrictEquals(v8_str("./cycle_self.js"))) {
return cycle_self_module;
} else if (specifier->StrictEquals(v8_str("./cycle_one.js"))) {
return cycle_one_module;
} else {
CHECK(specifier->StrictEquals(v8_str("./cycle_two.js")));
return cycle_two_module;
}
}
TEST(IsGraphAsyncTopLevelAwait) {
bool previous_top_level_await_flag_value = i::FLAG_harmony_top_level_await;
i::FLAG_harmony_top_level_await = true;
Isolate* isolate = CcTest::isolate();
HandleScope scope(isolate);
LocalContext env;
{
Local<String> source_text = v8_str("await notExecuted();");
ScriptOrigin origin =
ModuleOrigin(v8_str("async_leaf.js"), CcTest::isolate());
ScriptCompiler::Source source(source_text, origin);
async_leaf_module =
ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
CHECK(async_leaf_module
->InstantiateModule(env.local(),
ResolveCallbackForIsGraphAsyncTopLevelAwait)
.FromJust());
CHECK(async_leaf_module->IsGraphAsync());
}
{
Local<String> source_text = v8_str("notExecuted();");
ScriptOrigin origin =
ModuleOrigin(v8_str("sync_leaf.js"), CcTest::isolate());
ScriptCompiler::Source source(source_text, origin);
sync_leaf_module =
ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
CHECK(sync_leaf_module
->InstantiateModule(env.local(),
ResolveCallbackForIsGraphAsyncTopLevelAwait)
.FromJust());
CHECK(!sync_leaf_module->IsGraphAsync());
}
{
Local<String> source_text = v8_str("import './async_leaf.js'");
ScriptOrigin origin =
ModuleOrigin(v8_str("import_async.js"), CcTest::isolate());
ScriptCompiler::Source source(source_text, origin);
Local<Module> module =
ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
CHECK(module
->InstantiateModule(env.local(),
ResolveCallbackForIsGraphAsyncTopLevelAwait)
.FromJust());
CHECK(module->IsGraphAsync());
}
{
Local<String> source_text = v8_str("import './sync_leaf.js'");
ScriptOrigin origin =
ModuleOrigin(v8_str("import_sync.js"), CcTest::isolate());
ScriptCompiler::Source source(source_text, origin);
Local<Module> module =
ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
CHECK(module
->InstantiateModule(env.local(),
ResolveCallbackForIsGraphAsyncTopLevelAwait)
.FromJust());
CHECK(!module->IsGraphAsync());
}
{
Local<String> source_text = v8_str(
"import './cycle_self.js'\n"
"import './async_leaf.js'");
ScriptOrigin origin =
ModuleOrigin(v8_str("cycle_self.js"), CcTest::isolate());
ScriptCompiler::Source source(source_text, origin);
cycle_self_module =
ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
CHECK(cycle_self_module
->InstantiateModule(env.local(),
ResolveCallbackForIsGraphAsyncTopLevelAwait)
.FromJust());
CHECK(cycle_self_module->IsGraphAsync());
}
{
Local<String> source_text1 = v8_str("import './cycle_two.js'");
ScriptOrigin origin1 =
ModuleOrigin(v8_str("cycle_one.js"), CcTest::isolate());
ScriptCompiler::Source source1(source_text1, origin1);
cycle_one_module =
ScriptCompiler::CompileModule(isolate, &source1).ToLocalChecked();
Local<String> source_text2 = v8_str(
"import './cycle_one.js'\n"
"import './async_leaf.js'");
ScriptOrigin origin2 =
ModuleOrigin(v8_str("cycle_two.js"), CcTest::isolate());
ScriptCompiler::Source source2(source_text2, origin2);
cycle_two_module =
ScriptCompiler::CompileModule(isolate, &source2).ToLocalChecked();
CHECK(cycle_one_module
->InstantiateModule(env.local(),
ResolveCallbackForIsGraphAsyncTopLevelAwait)
.FromJust());
CHECK(cycle_one_module->IsGraphAsync());
CHECK(cycle_two_module->IsGraphAsync());
}
i::FLAG_harmony_top_level_await = previous_top_level_await_flag_value;
}
[modules] Do path resolution relative to each module file in d8 BUG=v8:1569 Review-Url: https://codereview.chromium.org/2361593002 Cr-Commit-Position: refs/heads/master@{#39646}
2016-09-22 21:03:19 +00:00
} // anonymous namespace
Reference in New Issue Copy Permalink