[ES6 modules] Return previous error when an instantiation is reattempt.

third_party/WebKit/Source/core/loader/modulescript/ModuleTreeLinker.cpp

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/loader/modulescript/ModuleTreeLinker.h"
 
 #include "bindings/core/v8/ScriptModule.h"
 #include "core/dom/AncestorList.h"
 #include "core/dom/ModuleScript.h"
 #include "core/loader/modulescript/ModuleScriptFetchRequest.h"
@@ skipping 94 matching lines @@
       NOTREACHED();
       break;
   }
 
   state_ = new_state;
 
   if (state_ == State::kFinished) {
     registry_->ReleaseFinishedFetcher(this);
 
     // https://html.spec.whatwg.org/multipage/webappapis.html#internal-module-script-graph-fetching-procedure
-    // Step 8. Asynchronously complete this algorithm with descendants result.
+    // Step 9. Asynchronously complete this algorithm with descendants result.
     client_->NotifyModuleTreeLoadFinished(descendants_module_script_);
   }
 }
 
 void ModuleTreeLinker::FetchSelf(const ModuleScriptFetchRequest& request,
                                  ModuleGraphLevel level) {
   // https://html.spec.whatwg.org/multipage/webappapis.html#internal-module-script-graph-fetching-procedure
 
   // Step 1. Fetch a single module script given url, fetch client settings
   // object, destination, cryptographic nonce, parser state, credentials mode,
@@ skipping 97 matching lines @@
                                                  module_script_->BaseURL());
 
     // Step 4.2. If the result is error: ...
     if (url.IsNull()) {
       // Let error be a new TypeError exception.
       // Report the exception error for module script.
       // TODO(kouhei): Implement the exception.
 
       // Abort this algorithm, and asynchronously complete it with null.
       // Note: The return variable for "internal module script graph fetching
-      // procedure" is descendants_module_script_ per Step 8.
+      // procedure" is descendants_module_script_ per Step 9.
       DCHECK(!descendants_module_script_);
       // Note: while we complete "fetch the descendants of a module script"
       //       algorithm here, we still need to continue to the rest of the
       //       steps in "internal module script graph fetching procedure"
       Instantiate();
       return;
     }
 
     // Step 4.3. Otherwise, if ancestor list does not contain url, append url to
     // urls.
@@ skipping 85 matching lines @@
     Instantiate();
   }
 }
 
 void ModuleTreeLinker::Instantiate() {
   CHECK(module_script_);
   AdvanceState(State::kInstantiating);
 
   // https://html.spec.whatwg.org/multipage/webappapis.html#internal-module-script-graph-fetching-procedure
 
-  // Step 5. Let record be result's module record.
-  ScriptModule record = module_script_->Record();
-
-  // Step 6. Let instantiationStatus be record.ModuleDeclarationInstantiation().
+  // Step 5. Let instantiationStatus be null.
   // Note: The |error| variable corresponds to spec variable
   // "instantiationStatus". If |error| is empty, it indicates successful
   // completion.
-  ScriptValue error = modulator_->InstantiateModule(record);
+  ScriptValue error;
 
-  // Step 7. For each module script script in result's uninstantiated inclusive
+  // Step 6. If result's instantiation state is "errored",...
+  if (module_script_->InstantiationState() ==
+      ModuleInstantiationState::kErrored) {
+    // ... Set instantiationStatus to record.ModuleDeclarationInstantiation().
+    error = modulator_->GetInstantiationError(module_script_);

[hiroshige, 2017/04/27 22:56:40]

DCHECK(!error.IsEmpty());

[kouhei (in TOK), 2017/04/28 00:55:09]

Done.

+  } else {
+    // Step 7. Otherwise:
+    // Step 7.1. Let record be result's module record.
+    ScriptModule record = module_script_->Record();
+    // Step 7.2. Set instantiationStatus to
+    // record.ModuleDeclarationInstantiation().
+    error = modulator_->InstantiateModule(record);
+  }
+
+  // Step 8. For each module script script in result's uninstantiated inclusive
   // descendant module scripts, perform the following steps:
   HeapHashSet<Member<ModuleScript>> uninstantiated_set =
       UninstantiatedInclusiveDescendants();
   for (const auto& descendant : uninstantiated_set) {
     if (!error.IsEmpty()) {
-      // Step 7.1. If instantiationStatus is an abrupt completion, then set
-      // script's instantiation state to "errored", its instantiation error to
-      // instantiationStatus.[[Value]], and its module record to null.
+      // Step 8.1. If instantiationStatus is an abrupt completion, then
+      // Step 8.1.1. Set script module record's [[HostDefined]] field to
+      // undefined.
+      // TODO(kouhei): Implement this.
+
+      // Step 8.1.2. Set script's module record to null.
+      // Step 8.1.3. Set script's instantiation state to "errored".
+      // Step 8.1.4. Set script's instantiation error to
+      // instantiationStatus.[[Value]].
       descendant->SetInstantiationErrorAndClearRecord(error);
     } else {
-      // Step 7.2. Otherwise, set script's instantiation state to
+      // Step 8.2. Otherwise, set script's instantiation state to
       // "instantiated".
       descendant->SetInstantiationSuccess();
     }
   }
 
-  // Step 8. Asynchronously complete this algorithm with descendants result.
+  // Step 9. Asynchronously complete this algorithm with descendants result.
   AdvanceState(State::kFinished);
 }
 
 HeapHashSet<Member<ModuleScript>>
 ModuleTreeLinker::UninstantiatedInclusiveDescendants() {
   // https://html.spec.whatwg.org/multipage/webappapis.html#uninstantiated-inclusive-descendant-module-scripts
   // Step 1. Let moduleMap be script's settings object's module map.
   // Note: Modulator is our "settings object".
   // Note: We won't reference the ModuleMap directly here to aid testing.
 
@@ skipping 78 matching lines @@
   HeapHashSet<Member<ModuleScript>> uninstantiated_set;
   for (const auto& script : inclusive_descendants) {
     if (script->InstantiationState() ==
         ModuleInstantiationState::kUninstantiated)
       uninstantiated_set.insert(script);
   }
   return uninstantiated_set;
 }
 
 }  // namespace blink