Use canonical names for some name-based lookup.

runtime/vm/kernel_to_il.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 <map>
 #include <set>
 #include <string>
 
 #include "vm/kernel_to_il.h"
 
@@ skipping 1050 matching lines @@
 }
 
 
 dart::String& TranslationHelper::DartSymbol(String* content) const {
   return dart::String::ZoneHandle(
       Z, dart::Symbols::FromUTF8(thread_, content->buffer(), content->size()));
 }
 
 
 const dart::String& TranslationHelper::DartClassName(
-    kernel::Class* kernel_klass) {
-  ASSERT(kernel_klass->IsNormalClass());
+    CanonicalName* kernel_klass) {
   dart::String& name = DartString(kernel_klass->name());
   return ManglePrivateName(kernel_klass->parent(), &name);
 }
 
 
 const dart::String& TranslationHelper::DartConstructorName(Constructor* node) {
   Class* klass = Class::Cast(node->parent());
   return DartFactoryName(klass, node->name());
 }
 
@@ skipping 22 matching lines @@
   //    conventions.
   String* content = kernel_name->string();
   ASSERT(content->size() > 0);
   intptr_t skip = 0;
   if (content->buffer()[content->size() - 1] == '=') {
     skip = 1;
   }
   dart::String& name = dart::String::ZoneHandle(
       Z, dart::String::FromUTF8(content->buffer(), content->size() - skip,
                                 allocation_space_));
