Use canonical names for some name-based lookup.

runtime/vm/kernel_to_il.h

 // 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.
 
 #ifndef RUNTIME_VM_KERNEL_TO_IL_H_
 #define RUNTIME_VM_KERNEL_TO_IL_H_
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 
 #include "vm/growable_array.h"
@@ skipping 235 matching lines @@
   const dart::String& DartString(const char* content, Heap::Space space);
 
   dart::String& DartString(String* content) {
     return DartString(content, allocation_space_);
   }
   dart::String& DartString(String* content, Heap::Space space);
 
   const dart::String& DartSymbol(const char* content) const;
   dart::String& DartSymbol(String* content) const;
 
-  const dart::String& DartClassName(Class* kernel_klass);
+  const dart::String& DartClassName(CanonicalName* kernel_klass);
   const dart::String& DartConstructorName(Constructor* node);
   const dart::String& DartProcedureName(Procedure* procedure);
 
   const dart::String& DartSetterName(Name* kernel_name);
   const dart::String& DartGetterName(Name* kernel_name);
   const dart::String& DartFieldName(Name* kernel_name);
   const dart::String& DartInitializerName(Name* kernel_name);
   const dart::String& DartMethodName(Name* kernel_name);
   const dart::String& DartFactoryName(Class* klass, Name* kernel_name);
 
   const Array& ArgumentNames(List<NamedExpression>* named);
 
   // A subclass overrides these when reading in the Kernel program in order to
   // support recursive type expressions (e.g. for "implements X" ...
   // annotations).
-  virtual RawLibrary* LookupLibraryByKernelLibrary(Library* library);
-  virtual RawClass* LookupClassByKernelClass(Class* klass);
+  virtual RawLibrary* LookupLibraryByKernelLibrary(CanonicalName* library);
+  virtual RawClass* LookupClassByKernelClass(CanonicalName* klass);
 
   RawField* LookupFieldByKernelField(Field* field);
   RawFunction* LookupStaticMethodByKernelProcedure(Procedure* procedure);
   RawFunction* LookupConstructorByKernelConstructor(Constructor* constructor);
   dart::RawFunction* LookupConstructorByKernelConstructor(
       const dart::Class& owner,
       Constructor* constructor);
 
   dart::Type& GetCanonicalType(const dart::Class& klass);
 
   void ReportError(const char* format, ...);
   void ReportError(const Error& prev_error, const char* format, ...);
 
  private:
   // This will mangle [kernel_name] (if necessary) and make the result a symbol.
   // The result will be avilable in [name_to_modify] and it is also returned.
-  dart::String& ManglePrivateName(Library* kernel_library,
+  dart::String& ManglePrivateName(CanonicalName* kernel_library,
                                   dart::String* name_to_modify,
                                   bool symbolize = true);
 
   dart::Thread* thread_;
   dart::Zone* zone_;
   dart::Isolate* isolate_;
   Heap::Space allocation_space_;
 };
 
 // Regarding malformed types:
@@ skipping 728 matching lines @@
 namespace kernel {
 
 RawObject* EvaluateMetadata(TreeNode* const kernel_node);
 RawObject* BuildParameterDescriptor(TreeNode* const kernel_node);
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 #endif  // RUNTIME_VM_KERNEL_TO_IL_H_