Implement canonical name scheme in kernel.

runtime/vm/kernel_binary.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.
 #if !defined(DART_PRECOMPILED_RUNTIME)
 
 #include "platform/globals.h"
 #include "vm/flags.h"
 #include "vm/growable_array.h"
 #include "vm/kernel.h"
 #include "vm/kernel_to_il.h"
@@ skipping 15 matching lines @@
 
 
 static const uint32_t kMagicProgramFile = 0x90ABCDEFu;
 
 
 // Keep in sync with package:dynamo/lib/binary/tag.dart
 enum Tag {
   kNothing = 0,
   kSomething = 1,
 
-  kNormalClass = 2,
-  kMixinClass = 3,
+  kClass = 2,
 
   kField = 4,
   kConstructor = 5,
   kProcedure = 6,
 
   kInvalidInitializer = 7,
   kFieldInitializer = 8,
   kSuperInitializer = 9,
   kRedirectingInitializer = 10,
   kLocalInitializer = 11,
@@ skipping 68 matching lines @@
 
   kInvalidType = 90,
   kDynamicType = 91,
   kVoidType = 92,
   kInterfaceType = 93,
   kFunctionType = 94,
   kTypeParameterType = 95,
   kSimpleInterfaceType = 96,
   kSimpleFunctionType = 97,
 
-  kNullReference = 99,
-  kNormalClassReference = 100,
-  kMixinClassReference = 101,
-
-  kLibraryFieldReference = 102,
-  kClassFieldReference = 103,
-  kClassConstructorReference = 104,
-  kLibraryProcedureReference = 105,
-  kClassProcedureReference = 106,
-
   kSpecializedTagHighBit = 0x80,  // 10000000
   kSpecializedTagMask = 0xF8,     // 11111000
   kSpecializedPayloadMask = 0x7,  // 00000111
 
   kSpecializedVariableGet = 128,
   kSpecializedVariableSet = 136,
   kSpecialIntLiteral = 144,
 };
 
 
@@ skipping 20 matching lines @@
     ASSERT(index < variables_.length());
     return variables_[index];
   }
 
   void Push(T* v) {
     variables_.Add(v);
     current_count_++;
   }
 
   void Push(List<T>* decl) {
-    for (int i = 0; i < decl->length(); i++) {
+    for (intptr_t i = 0; i < decl->length(); i++) {
       variables_.Add(decl[i]);
       current_count_++;
     }
   }
 
   void Pop(T* decl) {
     variables_.RemoveLast();
     current_count_--;
   }
 
@@ skipping 39 matching lines @@
     current_count_++;
   }
 
   void Set(T* v, int index) {
     typename MallocMap<T, int>::Pair* entry = variables_.LookupPair(v);
     ASSERT(entry != NULL);
     entry->value = index;
   }
 
   void Push(List<T>* decl) {
-    for (int i = 0; i < decl->length(); i++) {
+    for (intptr_t i = 0; i < decl->length(); i++) {
       Push(decl[i]);
     }
   }
 
   void Pop(T* v) {
     current_count_--;
     stack_height_--;
   }
 
  private:
@@ skipping 67 matching lines @@
   Program* program() { return program_; }
   void set_program(Program* program) { program_ = program; }
 
   BlockStack<VariableDeclaration>& variables() { return scope_; }
   BlockStack<TypeParameter>& type_parameters() { return type_parameters_; }
   BlockStack<SwitchCase>& switch_cases() { return switch_cases_; }
 
   BlockStack<LabeledStatement>* labels() { return labels_; }
   void set_labels(BlockStack<LabeledStatement>* labels) { labels_ = labels; }
 
+  CanonicalName* GetCanonicalName(int index) { return canonical_names_[index]; }
+  void SetCanonicalName(int index, CanonicalName* name) {
+    canonical_names_[index] = name;
+  }
+  void SetCanonicalNameCount(int count) { canonical_names_.SetLength(count); }
+
  private:
   Program* program_;
+  MallocGrowableArray<Ref<CanonicalName> > canonical_names_;
   BlockStack<VariableDeclaration> scope_;
   BlockStack<TypeParameter> type_parameters_;
   BlockStack<SwitchCase> switch_cases_;
   BlockStack<LabeledStatement>* labels_;
 };
 
 
 class Reader {
  public:
   Reader(const uint8_t* buffer, int64_t size)
@@ skipping 147 matching lines @@
     return RT::ReadFrom(this);
   }
 
   template <typename T>
   T* ReadOptional() {
     return ReadOptional<T, T>();
   }
 
   ReaderHelper* helper() { return &builder_; }
 
+  CanonicalName* ReadCanonicalNameReference() {
+    int index = ReadUInt();
+    if (index == 0) return NULL;
+    CanonicalName* name = builder_.GetCanonicalName(index - 1);
+    ASSERT(name != NULL);
+    return name;
+  }
+
+  CanonicalName* ReadDefiningCanonicalNameReference(LinkedNode* node_to_link) {
+    CanonicalName* name = ReadCanonicalNameReference();
+    ASSERT(name != NULL);
+    name->BindTo(node_to_link);
+    return name;
+  }
+
  private:
   const uint8_t* buffer_;
   int64_t size_;
   int64_t offset_;
   ReaderHelper builder_;
   TokenPosition max_position_;
   TokenPosition min_position_;
   intptr_t current_script_id_;
 
   friend class PositionScope;
@@ skipping 30 matching lines @@
 };
 
 template <typename T>
 template <typename IT>
 void List<T>::ReadFrom(Reader* reader, TreeNode* parent) {
   TRACE_READ_OFFSET();
   ASSERT(parent != NULL);
   int length = reader->ReadListLength();
   EnsureInitialized(length);
 
-  for (int i = 0; i < length_; i++) {
+  for (intptr_t i = 0; i < length_; i++) {
     IT* object = GetOrCreate<IT>(i, parent);
     object->ReadFrom(reader);
   }
 }
 
 
 template <typename T>
 template <typename IT>
 void List<T>::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   int length = reader->ReadListLength();
   EnsureInitialized(length);
 
-  for (int i = 0; i < length_; i++) {
+  for (intptr_t i = 0; i < length_; i++) {
     GetOrCreate<IT>(i)->ReadFrom(reader);
   }
 }
 
 
 template <typename T>
 template <typename IT>
 void List<T>::ReadFromStatic(Reader* reader) {
   TRACE_READ_OFFSET();
   int length = reader->ReadListLength();
   EnsureInitialized(length);
 
-  for (int i = 0; i < length_; i++) {
+  for (intptr_t i = 0; i < length_; i++) {
     ASSERT(array_[i] == NULL);
     array_[i] = IT::ReadFrom(reader);
   }
 }
 
 void TypeParameterList::ReadFrom(Reader* reader) {
   // It is possible for the bound of the first type parameter to refer to
   // the second type parameter. This means we need to create [TypeParameter]
   // objects before reading the bounds.
   int length = reader->ReadListLength();
   EnsureInitialized(length);
 
   // Make all [TypeParameter]s available in scope.
-  for (int i = 0; i < length; i++) {
+  for (intptr_t i = 0; i < length; i++) {
     TypeParameter* parameter = (*this)[i] = new TypeParameter();
     reader->helper()->type_parameters().Push(parameter);
   }
 
   // Read all [TypeParameter]s and their bounds.
-  for (int i = 0; i < length; i++) {
+  for (intptr_t i = 0; i < length; i++) {
     (*this)[i]->ReadFrom(reader);
   }
 }
 
 
 template <typename A, typename B>
 Tuple<A, B>* Tuple<A, B>::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   A* first = A::ReadFrom(reader);
   B* second = B::ReadFrom(reader);
@@ skipping 65 matching lines @@
     }
     line_starts_[i] = line_starts;
   }
 }
 
 
 Library* Library::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   int flags = reader->ReadFlags();
   ASSERT(flags == 0);  // external libraries not supported
+
+  CanonicalName* canonical_name =
+      reader->ReadDefiningCanonicalNameReference(this);
+
   name_ = Reference::ReadStringFrom(reader);
-  import_uri_ = Reference::ReadStringFrom(reader);
+  import_uri_ = canonical_name->name();
   source_uri_index_ = reader->ReadUInt();
   reader->set_current_script_id(source_uri_index_);
 
   int num_imports = reader->ReadUInt();
   if (num_imports != 0) {
     FATAL("Deferred imports not implemented in VM");
   }
   int num_classes = reader->ReadUInt();
   classes().EnsureInitialized(num_classes);
-  for (int i = 0; i < num_classes; i++) {
+  for (intptr_t i = 0; i < num_classes; i++) {
     Tag tag = reader->ReadTag();
-    if (tag == kNormalClass) {
-      NormalClass* klass = classes().GetOrCreate<NormalClass>(i, this);
-      klass->ReadFrom(reader);
-    } else {
-      ASSERT(tag == kMixinClass);
-      MixinClass* klass = classes().GetOrCreate<MixinClass>(i, this);
-      klass->ReadFrom(reader);
-    }
+    ASSERT(tag == kClass);
+    NormalClass* klass = classes().GetOrCreate<NormalClass>(i, this);
+    klass->ReadFrom(reader);
   }
 
   fields().ReadFrom<Field>(reader, this);
   procedures().ReadFrom<Procedure>(reader, this);
   return this;
 }
 
 
 Class* Class::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
 
+  reader->ReadDefiningCanonicalNameReference(this);
   position_ = reader->ReadPosition(false);
   is_abstract_ = reader->ReadBool();
   name_ = Reference::ReadStringFrom(reader);
   source_uri_index_ = reader->ReadUInt();
   reader->set_current_script_id(source_uri_index_);
   reader->record_token_position(position_);
   annotations_.ReadFromStatic<Expression>(reader);
 
   return this;
 }
 
 
 NormalClass* NormalClass::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   Class::ReadFrom(reader);
   TypeParameterScope<ReaderHelper> scope(reader->helper());
 
   type_parameters_.ReadFrom(reader);
   DartType* type = reader->ReadOptional<DartType>();
 
   super_class_ = InterfaceType::Cast(type);
