Use canonical names for some name-based lookup.

runtime/vm/kernel_reader.cc

 // Copyright (c) 2016, 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/kernel_reader.h"
 
 #include <string.h>
 
 #include "vm/dart_api_impl.h"
 #include "vm/longjump.h"
@@ skipping 66 matching lines @@
 
  private:
   TranslationHelper translation_helper_;
   dart::Zone* zone_;
   bool is_simple_;
   dart::Instance* simple_value_;
 };
 
 
 RawLibrary* BuildingTranslationHelper::LookupLibraryByKernelLibrary(
-    Library* library) {
+    CanonicalName* library) {
   return reader_->LookupLibrary(library).raw();
 }
 
 
-RawClass* BuildingTranslationHelper::LookupClassByKernelClass(Class* klass) {
+RawClass* BuildingTranslationHelper::LookupClassByKernelClass(
+    CanonicalName* klass) {
   return reader_->LookupClass(klass).raw();
 }
 
 KernelReader::KernelReader(Program* program)
     : program_(program),
       thread_(dart::Thread::Current()),
       zone_(thread_->zone()),
       isolate_(thread_->isolate()),
       scripts_(Array::ZoneHandle(zone_)),
       translation_helper_(this, thread_),
       type_translator_(&translation_helper_,
                        &active_class_,
                        /*finalize=*/false) {
   intptr_t source_file_count = program_->source_table().size();
   scripts_ = Array::New(source_file_count, Heap::kOld);
 }
 
 Object& KernelReader::ReadProgram() {
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
-    Procedure* main = program_->main_method();
-    Library* kernel_main_library = Library::Cast(main->parent());
-
     intptr_t length = program_->libraries().length();
     for (intptr_t i = 0; i < length; i++) {
       Library* kernel_library = program_->libraries()[i];
       ReadLibrary(kernel_library);
     }
 
     for (intptr_t i = 0; i < length; i++) {
-      dart::Library& library = LookupLibrary(program_->libraries()[i]);
+      dart::Library& library =
+          LookupLibrary(program_->libraries()[i]->canonical_name());
       if (!library.Loaded()) library.SetLoaded();
     }
 
     if (ClassFinalizer::ProcessPendingClasses(/*from_kernel=*/true)) {
-      dart::Library& library = LookupLibrary(kernel_main_library);
+      Procedure* main = program_->main_method();
+      Library* kernel_main_library = Library::Cast(main->parent());
+      dart::Library& library =
+          LookupLibrary(kernel_main_library->canonical_name());
 
       // Sanity check that we can find the main entrypoint.
       Object& main_obj = Object::Handle(
           Z, library.LookupObjectAllowPrivate(H.DartSymbol("main")));
       ASSERT(!main_obj.IsNull());
       return library;
     }
   }
 
   // Either class finalization failed or we caught a compile error.
   // In both cases sticky error would be set.
   Error& error = Error::Handle(Z);
   error = thread_->sticky_error();
   thread_->clear_sticky_error();
   return error;
 }
 
 
 void KernelReader::ReadLibrary(Library* kernel_library) {
-  dart::Library& library = LookupLibrary(kernel_library);
+  dart::Library& library = LookupLibrary(kernel_library->canonical_name());
   if (library.Loaded()) return;
 
   // The bootstrapper will take care of creating the native wrapper classes, but
   // we will add the synthetic constructors to them here.
   if (library.name() ==
       Symbols::Symbol(Symbols::kDartNativeWrappersLibNameId).raw()) {
     ASSERT(library.LoadInProgress());
   } else {
     library.SetLoadInProgress();
   }
@@ skipping 117 matching lines @@
     interfaces.SetAt(i, type);
   }
   klass->set_interfaces(interfaces);
   if (kernel_klass->is_abstract()) klass->set_is_abstract();
 }
 
 
 dart::Class& KernelReader::ReadClass(const dart::Library& library,
                                      const dart::Class& toplevel_class,
                                      Class* kernel_klass) {
-  // This will trigger a call to [ReadPreliminaryClass] if not already done.
-  dart::Class& klass = LookupClass(kernel_klass);
+  dart::Class& klass = LookupClass(kernel_klass->canonical_name());
+
+  // The class needs to have a script because all the functions in the class
+  // will inherit it.  The predicate Function::IsOptimizable uses the absence of
+  // a script to detect test functions that should not be optimized.
+  if (klass.script() == Script::null()) {
+    klass.set_script(ScriptAt(kernel_klass->source_uri_index()));
+  }
+  if (klass.token_pos() == TokenPosition::kNoSource) {
+    klass.set_token_pos(kernel_klass->position());
+  }
+  if (!klass.is_cycle_free()) {
+    ReadPreliminaryClass(&klass, kernel_klass);
+  }
 
   ActiveClassScope active_class_scope(&active_class_, kernel_klass, &klass);
 
   if (library.raw() == dart::Library::InternalLibrary() &&
       klass.Name() == Symbols::ClassID().raw()) {
     // If this is a dart:internal.ClassID class ignore field declarations
     // contained in the Kernel file and instead inject our own const
     // fields.
     klass.InjectCIDFields();
   } else {
@@ skipping 432 matching lines @@
     function.SetParameterNameAt(pos, Symbols::This());
     pos++;
   }
   if (is_setter) {
     function.SetParameterTypeAt(pos, AbstractType::dynamic_type());
     function.SetParameterNameAt(pos, Symbols::Value());
     pos++;
   }
 }
 
-dart::Library& KernelReader::LookupLibrary(Library* library) {
+dart::Library& KernelReader::LookupLibrary(CanonicalName* library) {
   dart::Library* handle = NULL;
   if (!libraries_.Lookup(library, &handle)) {
-    const dart::String& url = H.DartSymbol(library->import_uri());
+    const dart::String& url = H.DartSymbol(library->name());
     handle =
         &dart::Library::Handle(Z, dart::Library::LookupLibrary(thread_, url));
     if (handle->IsNull()) {
       *handle = dart::Library::New(url);
       handle->Register(thread_);
       handle->SetName(H.DartSymbol(library->name()));
     }
     ASSERT(!handle->IsNull());
     libraries_.Insert(library, handle);
   }
   return *handle;
 }
 
-dart::Class& KernelReader::LookupClass(Class* klass) {
+dart::Class& KernelReader::LookupClass(CanonicalName* klass) {
   dart::Class* handle = NULL;
   if (!classes_.Lookup(klass, &handle)) {
     dart::Library& library = LookupLibrary(klass->parent());
     const dart::String& name = H.DartClassName(klass);
     handle = &dart::Class::Handle(Z, library.LookupClass(name));
     if (handle->IsNull()) {
-      // The class needs to have a script because all the functions in the class
-      // will inherit it.  The predicate Function::IsOptimizable uses the
-      // absence of a script to detect test functions that should not be
-      // optimized.
-      Script& script = ScriptAt(klass->source_uri_index());
-      handle = &dart::Class::Handle(
-          Z, dart::Class::New(library, name, script, klass->position()));
+      *handle = dart::Class::New(library, name, Script::Handle(Z),
+                                 TokenPosition::kNoSource);
       library.AddClass(*handle);
-    } else if (handle->script() == Script::null()) {
-      // When bootstrapping we can encounter classes that do not yet have a
-      // dummy script.
-      Script& script = ScriptAt(klass->source_uri_index());
-      handle->set_script(script);
     }
     // Insert the class in the cache before calling ReadPreliminaryClass so
     // we do not risk allocating the class again by calling LookupClass
     // recursively from ReadPreliminaryClass for the same class.
     classes_.Insert(klass, handle);
-    if (!handle->is_cycle_free()) {
-      ReadPreliminaryClass(handle, klass);
-    }
   }
   return *handle;
 }
 
 
 RawFunction::Kind KernelReader::GetFunctionType(Procedure* kernel_procedure) {
   intptr_t lookuptable[] = {
       RawFunction::kRegularFunction,  // Procedure::kMethod
       RawFunction::kGetterFunction,   // Procedure::kGetter
       RawFunction::kSetterFunction,   // Procedure::kSetter
@@ skipping 35 matching lines @@
   initializer_fun.set_is_debuggable(false);
   initializer_fun.set_is_reflectable(false);
   initializer_fun.set_is_inlinable(false);
   return new (zone) ParsedFunction(thread, initializer_fun);
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)