Move the Kernel canonical name table into the VM's heap

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 <set>
 
 #include "vm/kernel_to_il.h"
 
 #include "vm/compiler.h"
 #include "vm/intermediate_language.h"
@@ skipping 54 matching lines @@
       zone_(translation_helper_.zone()),
       type_translator_(&translation_helper_, &active_class_, /*finalize=*/true),
       current_function_scope_(NULL),
       scope_(NULL),
       depth_(0),
       name_index_(0),
       needs_expr_temp_(false) {
   Script& script = Script::Handle(Z, parsed_function->function().script());
   H.SetStringOffsets(TypedData::Handle(Z, script.kernel_string_offsets()));
   H.SetStringData(TypedData::Handle(Z, script.kernel_string_data()));
+  H.SetCanonicalNames(TypedData::Handle(Z, script.kernel_canonical_names()));
 }
 
 
 void ScopeBuilder::EnterScope(TreeNode* node, TokenPosition start_position) {
   scope_ = new (Z) LocalScope(scope_, depth_.function_, depth_.loop_);
   scope_->set_begin_token_pos(start_position);
   ASSERT(node->kernel_offset() >= 0);
   result_->scopes.Insert(node->kernel_offset(), scope_);
 }
 
@@ skipping 197 matching lines @@
 }
 
 
 ScopeBuildingResult* ScopeBuilder::BuildScopes() {
   if (result_ != NULL) return result_;
 
   ASSERT(scope_ == NULL && depth_.loop_ == 0 && depth_.function_ == 0);
   result_ = new (Z) ScopeBuildingResult();
 
   ParsedFunction* parsed_function = parsed_function_;
-  const dart::Function& function = parsed_function->function();
+  const Function& function = parsed_function->function();
 
   // Setup a [ActiveClassScope] and a [ActiveMemberScope] which will be used
   // e.g. for type translation.
   const dart::Class& klass =
       dart::Class::Handle(zone_, parsed_function_->function().Owner());
   Function& outermost_function = Function::Handle(Z);
   TreeNode* outermost_node = NULL;
   Class* kernel_class = NULL;
   DiscoverEnclosingElements(Z, function, &outermost_function, &outermost_node,
                             &kernel_class);
@@ skipping 728 matching lines @@
 }
 
 
 Fragment operator<<(const Fragment& fragment, Instruction* next) {
   Fragment result = fragment;
   result <<= next;
   return result;
 }
 
 
-TranslationHelper::TranslationHelper(dart::Thread* thread)
+TranslationHelper::TranslationHelper(Thread* thread)
     : thread_(thread),
       zone_(thread->zone()),
       isolate_(thread->isolate()),
       allocation_space_(thread->IsMutatorThread() ? Heap::kNew : Heap::kOld),
       string_offsets_(TypedData::Handle(Z)),
-      string_data_(TypedData::Handle(Z)) {}
+      string_data_(TypedData::Handle(Z)),
+      canonical_names_(TypedData::Handle(Z)) {}
 
 
 void TranslationHelper::SetStringOffsets(const TypedData& string_offsets) {
   ASSERT(string_offsets_.IsNull());
   string_offsets_ = string_offsets.raw();
 }
 
 
 void TranslationHelper::SetStringData(const TypedData& string_data) {
   ASSERT(string_data_.IsNull());
   string_data_ = string_data.raw();
 }
 
 
+void TranslationHelper::SetCanonicalNames(const TypedData& canonical_names) {
+  ASSERT(canonical_names_.IsNull());
+  canonical_names_ = canonical_names.raw();
+}
+
+
 intptr_t TranslationHelper::StringOffset(intptr_t string_index) const {
   return string_offsets_.GetUint32(string_index << 2);
 }
 
 
 intptr_t TranslationHelper::StringSize(intptr_t string_index) const {
   return StringOffset(string_index + 1) - StringOffset(string_index);
 }
 
 
 uint8_t TranslationHelper::CharacterAt(intptr_t string_index, intptr_t index) {
   ASSERT(index < StringSize(string_index));
   return string_data_.GetUint8(StringOffset(string_index) + index);
 }
 
 
 bool TranslationHelper::StringEquals(intptr_t string_index, const char* other) {
   NoSafepointScope no_safepoint;
   intptr_t length = strlen(other);
   return (length == StringSize(string_index)) &&
          (memcmp(string_data_.DataAddr(StringOffset(string_index)), other,
                  length) == 0);
 }
 
 
-bool TranslationHelper::IsAdministrative(CanonicalName* name) {
-  // Administrative names start with '@'.
-  return (StringSize(name->name()) > 0) &&
-         (CharacterAt(name->name(), 0) == '@');
+intptr_t TranslationHelper::CanonicalNameParent(intptr_t name) {
+  // Canonical names are pairs of 4-byte parent and string indexes, so the size
+  // of an entry is 8 bytes.  The parent is biased: 0 represents the root name
+  // and N+1 represents the name with index N.
+  return static_cast<intptr_t>(canonical_names_.GetUint32(8 * name)) - 1;
 }
 
 
-bool TranslationHelper::IsPrivate(CanonicalName* name) {
-  // Private names start with '_'.
-  return (StringSize(name->name()) > 0) &&
-         (CharacterAt(name->name(), 0) == '_');
+intptr_t TranslationHelper::CanonicalNameString(intptr_t name) {
+  return canonical_names_.GetUint32((8 * name) + 4);
 }
 
 
-bool TranslationHelper::IsRoot(CanonicalName* name) {
-  // The root is the only canonical name with no parent.
-  return name->parent() == NULL;
+bool TranslationHelper::IsAdministrative(intptr_t name) {
+  // Administrative names start with '@'.
+  intptr_t name_string = CanonicalNameString(name);
+  return (StringSize(name_string) > 0) && (CharacterAt(name_string, 0) == '@');
 }
 
 
-bool TranslationHelper::IsLibrary(CanonicalName* name) {
-  // Libraries are the only canonical names with the root as their parent.
-  return !IsRoot(name) && IsRoot(name->parent());
+bool TranslationHelper::IsPrivate(intptr_t name) {
+  // Private names start with '_'.
+  intptr_t name_string = CanonicalNameString(name);
+  return (StringSize(name_string) > 0) && (CharacterAt(name_string, 0) == '_');
 }
 
 
-bool TranslationHelper::IsClass(CanonicalName* name) {
-  // Classes have the library as their parent and are not an administrative
-  // name starting with @.
-  return !IsAdministrative(name) && !IsRoot(name) && IsLibrary(name->parent());
+bool TranslationHelper::IsRoot(intptr_t name) {
+  return name == -1;
 }
 
 
-bool TranslationHelper::IsMember(CanonicalName* name) {
+bool TranslationHelper::IsLibrary(intptr_t name) {
+  // Libraries are the only canonical names with the root as their parent.
+  return !IsRoot(name) && IsRoot(CanonicalNameParent(name));
+}
+
+
+bool TranslationHelper::IsClass(intptr_t name) {
+  // Classes have the library as their parent and are not an administrative
+  // name starting with @.
+  return !IsAdministrative(name) && !IsRoot(name) &&
+         IsLibrary(CanonicalNameParent(name));
+}
+
+
+bool TranslationHelper::IsMember(intptr_t name) {
   return IsConstructor(name) || IsField(name) || IsProcedure(name);
 }
 
 
-bool TranslationHelper::IsField(CanonicalName* name) {
+bool TranslationHelper::IsField(intptr_t name) {
   // Fields with private names have the import URI of the library where they are
   // visible as the parent and the string "@fields" as the parent's parent.
   // Fields with non-private names have the string "@fields' as the parent.
   if (IsRoot(name)) {
     return false;
   }
-  CanonicalName* kind = name->parent();
+  intptr_t kind = CanonicalNameParent(name);
   if (IsPrivate(name)) {
-    kind = kind->parent();
+    kind = CanonicalNameParent(kind);
   }
-  return StringEquals(kind->name(), "@fields");
+  return StringEquals(CanonicalNameString(kind), "@fields");
 }
 
 
-bool TranslationHelper::IsConstructor(CanonicalName* name) {
+bool TranslationHelper::IsConstructor(intptr_t name) {
   // Constructors with private names have the import URI of the library where
   // they are visible as the parent and the string "@constructors" as the
   // parent's parent.  Constructors with non-private names have the string
   // "@constructors" as the parent.
   if (IsRoot(name)) {
     return false;
   }
-  CanonicalName* kind = name->parent();
+  intptr_t kind = CanonicalNameParent(name);
   if (IsPrivate(name)) {
-    kind = kind->parent();
+    kind = CanonicalNameParent(kind);
   }
-  return StringEquals(kind->name(), "@constructors");
+  return StringEquals(CanonicalNameString(kind), "@constructors");
 }
 
 
-bool TranslationHelper::IsProcedure(CanonicalName* name) {
+bool TranslationHelper::IsProcedure(intptr_t name) {
   return IsMethod(name) || IsGetter(name) || IsSetter(name) || IsFactory(name);
 }
 
 
-bool TranslationHelper::IsMethod(CanonicalName* name) {
+bool TranslationHelper::IsMethod(intptr_t name) {
   // Methods with private names have the import URI of the library where they
   // are visible as the parent and the string "@methods" as the parent's parent.
   // Methods with non-private names have the string "@methods" as the parent.
   if (IsRoot(name)) {
     return false;
   }
-  CanonicalName* kind = name->parent();
+  intptr_t kind = CanonicalNameParent(name);
   if (IsPrivate(name)) {
-    kind = kind->parent();
+    kind = CanonicalNameParent(kind);
   }
-  return StringEquals(kind->name(), "@methods");
+  return StringEquals(CanonicalNameString(kind), "@methods");
 }
 
 
-bool TranslationHelper::IsGetter(CanonicalName* name) {
+bool TranslationHelper::IsGetter(intptr_t name) {
   // Getters with private names have the import URI of the library where they
   // are visible as the parent and the string "@getters" as the parent's parent.
   // Getters with non-private names have the string "@getters" as the parent.
   if (IsRoot(name)) {
     return false;
   }
-  CanonicalName* kind = name->parent();
+  intptr_t kind = CanonicalNameParent(name);
   if (IsPrivate(name)) {
-    kind = kind->parent();
+    kind = CanonicalNameParent(kind);
   }
-  return StringEquals(kind->name(), "@getters");
+  return StringEquals(CanonicalNameString(kind), "@getters");
 }
 
 
-bool TranslationHelper::IsSetter(CanonicalName* name) {
+bool TranslationHelper::IsSetter(intptr_t name) {
   // Setters with private names have the import URI of the library where they
   // are visible as the parent and the string "@setters" as the parent's parent.
   // Setters with non-private names have the string "@setters" as the parent.
   if (IsRoot(name)) {
     return false;
   }
-  CanonicalName* kind = name->parent();
+  intptr_t kind = CanonicalNameParent(name);
   if (IsPrivate(name)) {
-    kind = kind->parent();
+    kind = CanonicalNameParent(kind);
   }
-  return StringEquals(kind->name(), "@setters");
+  return StringEquals(CanonicalNameString(kind), "@setters");
 }
 
 
-bool TranslationHelper::IsFactory(CanonicalName* name) {
+bool TranslationHelper::IsFactory(intptr_t name) {
   // Factories with private names have the import URI of the library where they
   // are visible as the parent and the string "@factories" as the parent's
   // parent.  Factories with non-private names have the string "@factories" as
   // the parent.
   if (IsRoot(name)) {
     return false;
   }
-  CanonicalName* kind = name->parent();
+  intptr_t kind = CanonicalNameParent(name);
   if (IsPrivate(name)) {
-    kind = kind->parent();
+    kind = CanonicalNameParent(kind);
   }
-  return StringEquals(kind->name(), "@factories");
+  return StringEquals(CanonicalNameString(kind), "@factories");
 }
 
 
-CanonicalName* TranslationHelper::EnclosingName(CanonicalName* name) {
+intptr_t TranslationHelper::EnclosingName(intptr_t name) {
   ASSERT(IsField(name) || IsConstructor(name) || IsProcedure(name));
-  CanonicalName* enclosing = name->parent()->parent();
+  intptr_t enclosing = CanonicalNameParent(CanonicalNameParent(name));
   if (IsPrivate(name)) {
-    enclosing = enclosing->parent();
+    enclosing = CanonicalNameParent(enclosing);
   }
   ASSERT(IsLibrary(enclosing) || IsClass(enclosing));
   return enclosing;
 }
 
 
 RawInstance* TranslationHelper::Canonicalize(const Instance& instance) {
   if (instance.IsNull()) return instance.raw();
 
   const char* error_str = NULL;
@@ skipping 37 matching lines @@
 }
 
 
 dart::String& TranslationHelper::DartSymbol(intptr_t string_index) const {
   intptr_t length = StringSize(string_index);
   uint8_t* buffer = Z->Alloc<uint8_t>(length);
   {
     NoSafepointScope no_safepoint;
     memmove(buffer, string_data_.DataAddr(StringOffset(string_index)), length);
   }
-  return dart::String::ZoneHandle(
-      Z, dart::Symbols::FromUTF8(thread_, buffer, length));
+  return dart::String::ZoneHandle(Z,
+                                  Symbols::FromUTF8(thread_, buffer, length));
 }
 
 dart::String& TranslationHelper::DartSymbol(const uint8_t* utf8_array,
                                             intptr_t len) const {
-  return dart::String::ZoneHandle(
-      Z, dart::Symbols::FromUTF8(thread_, utf8_array, len));
+  return dart::String::ZoneHandle(Z,
+                                  Symbols::FromUTF8(thread_, utf8_array, len));
 }
 
-const dart::String& TranslationHelper::DartClassName(
-    CanonicalName* kernel_class) {
+const dart::String& TranslationHelper::DartClassName(intptr_t kernel_class) {
   ASSERT(IsClass(kernel_class));
-  dart::String& name = DartString(kernel_class->name());
-  return ManglePrivateName(kernel_class->parent(), &name);
+  dart::String& name = DartString(CanonicalNameString(kernel_class));
+  return ManglePrivateName(CanonicalNameParent(kernel_class), &name);
 }
 
 
 const dart::String& TranslationHelper::DartConstructorName(
-    CanonicalName* constructor) {
+    intptr_t constructor) {
   ASSERT(IsConstructor(constructor));
   return DartFactoryName(constructor);
 }
 
 
-const dart::String& TranslationHelper::DartProcedureName(
-    CanonicalName* procedure) {
+const dart::String& TranslationHelper::DartProcedureName(intptr_t procedure) {
   ASSERT(IsProcedure(procedure));
   if (IsSetter(procedure)) {
     return DartSetterName(procedure);
   } else if (IsGetter(procedure)) {
     return DartGetterName(procedure);
   } else if (IsFactory(procedure)) {
     return DartFactoryName(procedure);
   } else {
     return DartMethodName(procedure);
   }
 }
 
 
-const dart::String& TranslationHelper::DartSetterName(CanonicalName* setter) {
-  return DartSetterName(setter->parent(), setter->name());
+const dart::String& TranslationHelper::DartSetterName(intptr_t setter) {
+  return DartSetterName(CanonicalNameParent(setter),
+                        CanonicalNameString(setter));
 }
 
 
 const dart::String& TranslationHelper::DartSetterName(Name* setter_name) {
   return DartSetterName(setter_name->library(), setter_name->string_index());
 }
 
 
-const dart::String& TranslationHelper::DartSetterName(CanonicalName* parent,
+const dart::String& TranslationHelper::DartSetterName(intptr_t parent,
                                                       intptr_t setter) {
   // The names flowing into [setter] are coming from the Kernel file:
   //   * user-defined setters: `fieldname=`
   //   * property-set expressions:  `fieldname`
   //
   // The VM uses `get:fieldname` and `set:fieldname`.
   //
   // => In order to be consistent, we remove the `=` always and adopt the VM
   //    conventions.
   intptr_t size = StringSize(setter);
   ASSERT(size > 0);
   if (CharacterAt(setter, size - 1) == '=') {
     --size;
   }
   uint8_t* buffer = Z->Alloc<uint8_t>(size);
   {
     NoSafepointScope no_safepoint;
     memmove(buffer, string_data_.DataAddr(StringOffset(setter)), size);
   }
   dart::String& name = dart::String::ZoneHandle(
       Z, dart::String::FromUTF8(buffer, size, allocation_space_));
   ManglePrivateName(parent, &name, false);
   name = dart::Field::SetterSymbol(name);
   return name;
 }
 
 
-const dart::String& TranslationHelper::DartGetterName(CanonicalName* getter) {
-  return DartGetterName(getter->parent(), getter->name());
+const dart::String& TranslationHelper::DartGetterName(intptr_t getter) {
+  return DartGetterName(CanonicalNameParent(getter),
+                        CanonicalNameString(getter));
 }
 
 
 const dart::String& TranslationHelper::DartGetterName(Name* getter_name) {
   return DartGetterName(getter_name->library(), getter_name->string_index());
 }
 
 
-const dart::String& TranslationHelper::DartGetterName(CanonicalName* parent,
+const dart::String& TranslationHelper::DartGetterName(intptr_t parent,
                                                       intptr_t getter) {
   dart::String& name = DartString(getter);
   ManglePrivateName(parent, &name, false);
   name = dart::Field::GetterSymbol(name);
   return name;
 }
 
 
 const dart::String& TranslationHelper::DartFieldName(Name* kernel_name) {
   dart::String& name = DartString(kernel_name->string_index());
   return ManglePrivateName(kernel_name->library(), &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(CanonicalName* method) {
-  return DartMethodName(method->parent(), method->name());
+const dart::String& TranslationHelper::DartMethodName(intptr_t method) {
+  return DartMethodName(CanonicalNameParent(method),
+                        CanonicalNameString(method));
 }
 
 
 const dart::String& TranslationHelper::DartMethodName(Name* method_name) {
   return DartMethodName(method_name->library(), method_name->string_index());
 }
 
 
-const dart::String& TranslationHelper::DartMethodName(CanonicalName* parent,
+const dart::String& TranslationHelper::DartMethodName(intptr_t parent,
                                                       intptr_t method) {
   dart::String& name = DartString(method);
   return ManglePrivateName(parent, &name);
 }
 
 
-const dart::String& TranslationHelper::DartFactoryName(CanonicalName* factory) {
+const dart::String& TranslationHelper::DartFactoryName(intptr_t factory) {
   ASSERT(IsConstructor(factory) || IsFactory(factory));
   GrowableHandlePtrArray<const dart::String> pieces(Z, 3);
   pieces.Add(DartClassName(EnclosingName(factory)));
   pieces.Add(Symbols::Dot());
   // [DartMethodName] will mangle the name.
   pieces.Add(DartMethodName(factory));
-  return dart::String::ZoneHandle(
-      Z, dart::Symbols::FromConcatAll(thread_, pieces));
+  return dart::String::ZoneHandle(Z, Symbols::FromConcatAll(thread_, pieces));
 }
 
 
-dart::RawLibrary* TranslationHelper::LookupLibraryByKernelLibrary(
-    CanonicalName* kernel_library) {
+RawLibrary* TranslationHelper::LookupLibraryByKernelLibrary(
+    intptr_t kernel_library) {
   // We only use the string and don't rely on having any particular parent.
   // This ASSERT is just a sanity check.
   ASSERT(IsLibrary(kernel_library) ||
-         IsAdministrative(kernel_library->parent()));
-  const dart::String& library_name = DartSymbol(kernel_library->name());
+         IsAdministrative(CanonicalNameParent(kernel_library)));
+  const dart::String& library_name =
+      DartSymbol(CanonicalNameString(kernel_library));
   ASSERT(!library_name.IsNull());
-  dart::RawLibrary* library =
-      dart::Library::LookupLibrary(thread_, library_name);
+  RawLibrary* library = dart::Library::LookupLibrary(thread_, library_name);
   ASSERT(library != Object::null());
   return library;
 }
 
 
-dart::RawClass* TranslationHelper::LookupClassByKernelClass(
-    CanonicalName* kernel_class) {
+RawClass* TranslationHelper::LookupClassByKernelClass(intptr_t kernel_class) {
   ASSERT(IsClass(kernel_class));
-  dart::RawClass* klass = NULL;
   const dart::String& class_name = DartClassName(kernel_class);
-  CanonicalName* kernel_library = kernel_class->parent();
+  intptr_t kernel_library = CanonicalNameParent(kernel_class);
   dart::Library& library =
       dart::Library::Handle(Z, LookupLibraryByKernelLibrary(kernel_library));
-  klass = library.LookupClassAllowPrivate(class_name);
+  RawClass* klass = library.LookupClassAllowPrivate(class_name);
 
   ASSERT(klass != Object::null());
   return klass;
 }
 
 
-dart::RawField* TranslationHelper::LookupFieldByKernelField(
-    CanonicalName* kernel_field) {
+RawField* TranslationHelper::LookupFieldByKernelField(intptr_t kernel_field) {
   ASSERT(IsField(kernel_field));
-  CanonicalName* enclosing = EnclosingName(kernel_field);
+  intptr_t enclosing = EnclosingName(kernel_field);
 
   dart::Class& klass = dart::Class::Handle(Z);
   if (IsLibrary(enclosing)) {
     dart::Library& library =
         dart::Library::Handle(Z, LookupLibraryByKernelLibrary(enclosing));
     klass = library.toplevel_class();
   } else {
     ASSERT(IsClass(enclosing));
     klass = LookupClassByKernelClass(enclosing);
   }
-  dart::RawField* field =
-      klass.LookupFieldAllowPrivate(DartSymbol(kernel_field->name()));
+  RawField* field = klass.LookupFieldAllowPrivate(
+      DartSymbol(CanonicalNameString(kernel_field)));
   ASSERT(field != Object::null());
   return field;
 }
 
 
-dart::RawFunction* TranslationHelper::LookupStaticMethodByKernelProcedure(
-    CanonicalName* procedure) {
+RawFunction* TranslationHelper::LookupStaticMethodByKernelProcedure(
+    intptr_t procedure) {
   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).
-  CanonicalName* enclosing = EnclosingName(procedure);
+  intptr_t enclosing = EnclosingName(procedure);
   if (IsLibrary(enclosing)) {
     dart::Library& library =
         dart::Library::Handle(Z, LookupLibraryByKernelLibrary(enclosing));
-    dart::RawFunction* function =
-        library.LookupFunctionAllowPrivate(procedure_name);
+    RawFunction* function = library.LookupFunctionAllowPrivate(procedure_name);
     ASSERT(function != Object::null());
     return function;
   } else {
     ASSERT(IsClass(enclosing));
     dart::Class& klass =
         dart::Class::Handle(Z, LookupClassByKernelClass(enclosing));
-    dart::RawFunction* raw_function =
-        klass.LookupFunctionAllowPrivate(procedure_name);
-    ASSERT(raw_function != Object::null());
+    Function& function = Function::ZoneHandle(
+        Z, klass.LookupFunctionAllowPrivate(procedure_name));
+    ASSERT(!function.IsNull());
 
     // 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();
   }
 }
 
 
-dart::RawFunction* TranslationHelper::LookupConstructorByKernelConstructor(
-    CanonicalName* constructor) {
+RawFunction* TranslationHelper::LookupConstructorByKernelConstructor(
+    intptr_t constructor) {
   ASSERT(IsConstructor(constructor));
   dart::Class& klass = dart::Class::Handle(
       Z, LookupClassByKernelClass(EnclosingName(constructor)));
   return LookupConstructorByKernelConstructor(klass, constructor);
 }
 
 
-dart::RawFunction* TranslationHelper::LookupConstructorByKernelConstructor(
+RawFunction* TranslationHelper::LookupConstructorByKernelConstructor(
     const dart::Class& owner,
-    CanonicalName* constructor) {
+    intptr_t constructor) {
   ASSERT(IsConstructor(constructor));
-  dart::RawFunction* function =
+  RawFunction* function =
       owner.LookupConstructorAllowPrivate(DartConstructorName(constructor));
   ASSERT(function != Object::null());
   return function;
 }
 
 
 dart::Type& TranslationHelper::GetCanonicalType(const dart::Class& klass) {
   ASSERT(!klass.IsNull());
   // Note that if cls is _Closure, the returned type will be _Closure,
   // and not the signature type.
@@ skipping 31 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(CanonicalName* parent,
+dart::String& TranslationHelper::ManglePrivateName(intptr_t parent,
                                                    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(parent));
     *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 27 matching lines @@
       result_(Instance::Handle(zone)) {}
 
 
 Instance& ConstantEvaluator::EvaluateExpression(Expression* expression) {
   if (!GetCachedConstant(expression, &result_)) {
     expression->AcceptExpressionVisitor(this);
     CacheConstantValue(expression, result_);
   }
   // We return a new `ZoneHandle` here on purpose: The intermediate language
   // instructions do not make a copy of the handle, so we do it.
-  return dart::Instance::ZoneHandle(Z, result_.raw());
+  return Instance::ZoneHandle(Z, result_.raw());
 }
 
 
 Object& ConstantEvaluator::EvaluateExpressionSafe(Expression* expression) {
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     return EvaluateExpression(expression);
   } else {
     Thread* thread = H.thread();
     Error& error = Error::Handle(Z);
     error = thread->sticky_error();
     thread->clear_sticky_error();
     return error;
   }
 }
 
 
 Instance& ConstantEvaluator::EvaluateConstructorInvocation(
     ConstructorInvocation* node) {
   if (!GetCachedConstant(node, &result_)) {
     VisitConstructorInvocation(node);
     CacheConstantValue(node, result_);
   }
   // We return a new `ZoneHandle` here on purpose: The intermediate language
   // instructions do not make a copy of the handle, so we do it.
-  return dart::Instance::ZoneHandle(Z, result_.raw());
+  return Instance::ZoneHandle(Z, result_.raw());
 }
 
 
 Instance& ConstantEvaluator::EvaluateListLiteral(ListLiteral* node) {
   if (!GetCachedConstant(node, &result_)) {
     VisitListLiteral(node);
     CacheConstantValue(node, result_);
   }
   // We return a new `ZoneHandle` here on purpose: The intermediate language
   // instructions do not make a copy of the handle, so we do it.
-  return dart::Instance::ZoneHandle(Z, result_.raw());
+  return Instance::ZoneHandle(Z, result_.raw());
 }
 
 
 Instance& ConstantEvaluator::EvaluateMapLiteral(MapLiteral* node) {
   if (!GetCachedConstant(node, &result_)) {
     VisitMapLiteral(node);
     CacheConstantValue(node, result_);
   }
   // We return a new `ZoneHandle` here on purpose: The intermediate language
   // instructions do not make a copy of the handle, so we do it.
-  return dart::Instance::ZoneHandle(Z, result_.raw());
+  return Instance::ZoneHandle(Z, result_.raw());
 }
 
 
 void ConstantEvaluator::VisitBigintLiteral(BigintLiteral* node) {
   const dart::String& value = H.DartString(node->value());
   result_ = Integer::New(value, Heap::kOld);
   result_ = H.Canonicalize(result_);
 }
 
 
 void ConstantEvaluator::VisitBoolLiteral(BoolLiteral* node) {
-  result_ = dart::Bool::Get(node->value()).raw();
+  result_ = Bool::Get(node->value()).raw();
 }
 
 
 void ConstantEvaluator::VisitDoubleLiteral(DoubleLiteral* node) {
-  result_ = dart::Double::New(H.DartString(node->value()), Heap::kOld);
+  result_ = Double::New(H.DartString(node->value()), Heap::kOld);
   result_ = H.Canonicalize(result_);
 }
 
 
 void ConstantEvaluator::VisitIntLiteral(IntLiteral* node) {
-  result_ = dart::Integer::New(node->value(), Heap::kOld);
+  result_ = Integer::New(node->value(), Heap::kOld);
   result_ = H.Canonicalize(result_);
 }
 
 
 void ConstantEvaluator::VisitNullLiteral(NullLiteral* node) {
-  result_ = dart::Instance::null();
+  result_ = Instance::null();
 }
 
 
 void ConstantEvaluator::VisitStringLiteral(StringLiteral* node) {
   result_ = H.DartSymbol(node->value()).raw();
 }
 
 
 void ConstantEvaluator::VisitTypeLiteral(TypeLiteral* node) {
   const AbstractType& type = T.TranslateType(node->type());
@@ skipping 96 matching lines @@
   script_.set_compile_time_constants(constants.Release());
 }
 
 
 void ConstantEvaluator::VisitSymbolLiteral(SymbolLiteral* node) {
   const dart::String& symbol_value = H.DartSymbol(node->value());
 
   const dart::Class& symbol_class =
       dart::Class::ZoneHandle(Z, I->object_store()->symbol_class());
   ASSERT(!symbol_class.IsNull());
-  const dart::Function& symbol_constructor = Function::ZoneHandle(
+  const Function& symbol_constructor = Function::ZoneHandle(
       Z, symbol_class.LookupConstructor(Symbols::SymbolCtor()));
   ASSERT(!symbol_constructor.IsNull());
   result_ ^= EvaluateConstConstructorCall(
       symbol_class, TypeArguments::Handle(Z), symbol_constructor, symbol_value);
 }
 
 
 void ConstantEvaluator::VisitListLiteral(ListLiteral* node) {
   DartType* types[] = {node->type()};
   const TypeArguments& type_arguments = T.TranslateTypeArguments(types, 1);
@@ skipping 84 matching lines @@
   }
 }
 
 
 void ConstantEvaluator::VisitMethodInvocation(MethodInvocation* node) {
   Arguments* kernel_arguments = node->arguments();
 
   // Dart does not support generic methods yet.
   ASSERT(kernel_arguments->types().length() == 0);
 
-  const dart::Instance& receiver = EvaluateExpression(node->receiver());
+  const Instance& receiver = EvaluateExpression(node->receiver());
   dart::Class& klass = dart::Class::Handle(
       Z, isolate_->class_table()->At(receiver.GetClassId()));
   ASSERT(!klass.IsNull());
 
   // Search the superclass chain for the selector.
-  dart::Function& function = dart::Function::Handle(Z);
+  Function& function = Function::Handle(Z);
   const dart::String& method_name = H.DartMethodName(node->name());
   while (!klass.IsNull()) {
     function = klass.LookupDynamicFunctionAllowPrivate(method_name);
     if (!function.IsNull()) break;
     klass = klass.SuperClass();
   }
 
   // The frontend should guarantee that [MethodInvocation]s inside constant
   // expressions are always valid.
   ASSERT(!function.IsNull());
 
   // Run the method and canonicalize the result.
   const Object& result = RunFunction(function, kernel_arguments, &receiver);
   result_ ^= result.raw();
   result_ = H.Canonicalize(result_);
 }
 
 
 void ConstantEvaluator::VisitStaticGet(StaticGet* node) {
-  CanonicalName* target = node->target();
+  intptr_t target = node->target();
   if (H.IsField(target)) {
     const dart::Field& field =
         dart::Field::Handle(Z, H.LookupFieldByKernelField(target));
     if (field.StaticValue() == Object::sentinel().raw() ||
         field.StaticValue() == Object::transition_sentinel().raw()) {
       field.EvaluateInitializer();
       result_ = field.StaticValue();
       result_ = H.Canonicalize(result_);
       field.SetStaticValue(result_, true);
     } else {
@@ skipping 240 matching lines @@
       next_used_try_index_(0),
       catch_block_(NULL),
       type_translator_(&translation_helper_,
                        &active_class_,
                        /* finalize= */ true),
       constant_evaluator_(this, zone_, &translation_helper_, &type_translator_),
       streaming_flow_graph_builder_(NULL) {
   Script& script = Script::Handle(Z, parsed_function->function().script());
   H.SetStringOffsets(TypedData::Handle(Z, script.kernel_string_offsets()));
   H.SetStringData(TypedData::Handle(Z, script.kernel_string_data()));
+  H.SetCanonicalNames(TypedData::Handle(Z, script.kernel_canonical_names()));
 }
 
 
 FlowGraphBuilder::~FlowGraphBuilder() {
   if (streaming_flow_graph_builder_ != NULL) {
     delete streaming_flow_graph_builder_;
   }
 }
 
 
@@ skipping 802 matching lines @@
   return Fragment(interpolate);
 }
 
 
 Fragment FlowGraphBuilder::StringInterpolateSingle(TokenPosition position) {
   const int kNumberOfArguments = 1;
   const Array& kNoArgumentNames = Object::null_array();
   const dart::Class& cls = dart::Class::Handle(
       dart::Library::LookupCoreClass(Symbols::StringBase()));
   ASSERT(!cls.IsNull());
-  const Function& function = dart::Function::ZoneHandle(
-      Z, dart::Resolver::ResolveStatic(cls, dart::Library::PrivateCoreLibName(
-                                                Symbols::InterpolateSingle()),
-                                       kNumberOfArguments, kNoArgumentNames));
+  const Function& function = Function::ZoneHandle(
+      Z, Resolver::ResolveStatic(cls, dart::Library::PrivateCoreLibName(
+                                          Symbols::InterpolateSingle()),
+                                 kNumberOfArguments, kNoArgumentNames));
   Fragment instructions;
   instructions += PushArgument();
   instructions += StaticCall(position, function, 1);
   return instructions;
 }
 
 
 Fragment FlowGraphBuilder::ThrowTypeError() {
   const dart::Class& klass = dart::Class::ZoneHandle(
       Z, dart::Library::LookupCoreClass(Symbols::TypeError()));
   ASSERT(!klass.IsNull());
-  const dart::Function& constructor = dart::Function::ZoneHandle(
+  const Function& constructor = Function::ZoneHandle(
       Z,
       klass.LookupConstructorAllowPrivate(H.DartSymbol("_TypeError._create")));
   ASSERT(!constructor.IsNull());
 
   const dart::String& url = H.DartString(
       parsed_function_->function().ToLibNamePrefixedQualifiedCString(),
       Heap::kOld);
 
   Fragment instructions;
 
@@ skipping 25 matching lines @@
   instructions += ThrowException(TokenPosition::kNoSource);
 
   return instructions;
 }
 
 
 Fragment FlowGraphBuilder::ThrowNoSuchMethodError() {
   const dart::Class& klass = dart::Class::ZoneHandle(
       Z, dart::Library::LookupCoreClass(Symbols::NoSuchMethodError()));
   ASSERT(!klass.IsNull());
-  const dart::Function& throw_function = dart::Function::ZoneHandle(
+  const Function& throw_function = Function::ZoneHandle(
       Z, klass.LookupStaticFunctionAllowPrivate(Symbols::ThrowNew()));
   ASSERT(!throw_function.IsNull());
 
   Fragment instructions;
 
   // Call NoSuchMethodError._throwNew static function.
   instructions += NullConstant();
   instructions += PushArgument();  // receiver
 
   instructions += Constant(H.DartString("<unknown>", Heap::kOld));
@@ skipping 12 matching lines @@
   instructions += PushArgument();  // existingArgumentNames
 
   instructions += StaticCall(TokenPosition::kNoSource, throw_function, 6);
   // Leave "result" on the stack since callers expect it to be there (even
   // though the function will result in an exception).
 
   return instructions;
 }
 
 
-dart::RawFunction* FlowGraphBuilder::LookupMethodByMember(
-    CanonicalName* target,
+RawFunction* FlowGraphBuilder::LookupMethodByMember(
+    intptr_t target,
     const dart::String& method_name) {
-  CanonicalName* kernel_class = H.EnclosingName(target);
+  intptr_t kernel_class = H.EnclosingName(target);
   dart::Class& klass =
       dart::Class::Handle(Z, H.LookupClassByKernelClass(kernel_class));
 
-  dart::RawFunction* function = klass.LookupFunctionAllowPrivate(method_name);
+  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();
   OS::SNPrint(name, 64, ":temp%" Pd, index);
   LocalVariable* variable =
@@ skipping 16 matching lines @@
 
 intptr_t FlowGraphBuilder::CurrentTryIndex() {
   if (try_catch_block_ == NULL) {
     return CatchClauseNode::kInvalidTryIndex;
   } else {
     return try_catch_block_->try_index();
   }
 }
 
 
-dart::LocalVariable* FlowGraphBuilder::LookupVariable(
-    VariableDeclaration* var) {
+LocalVariable* FlowGraphBuilder::LookupVariable(VariableDeclaration* var) {
   LocalVariable* local = scopes_->locals.Lookup(var->kernel_offset());
   ASSERT(local != NULL);
   return local;
 }
 
 
 void FlowGraphBuilder::SetTempIndex(Definition* definition) {
   definition->set_temp_index(
       stack_ == NULL ? 0 : stack_->definition()->temp_index() + 1);
 }
@@ skipping 89 matching lines @@
 void FlowGraphBuilder::InlineBailout(const char* reason) {
   bool is_inlining = exit_collector_ != NULL;
   if (is_inlining) {
     parsed_function_->function().set_is_inlinable(false);
     parsed_function_->Bailout("kernel::FlowGraphBuilder", reason);
   }
 }
 
 
 FlowGraph* FlowGraphBuilder::BuildGraph() {
-  const dart::Function& function = parsed_function_->function();
+  const Function& function = parsed_function_->function();
 
   if (function.IsConstructorClosureFunction()) return NULL;
 
   TreeNode* library_node = node_;
   if (node_ != NULL) {
-    const dart::Function* parent = &function;
+    const Function* parent = &function;
     while (true) {
       library_node = static_cast<kernel::TreeNode*>(parent->kernel_function());
       while (library_node != NULL && !library_node->IsLibrary()) {
         if (library_node->IsMember()) {
           library_node = Member::Cast(library_node)->parent();
         } else if (library_node->IsClass()) {
           library_node = Class::Cast(library_node)->parent();
           break;
         } else {
           library_node = NULL;
           break;
         }
       }
       if (library_node != NULL) break;
-      parent = &dart::Function::Handle(parent->parent_function());
+      parent = &Function::Handle(parent->parent_function());
     }
   }
   if (streaming_flow_graph_builder_ != NULL) {
     delete streaming_flow_graph_builder_;
     streaming_flow_graph_builder_ = NULL;
   }
   if (library_node != NULL && library_node->IsLibrary()) {
     Library* library = Library::Cast(library_node);
     streaming_flow_graph_builder_ = new StreamingFlowGraphBuilder(
         this, library->kernel_data(), library->kernel_data_size());
@@ skipping 518 matching lines @@
       break;
     }
   }
   return body + Return(TokenPosition::kNoSource);
 }
 
 
 FlowGraph* FlowGraphBuilder::BuildGraphOfFieldAccessor(
     Field* kernel_field,
     LocalVariable* setter_value) {
-  const dart::Function& function = parsed_function_->function();
+  const Function& function = parsed_function_->function();
 
   bool is_setter = function.IsImplicitSetterFunction();
   bool is_method = !function.IsStaticFunction();
   dart::Field& field = dart::Field::ZoneHandle(
       Z, H.LookupFieldByKernelField(kernel_field->canonical_name()));
 
   TargetEntryInstr* normal_entry = BuildTargetEntry();
   graph_entry_ = new (Z)
       GraphEntryInstr(*parsed_function_, normal_entry, Compiler::kNoOSRDeoptId);
 
@@ skipping 141 matching lines @@
 Fragment FlowGraphBuilder::DebugStepCheck(TokenPosition position) {
   return Fragment(
       new (Z) DebugStepCheckInstr(position, RawPcDescriptors::kRuntimeCall));
 }
 
 
 Fragment FlowGraphBuilder::EvaluateAssertion() {
   const dart::Class& klass = dart::Class::ZoneHandle(
       Z, dart::Library::LookupCoreClass(Symbols::AssertionError()));
   ASSERT(!klass.IsNull());
-  const dart::Function& target =
-      dart::Function::ZoneHandle(Z, klass.LookupStaticFunctionAllowPrivate(
-                                        H.DartSymbol("_evaluateAssertion")));
+  const Function& target =
+      Function::ZoneHandle(Z, klass.LookupStaticFunctionAllowPrivate(
+                                  H.DartSymbol("_evaluateAssertion")));
   ASSERT(!target.IsNull());
   return StaticCall(TokenPosition::kNoSource, target, 1);
 }
 
 
 Fragment FlowGraphBuilder::CheckReturnTypeInCheckedMode() {
   if (I->type_checks()) {
     const AbstractType& return_type =
         AbstractType::Handle(Z, parsed_function_->function().result_type());
     return CheckAssignableInCheckedMode(return_type, Symbols::FunctionResult());
   }
   return Fragment();
 }
 
 
 Fragment FlowGraphBuilder::CheckBooleanInCheckedMode() {
   Fragment instructions;
   if (I->type_checks()) {
     LocalVariable* top_of_stack = MakeTemporary();
     instructions += LoadLocal(top_of_stack);
     instructions += AssertBool();
     instructions += Drop();
   }
   return instructions;
 }
 
 
 Fragment FlowGraphBuilder::CheckAssignableInCheckedMode(
-    const dart::AbstractType& dst_type,
+    const AbstractType& dst_type,
     const dart::String& dst_name) {
   Fragment instructions;
   if (I->type_checks() && !dst_type.IsDynamicType() &&
       !dst_type.IsObjectType()) {
     LocalVariable* top_of_stack = MakeTemporary();
     instructions += LoadLocal(top_of_stack);
     instructions += AssertAssignable(dst_type, dst_name);
     instructions += Drop();
   }
   return instructions;
 }
 
 
 Fragment FlowGraphBuilder::AssertBool() {
   Value* value = Pop();
   AssertBooleanInstr* instr =
       new (Z) AssertBooleanInstr(TokenPosition::kNoSource, value);
   Push(instr);
   return Fragment(instr);
 }
 
 
-Fragment FlowGraphBuilder::AssertAssignable(const dart::AbstractType& dst_type,
+Fragment FlowGraphBuilder::AssertAssignable(const AbstractType& dst_type,
                                             const dart::String& dst_name) {
   Fragment instructions;
   Value* value = Pop();
 
   if (!dst_type.IsInstantiated(kCurrentClass)) {
     instructions += LoadInstantiatorTypeArguments();
   } else {
     instructions += NullConstant();
   }
   Value* instantiator_type_args = Pop();
@@ skipping 137 matching lines @@
     body += LoadLocal(array);
     body += IntConstant(i);
     body += LoadLocal(scope->VariableAt(i));
     body += StoreIndexed(kArrayCid);
     body += Drop();
   }
   dart::String& name = dart::String::Handle(Z);
   for (intptr_t i = 0; i < descriptor.NamedCount(); ++i) {
     intptr_t parameter_index = descriptor.PositionalCount() + i;
     name = descriptor.NameAt(i);
-    name = dart::Symbols::New(H.thread(), name);
+    name = Symbols::New(H.thread(), name);
     body += LoadLocal(array);
     body += IntConstant(descriptor.PositionAt(i));
     body += LoadLocal(scope->VariableAt(parameter_index));
     body += StoreIndexed(kArrayCid);
     body += Drop();
   }
   body += PushArgument();
 
   // Fourth, false indicating this is not a super NoSuchMethod.
   body += Constant(Bool::False());
@@ skipping 165 matching lines @@
 JoinEntryInstr* FlowGraphBuilder::BuildJoinEntry(intptr_t try_index) {
   return new (Z) JoinEntryInstr(AllocateBlockId(), try_index);
 }
 
 
 JoinEntryInstr* FlowGraphBuilder::BuildJoinEntry() {
   return new (Z) JoinEntryInstr(AllocateBlockId(), CurrentTryIndex());
 }
 
 
-Fragment FlowGraphBuilder::TranslateFieldInitializer(
-    CanonicalName* canonical_name,
-    Expression* init) {
+Fragment FlowGraphBuilder::TranslateFieldInitializer(intptr_t canonical_name,
+                                                     Expression* init) {
   dart::Field& field =
       dart::Field::ZoneHandle(Z, H.LookupFieldByKernelField(canonical_name));
   if (init->IsNullLiteral()) {
     field.RecordStore(Object::null_object());
     return Fragment();
   }
   Fragment instructions;
   instructions += LoadLocal(scopes_->this_variable);
   instructions += TranslateExpression(init);
   instructions += StoreInstanceFieldGuarded(field, true);
@@ skipping 190 matching lines @@
 void FlowGraphBuilder::VisitSymbolLiteral(SymbolLiteral* node) {
   fragment_ = streaming_flow_graph_builder_->BuildAt(node->kernel_offset());
 }
 
 
 AbstractType& DartTypeTranslator::TranslateType(DartType* node) {
   node->AcceptDartTypeVisitor(this);
 
   // We return a new `ZoneHandle` here on purpose: The intermediate language
   // instructions do not make a copy of the handle, so we do it.
-  return dart::AbstractType::ZoneHandle(Z, result_.raw());
+  return AbstractType::ZoneHandle(Z, result_.raw());
 }
 
 
 AbstractType& DartTypeTranslator::TranslateTypeWithoutFinalization(
     DartType* node) {
   bool saved_finalize = finalize_;
   finalize_ = false;
   AbstractType& result = TranslateType(node);
   finalize_ = saved_finalize;
   return result;
@@ skipping 14 matching lines @@
     type = result_.raw();
   }
 
   return type;
 }
 
 
 void DartTypeTranslator::VisitInvalidType(InvalidType* node) {
   result_ = ClassFinalizer::NewFinalizedMalformedType(
       Error::Handle(Z),  // No previous error.
-      dart::Script::Handle(Z, dart::Script::null()), TokenPosition::kNoSource,
+      Script::Handle(Z, Script::null()), TokenPosition::kNoSource,
       "[InvalidType] in Kernel IR.");
 }
 
 
 void DartTypeTranslator::VisitFunctionType(FunctionType* node) {
   // The spec describes in section "19.1 Static Types":
   //
   //     Any use of a malformed type gives rise to a static warning. A
   //     malformed type is then interpreted as dynamic by the static type
   //     checker and the runtime unless explicitly specified otherwise.
@@ skipping 108 matching lines @@
       //   class A<T> {
       //     static A.x<T'>() { return new B<T'>(); }
       //   }
       //
       const intptr_t index = FindTypeParameterIndex(
           &procedure->function()->type_parameters(), node->parameter());
       if (index >= 0) {
         if (procedure->kind() == Procedure::kFactory) {
           // The index of the type parameter in [parameters] is
           // the same index into the `klass->type_parameters()` array.
-          result_ ^= dart::TypeArguments::Handle(
-                         Z, active_class_->klass->type_parameters())
-                         .TypeAt(index);
+          result_ ^=
+              TypeArguments::Handle(Z, active_class_->klass->type_parameters())
+                  .TypeAt(index);
         } else {
           result_ ^= dart::Type::DynamicType();
         }
         return;
       }
     }
   }
 
   ASSERT(active_class_->kernel_class != NULL);
   List<TypeParameter>* parameters =
       &active_class_->kernel_class->type_parameters();
   const intptr_t index = FindTypeParameterIndex(parameters, node->parameter());
   if (index >= 0) {
     // The index of the type parameter in [parameters] is
     // the same index into the `klass->type_parameters()` array.
-    result_ ^=
-        dart::TypeArguments::Handle(Z, active_class_->klass->type_parameters())
-            .TypeAt(index);
+    result_ ^= TypeArguments::Handle(Z, active_class_->klass->type_parameters())
+                   .TypeAt(index);
     return;
   }
 
   UNREACHABLE();
 }
 
 
 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()));
+  Object& klass = Object::Handle(Z, H.LookupClassByKernelClass(node->klass()));
   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 144 matching lines @@
     } else {
       UNIMPLEMENTED();
     }
   } else {
     UNIMPLEMENTED();
   }
 }
 
 
 void FlowGraphBuilder::VisitStaticSet(StaticSet* node) {
-  CanonicalName* target = node->target();
+  intptr_t target = node->target();
   if (H.IsField(target)) {
     const dart::Field& field =
         dart::Field::ZoneHandle(Z, H.LookupFieldByKernelField(target));
     const AbstractType& dst_type = AbstractType::ZoneHandle(Z, field.type());
     Fragment instructions = TranslateExpression(node->expression());
     if (NeedsDebugStepCheck(stack_, node->position())) {
       instructions = DebugStepCheck(node->position()) + instructions;
     }
     instructions += CheckAssignableInCheckedMode(
         dst_type, dart::String::ZoneHandle(Z, field.name()));
@@ skipping 41 matching lines @@
   instructions += PushArgument();
 
   const dart::String& setter_name = H.DartSetterName(node->name());
   instructions += InstanceCall(node->position(), setter_name, Token::kSET, 2);
   fragment_ = instructions + Drop();
 }
 
 
 void FlowGraphBuilder::VisitDirectPropertyGet(DirectPropertyGet* node) {
   Function& target = Function::ZoneHandle(Z);
-  CanonicalName* kernel_name = node->target();
+  intptr_t kernel_name = node->target();
   if (H.IsProcedure(kernel_name)) {
     if (H.IsGetter(kernel_name)) {
       target = LookupMethodByMember(kernel_name, H.DartGetterName(kernel_name));
     } else {
       target = LookupMethodByMember(kernel_name, H.DartMethodName(kernel_name));
       target = target.ImplicitClosureFunction();
       ASSERT(!target.IsNull());
       fragment_ = BuildImplicitClosureCreation(target);
       return;
     }
@@ skipping 1054 matching lines @@
       body_fragment += Drop();
     }
 
     // The Dart language specification mandates fall-throughs in [SwitchCase]es
     // to be runtime errors.
     if (!switch_case->is_default() && body_fragment.is_open() &&
         (i < (node->cases().length() - 1))) {
       const dart::Class& klass = dart::Class::ZoneHandle(
           Z, dart::Library::LookupCoreClass(Symbols::FallThroughError()));
       ASSERT(!klass.IsNull());
-      const dart::Function& constructor = dart::Function::ZoneHandle(
+      const Function& constructor = Function::ZoneHandle(
           Z, klass.LookupConstructorAllowPrivate(
                  H.DartSymbol("FallThroughError._create")));
       ASSERT(!constructor.IsNull());
       const dart::String& url = H.DartString(
           parsed_function_->function().ToLibNamePrefixedQualifiedCString(),
           Heap::kOld);
 
       // Create instance of _FallThroughError
       body_fragment += AllocateObject(klass, 0);
       LocalVariable* instance = MakeTemporary();
@@ skipping 171 matching lines @@
   instructions += TranslateExpression(node->condition());
   instructions += PushArgument();
   instructions += EvaluateAssertion();
   instructions += CheckBooleanInCheckedMode();
   instructions += Constant(Bool::True());
   instructions += BranchIfEqual(&then, &otherwise, false);
 
   const dart::Class& klass = dart::Class::ZoneHandle(
       Z, dart::Library::LookupCoreClass(Symbols::AssertionError()));
   ASSERT(!klass.IsNull());
-  const dart::Function& constructor = dart::Function::ZoneHandle(
-      Z, klass.LookupConstructorAllowPrivate(
-             H.DartSymbol("_AssertionError._create")));
+  const Function& constructor =
+      Function::ZoneHandle(Z, klass.LookupConstructorAllowPrivate(
+                                  H.DartSymbol("_AssertionError._create")));
   ASSERT(!constructor.IsNull());
 
   const dart::String& url = H.DartString(
       parsed_function_->function().ToLibNamePrefixedQualifiedCString(),
       Heap::kOld);
 
   // Create instance of _AssertionError
   Fragment otherwise_fragment(otherwise);
   otherwise_fragment += AllocateObject(klass, 0);
   LocalVariable* instance = MakeTemporary();
@@ skipping 426 matching lines @@
     } else {
       FATAL1("No support for metadata on this type of kernel node %p\n",
              kernel_node);
     }
 
     TranslationHelper helper(thread);
     Script& script = Script::Handle(Z, metadata_field.Script());
     helper.SetStringOffsets(
         TypedData::Handle(Z, script.kernel_string_offsets()));
     helper.SetStringData(TypedData::Handle(Z, script.kernel_string_data()));
+    helper.SetCanonicalNames(
+        TypedData::Handle(Z, script.kernel_canonical_names()));
     DartTypeTranslator type_translator(&helper, NULL, true);
     ConstantEvaluator constant_evaluator(/* flow_graph_builder = */ NULL, Z,
                                          &helper, &type_translator);
 
     const Array& metadata_values =
         Array::Handle(Z, Array::New(metadata_expressions->length()));
 
     for (intptr_t i = 0; i < metadata_expressions->length(); i++) {
       const Instance& value =
           constant_evaluator.EvaluateExpression((*metadata_expressions)[i]);
@@ skipping 28 matching lines @@
       return NULL;
     }
 
     Thread* thread = Thread::Current();
     Zone* zone_ = thread->zone();
     TranslationHelper helper(thread);
     Script& script = Script::Handle(Z, function.script());
     helper.SetStringOffsets(
         TypedData::Handle(Z, script.kernel_string_offsets()));
     helper.SetStringData(TypedData::Handle(Z, script.kernel_string_data()));
+    helper.SetCanonicalNames(
+        TypedData::Handle(Z, script.kernel_canonical_names()));
     DartTypeTranslator type_translator(&helper, NULL, true);
     ConstantEvaluator constant_evaluator(/* flow_graph_builder = */ NULL, Z,
                                          &helper, &type_translator);
 
     const intptr_t positional_count =
         function_node->positional_parameters().length();
     const intptr_t param_count =
         positional_count + function_node->named_parameters().length();
     const Array& param_descriptor = Array::Handle(
         Array::New(param_count * Parser::kParameterEntrySize, Heap::kOld));
@@ skipping 33 matching lines @@
     thread->clear_sticky_error();
     return error.raw();
   }
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)