+  reader->ReadOptional<DartType>();  // Mixed-in type is unused.
   implemented_classes_.ReadFromStatic<DowncastReader<DartType, InterfaceType> >(
       reader);
   fields_.ReadFrom<Field>(reader, this);
   constructors_.ReadFrom<Constructor>(reader, this);
   procedures_.ReadFrom<Procedure>(reader, this);
 
   return this;
 }
 
 
 MixinClass* MixinClass::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   TypeParameterScope<ReaderHelper> scope(reader->helper());
 
   Class::ReadFrom(reader);
   type_parameters_.ReadFrom(reader);
   first_ = InterfaceType::Cast(DartType::ReadFrom(reader));
   second_ = InterfaceType::Cast(DartType::ReadFrom(reader));
   implemented_classes_.ReadFromStatic<DowncastReader<DartType, InterfaceType> >(
       reader);
   constructors_.ReadFrom<Constructor>(reader, this);
   return this;
 }
 
 
-Member* Reference::ReadMemberFrom(Reader* reader, bool allow_null) {
+CanonicalName* Reference::ReadMemberFrom(Reader* reader, bool allow_null) {
   TRACE_READ_OFFSET();
 
-  Program* program = reader->helper()->program();
-  Tag tag = reader->ReadTag();
-  switch (tag) {
-    case kLibraryFieldReference: {
-      int library_idx = reader->ReadUInt();
-      int field_idx = reader->ReadUInt();
-      Library* library = program->libraries().GetOrCreate<Library>(library_idx);
-      return library->fields().GetOrCreate<Field>(field_idx, library);
-    }
-    case kLibraryProcedureReference: {
-      int library_idx = reader->ReadUInt();
-      int procedure_idx = reader->ReadUInt();
-      Library* library = program->libraries().GetOrCreate<Library>(library_idx);
-      return library->procedures().GetOrCreate<Procedure>(procedure_idx,
-                                                          library);
-    }
-    case kClassFieldReference:
-    case kClassConstructorReference:
-    case kClassProcedureReference: {
-      Class* klass = Reference::ReadClassFrom(reader);
-      if (tag == kClassFieldReference) {
-        int field_idx = reader->ReadUInt();
-        return klass->fields().GetOrCreate<Field>(field_idx, klass);
-      } else if (tag == kClassConstructorReference) {
-        int constructor_idx = reader->ReadUInt();
-        return klass->constructors().GetOrCreate<Constructor>(constructor_idx,
-                                                              klass);
-      } else {
-        ASSERT(tag == kClassProcedureReference);
-        int procedure_idx = reader->ReadUInt();
-        return klass->procedures().GetOrCreate<Procedure>(procedure_idx, klass);
-      }
-    }
-    case kNullReference:
-      if (allow_null) {
-        return NULL;
-      } else {
-        FATAL("Expected a valid member reference, but got `null`");
-      }
-    default:
-      UNREACHABLE();
-      break;
+  CanonicalName* canonical_name = reader->ReadCanonicalNameReference();
+  if (canonical_name == NULL && !allow_null) {
+    FATAL("Expected a valid member reference, but got `null`");
   }
 
-  UNREACHABLE();
-  return NULL;
+  if (canonical_name != NULL) {
+    canonical_name->set_referenced(true);
+  }
+
+  return canonical_name;
 }
 
 
-Class* Reference::ReadClassFrom(Reader* reader, bool allow_null) {
+CanonicalName* Reference::ReadClassFrom(Reader* reader, bool allow_null) {
   TRACE_READ_OFFSET();
-  Program* program = reader->helper()->program();
 
-  Tag klass_member_tag = reader->ReadTag();
-  if (klass_member_tag == kNullReference) {
-    if (allow_null) {
-      return NULL;
-    } else {
-      FATAL("Expected a valid class reference but got `null`.");
-    }
+  CanonicalName* canonical_name = reader->ReadCanonicalNameReference();
+  if (canonical_name == NULL && !allow_null) {
+    FATAL("Expected a valid class reference, but got `null`");
   }
-  int library_idx = reader->ReadUInt();
-  int class_idx = reader->ReadUInt();
 
-  Library* library = program->libraries().GetOrCreate<Library>(library_idx);
-  Class* klass;
-  if (klass_member_tag == kNormalClassReference) {
-    klass = library->classes().GetOrCreate<NormalClass>(class_idx, library);
-  } else {
-    ASSERT(klass_member_tag == kMixinClassReference);
-    klass = library->classes().GetOrCreate<MixinClass>(class_idx, library);
+  if (canonical_name != NULL) {
+    canonical_name->set_referenced(true);
   }
-  return klass;
+
+  return canonical_name;
 }
 
 
 String* Reference::ReadStringFrom(Reader* reader) {
   int index = reader->ReadUInt();
   return reader->helper()->program()->string_table().strings()[index];
 }
 
 
 Field* Field::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   Tag tag = reader->ReadTag();
   ASSERT(tag == kField);
 
+  reader->ReadDefiningCanonicalNameReference(this);
   position_ = reader->ReadPosition(false);
   end_position_ = reader->ReadPosition(false);
   flags_ = reader->ReadFlags();
   name_ = Name::ReadFrom(reader);
   source_uri_index_ = reader->ReadUInt();
   reader->set_current_script_id(source_uri_index_);
   reader->record_token_position(position_);
   reader->record_token_position(end_position_);
   annotations_.ReadFromStatic<Expression>(reader);
   type_ = DartType::ReadFrom(reader);
   inferred_value_ = reader->ReadOptional<InferredValue>();
   initializer_ = reader->ReadOptional<Expression>();
   return this;
 }
 
 
 Constructor* Constructor::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   Tag tag = reader->ReadTag();
   ASSERT(tag == kConstructor);
 
+  reader->ReadDefiningCanonicalNameReference(this);
   VariableScope<ReaderHelper> parameters(reader->helper());
   position_ = reader->ReadPosition();
   end_position_ = reader->ReadPosition();
   flags_ = reader->ReadFlags();
   name_ = Name::ReadFrom(reader);
   annotations_.ReadFromStatic<Expression>(reader);
   function_ = FunctionNode::ReadFrom(reader);
   initializers_.ReadFromStatic<Initializer>(reader);
   return this;
 }
 
 
 Procedure* Procedure::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   Tag tag = reader->ReadTag();
   ASSERT(tag == kProcedure);
 
+  reader->ReadDefiningCanonicalNameReference(this);
   VariableScope<ReaderHelper> parameters(reader->helper());
   position_ = reader->ReadPosition(false);
   end_position_ = reader->ReadPosition(false);
   kind_ = static_cast<ProcedureKind>(reader->ReadByte());
   flags_ = reader->ReadFlags();
   name_ = Name::ReadFrom(reader);
   source_uri_index_ = reader->ReadUInt();
   reader->set_current_script_id(source_uri_index_);
   reader->record_token_position(position_);
   reader->record_token_position(end_position_);
@@ skipping 26 matching lines @@
 
 InvalidInitializer* InvalidInitializer::ReadFromImpl(Reader* reader) {
   TRACE_READ_OFFSET();
   return new InvalidInitializer();
 }
 
 
 FieldInitializer* FieldInitializer::ReadFromImpl(Reader* reader) {
   TRACE_READ_OFFSET();
   FieldInitializer* initializer = new FieldInitializer();
-  initializer->field_ = Field::Cast(Reference::ReadMemberFrom(reader));
+  initializer->field_reference_ = Reference::ReadMemberFrom(reader);
   initializer->value_ = Expression::ReadFrom(reader);
   return initializer;
 }
 
 
 SuperInitializer* SuperInitializer::ReadFromImpl(Reader* reader) {
   TRACE_READ_OFFSET();
   SuperInitializer* init = new SuperInitializer();
-  init->target_ = Constructor::Cast(Reference::ReadMemberFrom(reader));
+  init->target_reference_ = Reference::ReadMemberFrom(reader);
   init->arguments_ = Arguments::ReadFrom(reader);
   return init;
 }
 
 
 RedirectingInitializer* RedirectingInitializer::ReadFromImpl(Reader* reader) {
   TRACE_READ_OFFSET();
   RedirectingInitializer* init = new RedirectingInitializer();
-  init->target_ = Constructor::Cast(Reference::ReadMemberFrom(reader));
+  init->target_reference_ = Reference::ReadMemberFrom(reader);
   init->arguments_ = Arguments::ReadFrom(reader);
   return init;
 }
 
 
 LocalInitializer* LocalInitializer::ReadFromImpl(Reader* reader) {
   TRACE_READ_OFFSET();
   LocalInitializer* init = new LocalInitializer();
   init->variable_ = VariableDeclaration::ReadFromImpl(reader);
   return init;
@@ skipping 144 matching lines @@
   return set;
 }
 
 
 PropertyGet* PropertyGet::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   PropertyGet* get = new PropertyGet();
   get->position_ = reader->ReadPosition();
   get->receiver_ = Expression::ReadFrom(reader);
   get->name_ = Name::ReadFrom(reader);
-  get->interfaceTarget_ = Reference::ReadMemberFrom(reader, true);
+  get->interface_target_reference_ = Reference::ReadMemberFrom(reader, true);
   return get;
 }
 
 
 PropertySet* PropertySet::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   PropertySet* set = new PropertySet();
   set->position_ = reader->ReadPosition();
   set->receiver_ = Expression::ReadFrom(reader);
   set->name_ = Name::ReadFrom(reader);
   set->value_ = Expression::ReadFrom(reader);
-  set->interfaceTarget_ = Reference::ReadMemberFrom(reader, true);
+  set->interface_target_reference_ = Reference::ReadMemberFrom(reader, true);
   return set;
 }
 
 
 DirectPropertyGet* DirectPropertyGet::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   DirectPropertyGet* get = new DirectPropertyGet();
   get->receiver_ = Expression::ReadFrom(reader);
-  get->target_ = Reference::ReadMemberFrom(reader);
+  get->target_reference_ = Reference::ReadMemberFrom(reader);
   return get;
 }
 
 
 DirectPropertySet* DirectPropertySet::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   DirectPropertySet* set = new DirectPropertySet();
   set->receiver_ = Expression::ReadFrom(reader);
