Handle load errors in deferred code

runtime/vm/object.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 8527 matching lines @@
 }
 
 
 void Library::SetLoaded() const {
   // Should not be already loaded or just allocated.
   ASSERT(LoadInProgress() || LoadRequested());
   raw_ptr()->load_state_ = RawLibrary::kLoaded;
 }
 
 
-void Library::SetLoadError() const {
+void Library::SetLoadError(const Object& error) const {
   // Should not be already successfully loaded or just allocated.
-  ASSERT(LoadInProgress() || LoadRequested() || LoadError());
+  ASSERT(LoadInProgress() || LoadRequested() || LoadFailed());
   raw_ptr()->load_state_ = RawLibrary::kLoadError;
+  StorePointer(&raw_ptr()->load_error_, error.raw());
+}
+
+
+RawObject* Library::TransitiveLoadError() const {
+  if (LoadError() != Error::null()) {
+    return LoadError();
+  }
+  intptr_t num_imp = num_imports();
+  Library& lib = Library::Handle();
+  Object& error = Object::Handle();
+  for (intptr_t i = 0; i < num_imp; i++) {
+    lib = ImportLibraryAt(i);
+    // Break potential import cycles while recursing through imports.
+    set_num_imports(0);
+    error = lib.TransitiveLoadError();
+    set_num_imports(num_imp);
+    if (!error.IsNull()) {
+      break;
+    }
+  }
+  return error.raw();
 }
 
 
 static RawString* MakeClassMetaName(const Class& cls) {
   String& cname = String::Handle(cls.Name());
   return String::Concat(Symbols::At(), cname);
 }
 
 
 static RawString* MakeFieldMetaName(const Field& field) {
@@ skipping 782 matching lines @@
   result.StorePointer(&result.raw_ptr()->url_, url.raw());
   result.raw_ptr()->resolved_names_ = Object::empty_array().raw();
   result.raw_ptr()->dictionary_ = Object::empty_array().raw();
   result.StorePointer(&result.raw_ptr()->metadata_,
                       GrowableObjectArray::New(4, Heap::kOld));
   result.raw_ptr()->anonymous_classes_ = Object::empty_array().raw();
   result.raw_ptr()->num_anonymous_ = 0;
   result.raw_ptr()->imports_ = Object::empty_array().raw();
   result.raw_ptr()->exports_ = Object::empty_array().raw();
   result.raw_ptr()->loaded_scripts_ = Array::null();
+  result.raw_ptr()->load_error_ = Object::null();
   result.set_native_entry_resolver(NULL);
   result.set_native_entry_symbol_resolver(NULL);
   result.raw_ptr()->corelib_imported_ = true;
   result.set_debuggable(false);
   result.set_is_dart_scheme(url.StartsWith(Symbols::DartScheme()));
   result.raw_ptr()->load_state_ = RawLibrary::kAllocated;
   result.raw_ptr()->index_ = -1;
   const intptr_t kInitialNameCacheSize = 64;
   result.InitResolvedNamesCache(kInitialNameCacheSize);
   result.InitClassDictionary();
@@ skipping 356 matching lines @@
   if ((index >= 0) || (index < num_imports())) {
     const Array& imports = Array::Handle(this->imports());
     Namespace& import = Namespace::Handle();
     import ^= imports.At(index);
     return import.library();
   }
   return Library::null();
 }
 
 
+RawObject* LibraryPrefix::LoadError() const {
+  Library& lib = Library::Handle();
+  Object& error = Object::Handle();
+  for (int32_t i = 0; i < num_imports(); i++) {
+    lib = GetLibrary(i);
+    ASSERT(!lib.IsNull());
+    error = lib.TransitiveLoadError();
+    if (!error.IsNull()) {
+      return error.raw();
+    }
+  }
+  return Object::null();
+}
+
+
 bool LibraryPrefix::ContainsLibrary(const Library& library) const {
-  intptr_t num_current_imports = num_imports();
+  int32_t num_current_imports = num_imports();
   if (num_current_imports > 0) {
     Library& lib = Library::Handle();
     const String& url = String::Handle(library.url());
     String& lib_url = String::Handle();
-    for (intptr_t i = 0; i < num_current_imports; i++) {
+    for (int32_t i = 0; i < num_current_imports; i++) {
       lib = GetLibrary(i);
       ASSERT(!lib.IsNull());
       lib_url = lib.url();
       if (url.Equals(lib_url)) {
         return true;
       }
     }
   }
   return false;
 }
@@ skipping 90 matching lines @@
   // - mark this prefixes as loaded;
   // - complete the future associated with this prefix.
   const Library& deferred_lib = Library::Handle(GetLibrary(0));
   if (deferred_lib.Loaded()) {
     this->set_is_loaded();
     return true;
   } else if (deferred_lib.LoadNotStarted()) {
     Isolate* isolate = Isolate::Current();
     Api::Scope api_scope(isolate);
     deferred_lib.SetLoadRequested();
+    const GrowableObjectArray& pending_deferred_loads =
+        GrowableObjectArray::Handle(
+            isolate->object_store()->pending_deferred_loads());
+    pending_deferred_loads.Add(deferred_lib);

[Ivan Posva, 2014/07/31 18:29:04]

Please make sure this is reset when the loads are finished.

[hausner, 2014/07/31 21:12:45]

Added to Dart_FinalizeLoading()

     const String& lib_url = String::Handle(isolate, deferred_lib.url());
     Dart_LibraryTagHandler handler = isolate->library_tag_handler();
     handler(Dart_kImportTag,
             Api::NewHandle(isolate, importer()),
             Api::NewHandle(isolate, lib_url.raw()));
   } else {
     // Another load request is in flight.
     ASSERT(deferred_lib.LoadRequested());
   }
   return false;  // Load request not yet completed.
@@ skipping 9495 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart