[vm] Cleanup some outdated code from hot-reload (and deferred loading)

Hot-reload used to be implemented by calling a tag handler (i.e. embedder),
which would load new Dart source code and call recursively into hot reloading
code.

=> This no longer happens, since the hot reload implementation obtains and
   loads the kernel diffs itself in isolate_reload.cc.

With the switch to the Dart 2.0 CFE the VM no longer supports any kind of
deferred library loading. The CFE provides the VM with all sources together.

This CL cleans up some unnecessary code and outdated comments.

Issue #36097

Change-Id: I63aaa6e2a1910165185172a9dd975c3974ac5dd5
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/110720
Reviewed-by: Alexander Aprelev <aam@google.com>
Commit-Queue: Martin Kustermann <kustermann@google.com>

Author: mkustermann

runtime/vm/dart_api_impl.cc

@@ -5473,8 +5473,6 @@ DART_EXPORT Dart_Handle Dart_FinalizeLoading(bool complete_futures) {
   // instead of freelists.
   BumpAllocateScope bump_allocate_scope(T);
 
-  I->DoneLoading();
-
   // TODO(hausner): move the remaining code below (finalization and
   // invoking of _completeDeferredLoads) into Isolate::DoneLoading().
 
@@ -5484,8 +5482,6 @@ DART_EXPORT Dart_Handle Dart_FinalizeLoading(bool complete_futures) {
     return state;
   }
 
-  I->DoneFinalizing();
-
 #if !defined(PRODUCT)
   // Now that the newly loaded classes are finalized, notify the debugger
   // that new code has been loaded. If there are latent breakpoints in

runtime/vm/isolate.cc

@@ -1404,21 +1404,6 @@ void Isolate::BuildName(const char* name_prefix) {
   }
 }
 
-void Isolate::DoneLoading() {
-  GrowableObjectArray& libs =
-      GrowableObjectArray::Handle(current_zone(), object_store()->libraries());
-  Library& lib = Library::Handle(current_zone());
-  intptr_t num_libs = libs.Length();
-  for (intptr_t i = 0; i < num_libs; i++) {
-    lib ^= libs.At(i);
-    // If this library was loaded with Dart_LoadLibrary, it was marked
-    // as 'load in progres'. Set the status to 'loaded'.
-    if (lib.LoadInProgress()) {
-      lib.SetLoaded();
-    }
-  }
-}
-
 #if !defined(PRODUCT) && !defined(DART_PRECOMPILED_RUNTIME)
 bool Isolate::CanReload() const {
   return !Isolate::IsVMInternalIsolate(this) && is_runnable() &&
@@ -1475,14 +1460,6 @@ void Isolate::DeleteReloadContext() {
 }
 #endif  // !defined(PRODUCT) && !defined(DART_PRECOMPILED_RUNTIME)
 
-void Isolate::DoneFinalizing() {
-#if !defined(PRODUCT) && !defined(DART_PRECOMPILED_RUNTIME)
-  if (IsReloading()) {
-    reload_context_->FinalizeLoading();
-  }
-#endif  // !defined(PRODUCT) && !defined(DART_PRECOMPILED_RUNTIME)
-}
-
 const char* Isolate::MakeRunnable() {
   ASSERT(Isolate::Current() == nullptr);
 

runtime/vm/isolate.h

@@ -422,10 +422,6 @@ class Isolate : public BaseIsolate, public IntrusiveDListEntry<Isolate> {
 
   void ScheduleInterrupts(uword interrupt_bits);
 
-  // Marks all libraries as loaded.
-  void DoneLoading();
-  void DoneFinalizing();
-
 #if !defined(PRODUCT) && !defined(DART_PRECOMPILED_RUNTIME)
   // By default the reload context is deleted. This parameter allows
   // the caller to delete is separately if it is still needed.

runtime/vm/isolate_reload.cc

@@ -736,26 +736,11 @@ void IsolateReloadContext::Reload(bool force_reload,
   DeoptimizeDependentCode();
   Checkpoint();
 
-  // WEIRD CONTROL FLOW BEGINS.
+  // We synchronously load the hot-reload kernel diff (which includes changed
+  // libraries and any libraries transitively depending on them).
   //
-  // The flow of execution until we return from the tag handler can be complex.
-  //
-  // On a successful load, the following will occur:
-  //   1) Tag Handler is invoked and the embedder is in control.
-  //   2) All sources and libraries are loaded.
-  //   3) Dart_FinalizeLoading is called by the embedder.
-  //   4) Dart_FinalizeLoading invokes IsolateReloadContext::FinalizeLoading
-  //      and we are temporarily back in control.
-  //      This is where we validate the reload and commit or reject.
-  //   5) Dart_FinalizeLoading invokes Dart code related to deferred libraries.
-  //   6) The tag handler returns and we move on.
-  //
-  // Even after a successful reload the Dart code invoked in (5) can result
-  // in an Unwind error or an UnhandledException error. This error will be
-  // returned by the tag handler. The tag handler can return other errors,
-  // for example, top level parse errors. We want to capture these errors while
-  // propagating the UnwindError or an UnhandledException error.
-
+  // If loading the hot-reload diff succeeded we'll finalize the loading, which
+  // will either commit or reject the reload request.
   {
     const Object& tmp =
         kernel::KernelLoader::LoadEntireProgram(kernel_program.get());
@@ -782,8 +767,6 @@ void IsolateReloadContext::Reload(bool force_reload,
       result = tmp.raw();
     }
   }
-  //
-  // WEIRD CONTROL FLOW ENDS.
 
   // Re-enable the background compiler. Do this before propagating any errors.
   BackgroundCompiler::Enable(I);
@@ -840,8 +823,6 @@ void IsolateReloadContext::RegisterClass(const Class& new_cls) {
   AddClassMapping(new_cls, old_cls);
 }
 
-// FinalizeLoading will be called *before* Reload() returns but will not be
-// called if the embedder fails to load sources.
 void IsolateReloadContext::FinalizeLoading() {
   if (reload_skipped_ || reload_finalized_) {
     return;
@@ -1475,9 +1456,9 @@ void IsolateReloadContext::Commit() {
         if (new_cls.raw() != old_cls.raw()) {
           ASSERT(new_cls.is_enum_class() == old_cls.is_enum_class());
           if (new_cls.is_enum_class() && new_cls.is_finalized()) {
-            new_cls.ReplaceEnum(old_cls);
+            new_cls.ReplaceEnum(this, old_cls);
           } else {
-            new_cls.CopyStaticFieldValues(old_cls);
+            new_cls.CopyStaticFieldValues(this, old_cls);
           }
           old_cls.PatchFieldsAndFunctions();
           old_cls.MigrateImplicitStaticClosures(this, new_cls);

runtime/vm/object.h

@@ -1364,8 +1364,10 @@ class Class : public Object {
   bool TraceAllocation(Isolate* isolate) const;
   void SetTraceAllocation(bool trace_allocation) const;
 
-  void ReplaceEnum(const Class& old_enum) const;
-  void CopyStaticFieldValues(const Class& old_cls) const;
+  void ReplaceEnum(IsolateReloadContext* reload_context,
+                   const Class& old_enum) const;
+  void CopyStaticFieldValues(IsolateReloadContext* reload_context,
+                             const Class& old_cls) const;
   void PatchFieldsAndFunctions() const;
   void MigrateImplicitStaticClosures(IsolateReloadContext* context,
                                      const Class& new_cls) const;

runtime/vm/object_reload.cc

@@ -183,13 +183,11 @@ void ObjectPool::ResetICDatas(Zone* zone) const {
 #endif
 }
 
-void Class::CopyStaticFieldValues(const Class& old_cls) const {
+void Class::CopyStaticFieldValues(IsolateReloadContext* reload_context,
+                                  const Class& old_cls) const {
   // We only update values for non-enum classes.
   const bool update_values = !is_enum_class();
 
-  IsolateReloadContext* reload_context = Isolate::Current()->reload_context();
-  ASSERT(reload_context != NULL);
-
   const Array& old_field_list = Array::Handle(old_cls.fields());
   Field& old_field = Field::Handle();
   String& old_name = String::Handle();
@@ -285,17 +283,15 @@ class EnumMapTraits {
 //   When an enum value is deleted, we 'become' all references to the 'deleted'
 //   sentinel value. The index value is -1.
 //
-void Class::ReplaceEnum(const Class& old_enum) const {
+void Class::ReplaceEnum(IsolateReloadContext* reload_context,
+                        const Class& old_enum) const {
   // We only do this for finalized enum classes.
   ASSERT(is_enum_class());
   ASSERT(old_enum.is_enum_class());
   ASSERT(is_finalized());
   ASSERT(old_enum.is_finalized());
 
-  Thread* thread = Thread::Current();
-  Zone* zone = thread->zone();
-  IsolateReloadContext* reload_context = Isolate::Current()->reload_context();
-  ASSERT(reload_context != NULL);
+  Zone* zone = Thread::Current()->zone();
 
   Array& enum_fields = Array::Handle(zone);
   Field& field = Field::Handle(zone);

runtime/vm/symbols.h

@@ -193,7 +193,6 @@ class ObjectPointerVisitor;
   V(List, "List")                                                              \
   V(ListFactory, "List.")                                                      \
   V(ListLiteralFactory, "List._fromLiteral")                                   \
-  V(LoadLibrary, "loadLibrary")                                                \
   V(LocalVarDescriptors, "LocalVarDescriptors")                                \
   V(Map, "Map")                                                                \
   V(MapLiteralFactory, "Map._fromLiteral")                                     \