-  set->target_ = Reference::ReadMemberFrom(reader);
+  set->target_reference_ = Reference::ReadMemberFrom(reader);
   set->value_ = Expression::ReadFrom(reader);
   return set;
 }
 
 
 StaticGet* StaticGet::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   StaticGet* get = new StaticGet();
   get->position_ = reader->ReadPosition();
-  get->target_ = Reference::ReadMemberFrom(reader);
+  get->target_reference_ = Reference::ReadMemberFrom(reader);
   return get;
 }
 
 
 StaticSet* StaticSet::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   StaticSet* set = new StaticSet();
-  set->target_ = Reference::ReadMemberFrom(reader);
+  set->target_reference_ = Reference::ReadMemberFrom(reader);
   set->expression_ = Expression::ReadFrom(reader);
   return set;
 }
 
 
 Arguments* Arguments::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   Arguments* arguments = new Arguments();
   arguments->types().ReadFromStatic<DartType>(reader);
   arguments->positional().ReadFromStatic<Expression>(reader);
@@ skipping 10 matching lines @@
 }
 
 
 MethodInvocation* MethodInvocation::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   MethodInvocation* invocation = new MethodInvocation();
   invocation->position_ = reader->ReadPosition();
   invocation->receiver_ = Expression::ReadFrom(reader);
   invocation->name_ = Name::ReadFrom(reader);
   invocation->arguments_ = Arguments::ReadFrom(reader);