-  ManglePrivateName(kernel_name->library(), &name, false);
+  ManglePrivateName(kernel_name->library_reference(), &name, false);
   name = dart::Field::SetterSymbol(name);
   return name;
 }
 
 
 const dart::String& TranslationHelper::DartGetterName(Name* kernel_name) {
   dart::String& name = DartString(kernel_name->string());
-  ManglePrivateName(kernel_name->library(), &name, false);
+  ManglePrivateName(kernel_name->library_reference(), &name, false);
   name = dart::Field::GetterSymbol(name);
   return name;
 }
 
 
 const dart::String& TranslationHelper::DartFieldName(Name* kernel_name) {
   dart::String& name = DartString(kernel_name->string());
-  return ManglePrivateName(kernel_name->library(), &name);
+  return ManglePrivateName(kernel_name->library_reference(), &name);
 }
 
 
 const dart::String& TranslationHelper::DartInitializerName(Name* kernel_name) {
   // The [DartFieldName] will take care of mangling the name.
   dart::String& name =
       dart::String::Handle(Z, DartFieldName(kernel_name).raw());
   name = Symbols::FromConcat(thread_, Symbols::InitPrefix(), name);
   return name;
 }
 
 
 const dart::String& TranslationHelper::DartMethodName(Name* kernel_name) {
   dart::String& name = DartString(kernel_name->string());
-  return ManglePrivateName(kernel_name->library(), &name);
+  return ManglePrivateName(kernel_name->library_reference(), &name);
 }
 
 
 const dart::String& TranslationHelper::DartFactoryName(Class* klass,
                                                        Name* method_name) {
   // [DartMethodName] will mangle the name.
   GrowableHandlePtrArray<const dart::String> pieces(Z, 3);
-  pieces.Add(DartClassName(klass));
+  pieces.Add(DartClassName(klass->canonical_name()));
   pieces.Add(Symbols::Dot());
   pieces.Add(DartMethodName(method_name));
   return dart::String::ZoneHandle(
       Z, dart::Symbols::FromConcatAll(thread_, pieces));
 }
 
 
 dart::RawLibrary* TranslationHelper::LookupLibraryByKernelLibrary(
-    Library* kernel_library) {
-  const dart::String& library_name = DartSymbol(kernel_library->import_uri());
+    CanonicalName* kernel_library) {
+  const dart::String& library_name = DartSymbol(kernel_library->name());
   ASSERT(!library_name.IsNull());
   dart::RawLibrary* library =
       dart::Library::LookupLibrary(thread_, library_name);
   ASSERT(library != Object::null());
   return library;
 }
 
 
 dart::RawClass* TranslationHelper::LookupClassByKernelClass(
-    Class* kernel_klass) {
+    CanonicalName* kernel_klass) {
   dart::RawClass* klass = NULL;
 
   const dart::String& class_name = DartClassName(kernel_klass);
-  Library* kernel_library = Library::Cast(kernel_klass->parent());
+  CanonicalName* kernel_library = kernel_klass->parent();
   dart::Library& library =
       dart::Library::Handle(Z, LookupLibraryByKernelLibrary(kernel_library));
   klass = library.LookupClassAllowPrivate(class_name);
 
   ASSERT(klass != Object::null());
   return klass;
 }
 
 
 dart::RawField* TranslationHelper::LookupFieldByKernelField(
     Field* kernel_field) {
   TreeNode* node = kernel_field->parent();
 
   dart::Class& klass = dart::Class::Handle(Z);
   if (node->IsClass()) {
-    klass = LookupClassByKernelClass(Class::Cast(node));
+    klass = LookupClassByKernelClass(Class::Cast(node)->canonical_name());
   } else {
     ASSERT(node->IsLibrary());
     dart::Library& library = dart::Library::Handle(
-        Z, LookupLibraryByKernelLibrary(Library::Cast(node)));
+        Z, LookupLibraryByKernelLibrary(Library::Cast(node)->canonical_name()));
     klass = library.toplevel_class();
   }
   dart::RawField* field =
       klass.LookupFieldAllowPrivate(DartSymbol(kernel_field->name()->string()));
   ASSERT(field != Object::null());
   return field;
 }
 
 
 dart::RawFunction* TranslationHelper::LookupStaticMethodByKernelProcedure(
     Procedure* procedure) {
   ASSERT(procedure->IsStatic());
   const dart::String& procedure_name = DartProcedureName(procedure);
 
   // The parent is either a library or a class (in which case the procedure is a
   // static method).
   TreeNode* parent = procedure->parent();
   if (parent->IsClass()) {
-    dart::Class& klass =
-        dart::Class::Handle(Z, LookupClassByKernelClass(Class::Cast(parent)));
+    dart::Class& klass = dart::Class::Handle(
+        Z, LookupClassByKernelClass(Class::Cast(parent)->canonical_name()));
     dart::RawFunction* raw_function =
         klass.LookupFunctionAllowPrivate(procedure_name);
     ASSERT(raw_function != Object::null());
 
     // TODO(27590): We can probably get rid of this after no longer using
     // core libraries from the source.
     dart::Function& function = dart::Function::ZoneHandle(Z, raw_function);
     if (function.IsRedirectingFactory()) {
       ClassFinalizer::ResolveRedirectingFactory(klass, function);
       function = function.RedirectionTarget();
     }
     return function.raw();
   } else {
     ASSERT(parent->IsLibrary());
     dart::Library& library = dart::Library::Handle(
-        Z, LookupLibraryByKernelLibrary(Library::Cast(parent)));
+        Z,
+        LookupLibraryByKernelLibrary(Library::Cast(parent)->canonical_name()));
     dart::RawFunction* function =
         library.LookupFunctionAllowPrivate(procedure_name);
     ASSERT(function != Object::null());
     return function;
   }
 }
 
 
 dart::RawFunction* TranslationHelper::LookupConstructorByKernelConstructor(
     Constructor* constructor) {
   Class* kernel_klass = Class::Cast(constructor->parent());
-  dart::Class& klass =
-      dart::Class::Handle(Z, LookupClassByKernelClass(kernel_klass));
+  dart::Class& klass = dart::Class::Handle(
+      Z, LookupClassByKernelClass(kernel_klass->canonical_name()));
   return LookupConstructorByKernelConstructor(klass, constructor);
 }
 
 
 dart::RawFunction* TranslationHelper::LookupConstructorByKernelConstructor(
     const dart::Class& owner,
     Constructor* constructor) {
   dart::RawFunction* function =
       owner.LookupConstructorAllowPrivate(DartConstructorName(constructor));
   ASSERT(function != Object::null());
@@ skipping 39 matching lines @@
 
   va_list args;
   va_start(args, format);
   Report::LongJumpV(prev_error, null_script, TokenPosition::kNoSource, format,
                     args);
   va_end(args);
   UNREACHABLE();
 }
 
 
