Use canonical names for some name-based lookup.

runtime/vm/kernel.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_H_
 #define RUNTIME_VM_KERNEL_H_
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 #include "platform/assert.h"
 #include "vm/allocation.h"
@@ skipping 2516 matching lines @@
 
   DEFINE_CASTING_OPERATIONS(Name);
 
   virtual void AcceptVisitor(Visitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   String* string() { return string_; }
   Library* library() {
     if (library_reference_ == NULL) return NULL;
     return library_reference_->AsLibrary();
   }

[kustermann, 2017/03/23 10:43:18]

As a safeguard, I think we should get rid of these old getters! (to prevent any
old or new code accidentally using it)

[Kevin Millikin (Google), 2017/03/23 11:15:52]

I agree.

I plan to get rid of the definition from the CanonicalName class and at that
point they will not work.  If we have code that really needs them we will do
something like a map on the side.

+  CanonicalName* library_reference() { return library_reference_; }
 
  private:
   Name(String* string, CanonicalName* library_reference)
       : string_(string), library_reference_(library_reference) {}  // NOLINT
 
   Ref<String> string_;
   Ref<CanonicalName> library_reference_;
 
   DISALLOW_COPY_AND_ASSIGN(Name);
 };
@@ skipping 123 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(VoidType);
 };
 
 
 class InterfaceType : public DartType {
  public:
   static InterfaceType* ReadFrom(Reader* reader);
   static InterfaceType* ReadFrom(Reader* reader, bool _without_type_arguments_);
 
-  explicit InterfaceType(CanonicalName* klass_reference)
-      : klass_reference_(klass_reference) {}
+  explicit InterfaceType(CanonicalName* class_reference)
+      : class_reference_(class_reference) {}
   virtual ~InterfaceType();
 
   DEFINE_CASTING_OPERATIONS(InterfaceType);
 
   virtual void AcceptDartTypeVisitor(DartTypeVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
-  Class* klass() { return klass_reference_->AsClass(); }
+  Class* klass() { return class_reference_->AsClass(); }
+  CanonicalName* class_reference() { return class_reference_; }
   List<DartType>& type_arguments() { return type_arguments_; }
 
  private:
   InterfaceType() {}
 
-  Ref<CanonicalName> klass_reference_;
+  Ref<CanonicalName> class_reference_;
   List<DartType> type_arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(InterfaceType);
 };
 
 
 class FunctionType : public DartType {
  public:
   static FunctionType* ReadFrom(Reader* reader);
   static FunctionType* ReadFrom(Reader* reader, bool _without_type_arguments_);
@@ skipping 536 matching lines @@
 
 kernel::Program* ReadPrecompiledKernelFromBuffer(const uint8_t* buffer,
                                                  intptr_t buffer_length);
 
 
 
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 #endif  // RUNTIME_VM_KERNEL_H_