-  invocation->interfaceTarget_ = Reference::ReadMemberFrom(reader, true);
+  invocation->interface_target_reference_ =
+      Reference::ReadMemberFrom(reader, true);
   return invocation;
 }
 
 
 DirectMethodInvocation* DirectMethodInvocation::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   DirectMethodInvocation* invocation = new DirectMethodInvocation();
   invocation->receiver_ = Expression::ReadFrom(reader);
-  invocation->target_ = Procedure::Cast(Reference::ReadMemberFrom(reader));
+  invocation->target_reference_ = Reference::ReadMemberFrom(reader);
   invocation->arguments_ = Arguments::ReadFrom(reader);
   return invocation;
 }
 
 
 StaticInvocation* StaticInvocation::ReadFrom(Reader* reader, bool is_const) {
   TRACE_READ_OFFSET();
   StaticInvocation* invocation = new StaticInvocation();
   invocation->is_const_ = is_const;
   invocation->position_ = reader->ReadPosition();
-  invocation->procedure_ = Procedure::Cast(Reference::ReadMemberFrom(reader));
+  invocation->procedure_reference_ = Reference::ReadMemberFrom(reader);
   invocation->arguments_ = Arguments::ReadFrom(reader);
   return invocation;
 }
 
 
 ConstructorInvocation* ConstructorInvocation::ReadFrom(Reader* reader,
                                                        bool is_const) {
   TRACE_READ_OFFSET();
   ConstructorInvocation* invocation = new ConstructorInvocation();
   invocation->is_const_ = is_const;
   invocation->position_ = reader->ReadPosition();
-  invocation->target_ = Constructor::Cast(Reference::ReadMemberFrom(reader));
+  invocation->target_reference_ = Reference::ReadMemberFrom(reader);
   invocation->arguments_ = Arguments::ReadFrom(reader);
   return invocation;
 }
 
 
 Not* Not::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   Not* n = new Not();
   n->expression_ = Expression::ReadFrom(reader);
   return n;