-dart::String& TranslationHelper::ManglePrivateName(Library* kernel_library,
-                                                   dart::String* name_to_modify,
-                                                   bool symbolize) {
+dart::String& TranslationHelper::ManglePrivateName(
+    CanonicalName* kernel_library,
+    dart::String* name_to_modify,
+    bool symbolize) {
   if (name_to_modify->Length() >= 1 && name_to_modify->CharAt(0) == '_') {
     const dart::Library& library =
         dart::Library::Handle(Z, LookupLibraryByKernelLibrary(kernel_library));
     *name_to_modify = library.PrivateName(*name_to_modify);
   } else if (symbolize) {
     *name_to_modify = Symbols::New(thread_, *name_to_modify);
   }
   return *name_to_modify;
 }
 
@@ skipping 1510 matching lines @@
   // though the function will result in an exception).
 
   return instructions;
 }
 
 
 dart::RawFunction* FlowGraphBuilder::LookupMethodByMember(
     Member* target,
     const dart::String& method_name) {
   Class* kernel_klass = Class::Cast(target->parent());
-  dart::Class& klass =
-      dart::Class::Handle(Z, H.LookupClassByKernelClass(kernel_klass));
+  dart::Class& klass = dart::Class::Handle(
+      Z, H.LookupClassByKernelClass(kernel_klass->canonical_name()));
 
   dart::RawFunction* function = klass.LookupFunctionAllowPrivate(method_name);
   ASSERT(function != Object::null());
   return function;
 }
 
 
 LocalVariable* FlowGraphBuilder::MakeTemporary() {
   char name[64];
   intptr_t index = stack_->definition()->temp_index();
@@ skipping 1610 matching lines @@
 
 
 void DartTypeTranslator::VisitInterfaceType(InterfaceType* node) {
   // NOTE: That an interface type like `T<A, B>` is considered to be
   // malformed iff `T` is malformed.
   //   => We therefore ignore errors in `A` or `B`.
   const TypeArguments& type_arguments = TranslateTypeArguments(
       node->type_arguments().raw_array(), node->type_arguments().length());
 
 
-  dart::Object& klass =
-      dart::Object::Handle(Z, H.LookupClassByKernelClass(node->klass()));
+  dart::Object& klass = dart::Object::Handle(
+      Z, H.LookupClassByKernelClass(node->class_reference()));
   result_ = Type::New(klass, type_arguments, TokenPosition::kNoSource);
   if (finalize_) {
     ASSERT(active_class_->klass != NULL);
     result_ = ClassFinalizer::FinalizeType(*active_class_->klass, result_);
   }
 }
 
 
 void DartTypeTranslator::VisitDynamicType(DynamicType* node) {
   result_ = Object::dynamic_type().raw();
@@ skipping 417 matching lines @@
 
 void FlowGraphBuilder::VisitConstructorInvocation(ConstructorInvocation* node) {
   if (node->is_const()) {
     fragment_ =
         Constant(constant_evaluator_.EvaluateConstructorInvocation(node));
     return;
   }
 
   Class* kernel_class = Class::Cast(node->target()->parent());
 
-  dart::Class& klass =
-      dart::Class::ZoneHandle(Z, H.LookupClassByKernelClass(kernel_class));
+  dart::Class& klass = dart::Class::ZoneHandle(
+      Z, H.LookupClassByKernelClass(kernel_class->canonical_name()));
 
   Fragment instructions;
 
   // Check for malbounded-ness of type.
   if (I->type_checks()) {
     List<DartType>& kernel_type_arguments = node->arguments()->types();
     const TypeArguments& type_arguments = T.TranslateInstantiatedTypeArguments(
         klass, kernel_type_arguments.raw_array(),
         kernel_type_arguments.length());
 
@@ skipping 1517 matching lines @@
     thread->clear_sticky_error();
     return error.raw();
   }
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)