@@ skipping 365 matching lines @@
 
 SwitchStatement* SwitchStatement::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   SwitchCaseScope<ReaderHelper> scope(reader->helper());
   SwitchStatement* stmt = new SwitchStatement();
   stmt->condition_ = Expression::ReadFrom(reader);
   // We need to explicitly create empty [SwitchCase]s first in order to add them
   // to the [SwitchCaseScope]. This is necessary since a [Statement] in a switch
   // case can refer to one defined later on.
   int count = reader->ReadUInt();
-  for (int i = 0; i < count; i++) {
+  for (intptr_t i = 0; i < count; i++) {
     SwitchCase* sc = stmt->cases_.GetOrCreate<SwitchCase>(i);
     reader->helper()->switch_cases().Push(sc);
   }
-  for (int i = 0; i < count; i++) {
+  for (intptr_t i = 0; i < count; i++) {
     SwitchCase* sc = stmt->cases_[i];
     sc->ReadFrom(reader);
   }
   return stmt;
 }
 
 
 SwitchCase* SwitchCase::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   expressions_.ReadFromStatic<Expression>(reader);
@@ skipping 120 matching lines @@
   decl->variable_ = VariableDeclaration::ReadFromImpl(reader);
   VariableScope<ReaderHelper> parameters(reader->helper());
   decl->function_ = FunctionNode::ReadFrom(reader);
   return decl;
 }
 
 
 Name* Name::ReadFrom(Reader* reader) {
   String* string = Reference::ReadStringFrom(reader);
   if (string->size() >= 1 && string->buffer()[0] == '_') {
-    int lib_index = reader->ReadUInt();
-    Library* library =
-        reader->helper()->program()->libraries().GetOrCreate<Library>(
-            lib_index);
-    return new Name(string, library);
+    CanonicalName* library_reference = reader->ReadCanonicalNameReference();
+    return new Name(string, library_reference);
   } else {
     return new Name(string, NULL);
   }
 }
 
 
 InferredValue* InferredValue::ReadFrom(Reader* reader) {
   InferredValue* type = new InferredValue();
-  type->klass_ = Reference::ReadClassFrom(reader, true);
+  type->klass_reference_ = Reference::ReadClassFrom(reader, true);
   type->kind_ = static_cast<BaseClassKind>(reader->ReadByte());
   type->value_bits_ = reader->ReadByte();
   return type;
 }
 
 
 DartType* DartType::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   Tag tag = reader->ReadTag();
   switch (tag) {
@@ skipping 34 matching lines @@
 
 
 VoidType* VoidType::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   return new VoidType();
 }
 
 
 InterfaceType* InterfaceType::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
-  Class* klass = Reference::ReadClassFrom(reader);
-  InterfaceType* type = new InterfaceType(klass);
+  CanonicalName* klass_name = Reference::ReadClassFrom(reader);
+  InterfaceType* type = new InterfaceType(klass_name);
   type->type_arguments().ReadFromStatic<DartType>(reader);
   return type;
 }
 
 
 InterfaceType* InterfaceType::ReadFrom(Reader* reader,
                                        bool _without_type_arguments_) {
   TRACE_READ_OFFSET();
-  Class* klass = Reference::ReadClassFrom(reader);
-  InterfaceType* type = new InterfaceType(klass);
+  CanonicalName* klass_name = Reference::ReadClassFrom(reader);
+  InterfaceType* type = new InterfaceType(klass_name);
   ASSERT(_without_type_arguments_);
   return type;
 }
 
 
 FunctionType* FunctionType::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   FunctionType* type = new FunctionType();
   TypeParameterScope<ReaderHelper> scope(reader->helper());
   type->type_parameters().ReadFrom(reader);
@@ skipping 24 matching lines @@
   return type;
 }
 
 
 Program* Program::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   uint32_t magic = reader->ReadUInt32();
   if (magic != kMagicProgramFile) FATAL("Invalid magic identifier");
 
   Program* program = new Program();
+  program->canonical_name_root_ = CanonicalName::NewRoot();
   reader->helper()->set_program(program);
 
   program->string_table_.ReadFrom(reader);
   program->source_uri_table_.ReadFrom(reader);
   program->source_table_.ReadFrom(reader);
 
+  int canonical_names = reader->ReadUInt();
+  reader->helper()->SetCanonicalNameCount(canonical_names);
+  for (int i = 0; i < canonical_names; ++i) {
+    int biased_parent_index = reader->ReadUInt();
+    CanonicalName* parent;
+    if (biased_parent_index != 0) {
+      parent = reader->helper()->GetCanonicalName(biased_parent_index - 1);
+    } else {
+      parent = program->canonical_name_root();
+    }
+    ASSERT(parent != NULL);
+    int name_index = reader->ReadUInt();
+    String* name = program->string_table().strings()[name_index];
+    CanonicalName* canonical_name = parent->AddChild(name);
+    reader->helper()->SetCanonicalName(i, canonical_name);
+  }
+
   int libraries = reader->ReadUInt();
   program->libraries().EnsureInitialized(libraries);
-  for (int i = 0; i < libraries; i++) {
+  for (intptr_t i = 0; i < libraries; i++) {
     program->libraries().GetOrCreate<Library>(i)->ReadFrom(reader);
   }
 
-  program->main_method_ = Procedure::Cast(Reference::ReadMemberFrom(reader));
+  program->main_method_reference_ = Reference::ReadMemberFrom(reader);
+
+#ifdef DEBUG
+  for (intptr_t i = 0; i < canonical_names; ++i) {
+    CanonicalName* name = reader->helper()->GetCanonicalName(i);
+    if (name->is_referenced() && name->definition() == NULL) {
+      FATAL("Missing definition for canonical name");
+    }
+  }
+#endif
 
   return program;
 }
 
 
 FunctionNode* FunctionNode::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   TypeParameterScope<ReaderHelper> scope(reader->helper());
 
   FunctionNode* function = new FunctionNode();
@@ skipping 31 matching lines @@
 
 kernel::Program* ReadPrecompiledKernelFromBuffer(const uint8_t* buffer,
                                                  intptr_t buffer_length) {
   kernel::Reader reader(buffer, buffer_length);
   return kernel::Program::ReadFrom(&reader);
 }
 
 
 }  // namespace dart
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)