Implement canonical name scheme in kernel.

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 339 matching lines @@
   virtual Node::NodeType Type() { return Node::kType##klass; }
 
 #define DEFINE_IS_OPERATION(klass)                                             \
   virtual bool Is##klass() { return false; }
 
 #define DEFINE_ALL_IS_OPERATIONS()                                             \
   KERNEL_NODES_DO(DEFINE_IS_OPERATION)                                         \
   DEFINE_IS_OPERATION(TreeNode)                                                \
   KERNEL_TREE_NODES_DO(DEFINE_IS_OPERATION)
 
+class Class;
+class Constructor;
+class Field;
+class Library;
+class LinkedNode;
+class Member;
+class Procedure;
+
+class CanonicalName {
+ public:
+  ~CanonicalName();
+
+  String* name() { return name_; }
+  CanonicalName* parent() { return parent_; }
+  LinkedNode* definition() { return definition_; }
+  bool is_referenced() { return is_referenced_; }
+  void set_referenced(bool referenced) { is_referenced_ = referenced; }
+
+  void BindTo(LinkedNode* definition);
+  void Unbind();
+  CanonicalName* AddChild(String* name);
+
+  Library* AsLibrary();
+  Class* AsClass();
+  Member* AsMember();
+  Field* AsField();
+  Constructor* AsConstructor();
+  Procedure* AsProcedure();
+
+  static CanonicalName* NewRoot();
+
+ private:
+  CanonicalName();
+
+  bool is_referenced_;
+  Ref<CanonicalName> parent_;
+  Ref<String> name_;
+  Ref<LinkedNode> definition_;
+  MallocGrowableArray<CanonicalName*> children_;
+
+  DISALLOW_COPY_AND_ASSIGN(CanonicalName);
+};
+
 
 class Node {
  public:
   virtual ~Node();
 
   enum NodeType {
 #define DO(name) kType##name,
     KERNEL_ALL_NODES_DO(DO)
 #undef DO
 
@@ skipping 24 matching lines @@
   virtual void AcceptTreeVisitor(TreeVisitor* visitor) = 0;
 
  protected:
   TreeNode() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TreeNode);
 };
 
 
-class Library : public TreeNode {
+class LinkedNode : public TreeNode {
+ public:
+  virtual ~LinkedNode();
+
+  CanonicalName* canonical_name() { return canonical_name_; }
+
+ protected:
+  LinkedNode() {}
+
+ private:
+  Ref<CanonicalName> canonical_name_;
+
+  friend class CanonicalName;
+
+  DISALLOW_COPY_AND_ASSIGN(LinkedNode);
+};
+
+
+class Library : public LinkedNode {
  public:
   Library* ReadFrom(Reader* reader);
 
   virtual ~Library();
 
   DEFINE_CASTING_OPERATIONS(Library);
 
   virtual void AcceptTreeVisitor(TreeVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
@@ skipping 36 matching lines @@
   Ref<String> import_uri_;
   intptr_t source_uri_index_;
   List<Class> classes_;
   List<Field> fields_;
   List<Procedure> procedures_;
 
   DISALLOW_COPY_AND_ASSIGN(Library);
 };
 
 
-class Class : public TreeNode {
+class Class : public LinkedNode {
  public:
   Class* ReadFrom(Reader* reader);
 
   virtual ~Class();
 
   DEFINE_CASTING_OPERATIONS(Class);
 
   virtual void AcceptTreeVisitor(TreeVisitor* visitor);
   virtual void AcceptClassVisitor(ClassVisitor* visitor) = 0;
   virtual void AcceptReferenceVisitor(ClassReferenceVisitor* visitor) = 0;
@@ skipping 102 matching lines @@
   List<Constructor> constructors_;
 
   // Dummy instances which are empty lists.
   List<Field> fields_;
   List<Procedure> procedures_;
 
   DISALLOW_COPY_AND_ASSIGN(MixinClass);
 };
 
 
-class Member : public TreeNode {
+class Member : public LinkedNode {
  public:
   virtual ~Member();
 
   DEFINE_CASTING_OPERATIONS(Member);
 
   virtual void AcceptTreeVisitor(TreeVisitor* visitor);
   virtual void AcceptMemberVisitor(MemberVisitor* visitor) = 0;
   virtual void AcceptReferenceVisitor(MemberReferenceVisitor* visitor) = 0;
 
   TreeNode* parent() { return parent_; }
@@ skipping 195 matching lines @@
  public:
   static FieldInitializer* ReadFromImpl(Reader* reader);
 
   virtual ~FieldInitializer();
 
   DEFINE_CASTING_OPERATIONS(FieldInitializer);
 
   virtual void AcceptInitializerVisitor(InitializerVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
-  Field* field() { return field_; }
+  Field* field() { return field_reference_->AsField(); }
   Expression* value() { return value_; }
 
  private:
   FieldInitializer() {}
 
-  Ref<Field> field_;
+  Ref<CanonicalName> field_reference_;
   Child<Expression> value_;
 
   DISALLOW_COPY_AND_ASSIGN(FieldInitializer);
 };
 
 
 class SuperInitializer : public Initializer {
  public:
   static SuperInitializer* ReadFromImpl(Reader* reader);
 
   virtual ~SuperInitializer();
 
   DEFINE_CASTING_OPERATIONS(SuperInitializer);
 
   virtual void AcceptInitializerVisitor(InitializerVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
-  Constructor* target() { return target_; }
+  Constructor* target() { return target_reference_->AsConstructor(); }
   Arguments* arguments() { return arguments_; }
 
  private:
   SuperInitializer() {}
 
-  Ref<Constructor> target_;
+  Ref<CanonicalName> target_reference_;
   Child<Arguments> arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(SuperInitializer);
 };
 
 
 class RedirectingInitializer : public Initializer {
  public:
   static RedirectingInitializer* ReadFromImpl(Reader* reader);
 
   virtual ~RedirectingInitializer();
 
   DEFINE_CASTING_OPERATIONS(RedirectingInitializer);
 
   virtual void AcceptInitializerVisitor(InitializerVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
-  Constructor* target() { return target_; }
+  Constructor* target() { return target_reference_->AsConstructor(); }
   Arguments* arguments() { return arguments_; }
 
  private:
   RedirectingInitializer() {}
 
-  Ref<Constructor> target_;
+  Ref<CanonicalName> target_reference_;
   Child<Arguments> arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(RedirectingInitializer);
 };
 
 
 class LocalInitializer : public Initializer {
  public:
   static LocalInitializer* ReadFromImpl(Reader* reader);
 
@@ skipping 168 matching lines @@
   virtual void VisitChildren(Visitor* visitor);
 
   Expression* receiver() { return receiver_; }
   Name* name() { return name_; }
 
  private:
   PropertyGet() {}
 
   Child<Expression> receiver_;
   Child<Name> name_;
-  Ref<Member> interfaceTarget_;
+  Ref<CanonicalName> interface_target_reference_;
 
   DISALLOW_COPY_AND_ASSIGN(PropertyGet);
 };
 
 
 class PropertySet : public Expression {
  public:
   static PropertySet* ReadFrom(Reader* reader);
 
   virtual ~PropertySet();
 
   DEFINE_CASTING_OPERATIONS(PropertySet);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   Expression* receiver() { return receiver_; }
   Name* name() { return name_; }
   Expression* value() { return value_; }
 
  private:
   PropertySet() {}
 
   Child<Expression> receiver_;
   Child<Name> name_;
   Child<Expression> value_;
-  Ref<Member> interfaceTarget_;
+  Ref<CanonicalName> interface_target_reference_;
 
   DISALLOW_COPY_AND_ASSIGN(PropertySet);
 };
 
 
 class DirectPropertyGet : public Expression {
  public:
   static DirectPropertyGet* ReadFrom(Reader* reader);
 
   virtual ~DirectPropertyGet();
 
   DEFINE_CASTING_OPERATIONS(DirectPropertyGet);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   Expression* receiver() { return receiver_; }
-  Member* target() { return target_; }
+  Member* target() { return target_reference_->AsMember(); }
 
  private:
   DirectPropertyGet() {}
 
   Child<Expression> receiver_;
-  Ref<Member> target_;
+  Ref<CanonicalName> target_reference_;
 
   DISALLOW_COPY_AND_ASSIGN(DirectPropertyGet);
 };
 
 
 class DirectPropertySet : public Expression {
  public:
   static DirectPropertySet* ReadFrom(Reader* reader);
 
   virtual ~DirectPropertySet();
 
   DEFINE_CASTING_OPERATIONS(DirectPropertySet);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   Expression* receiver() { return receiver_; }
-  Member* target() { return target_; }
+  Member* target() { return target_reference_->AsMember(); }
   Expression* value() { return value_; }
 
  private:
   DirectPropertySet() {}
 
   Child<Expression> receiver_;
-  Ref<Member> target_;
+  Ref<CanonicalName> target_reference_;
   Child<Expression> value_;
 
   DISALLOW_COPY_AND_ASSIGN(DirectPropertySet);
 };
 
 
 class StaticGet : public Expression {
  public:
   static StaticGet* ReadFrom(Reader* reader);
 
   virtual ~StaticGet();
 
   DEFINE_CASTING_OPERATIONS(StaticGet);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
-  Member* target() { return target_; }
+  Member* target() { return target_reference_->AsMember(); }
 
  private:
   StaticGet() {}
 
-  Ref<Member> target_;
+  Ref<CanonicalName> target_reference_;
 
   DISALLOW_COPY_AND_ASSIGN(StaticGet);
 };
 
 
 class StaticSet : public Expression {
  public:
   static StaticSet* ReadFrom(Reader* reader);
 
   virtual ~StaticSet();
 
   DEFINE_CASTING_OPERATIONS(StaticSet);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
-  Member* target() { return target_; }
+  Member* target() { return target_reference_->AsMember(); }
   Expression* expression() { return expression_; }
 
  private:
   StaticSet() {}
 
-  Ref<Member> target_;
+  Ref<CanonicalName> target_reference_;
   Child<Expression> expression_;
 
   DISALLOW_COPY_AND_ASSIGN(StaticSet);
 };
 
 
 class Arguments : public TreeNode {
  public:
   static Arguments* ReadFrom(Reader* reader);
 
@@ skipping 61 matching lines @@
   Expression* receiver() { return receiver_; }
   Name* name() { return name_; }
   Arguments* arguments() { return arguments_; }
 
  private:
   MethodInvocation() {}
 
   Child<Expression> receiver_;
   Child<Name> name_;
   Child<Arguments> arguments_;
-  Ref<Member> interfaceTarget_;
+  Ref<CanonicalName> interface_target_reference_;
 
   DISALLOW_COPY_AND_ASSIGN(MethodInvocation);
 };
 
 
 class DirectMethodInvocation : public Expression {
  public:
   static DirectMethodInvocation* ReadFrom(Reader* reader);
 
   virtual ~DirectMethodInvocation();
 
   DEFINE_CASTING_OPERATIONS(DirectMethodInvocation);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   Expression* receiver() { return receiver_; }
-  Procedure* target() { return target_; }
+  Procedure* target() { return target_reference_->AsProcedure(); }
   Arguments* arguments() { return arguments_; }
 
  private:
   DirectMethodInvocation() {}
 
   Child<Expression> receiver_;
-  Ref<Procedure> target_;
+  Ref<CanonicalName> target_reference_;
   Child<Arguments> arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(DirectMethodInvocation);
 };
 
 
 class StaticInvocation : public Expression {
  public:
   static StaticInvocation* ReadFrom(Reader* reader, bool is_const);
   ~StaticInvocation();
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
-  Procedure* procedure() { return procedure_; }
+  Procedure* procedure() { return procedure_reference_->AsProcedure(); }
   Arguments* arguments() { return arguments_; }
   bool is_const() { return is_const_; }
 
  private:
   StaticInvocation() {}
 
-  Ref<Procedure> procedure_;
+  Ref<CanonicalName> procedure_reference_;
   Child<Arguments> arguments_;
   bool is_const_;
 
   DISALLOW_COPY_AND_ASSIGN(StaticInvocation);
 };
 
 
 class ConstructorInvocation : public Expression {
  public:
   static ConstructorInvocation* ReadFrom(Reader* reader, bool is_const);
 
   virtual ~ConstructorInvocation();
 
   DEFINE_CASTING_OPERATIONS(ConstructorInvocation);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   bool is_const() { return is_const_; }
-  Constructor* target() { return target_; }
+  Constructor* target() { return target_reference_->AsConstructor(); }
   Arguments* arguments() { return arguments_; }
 
  private:
   ConstructorInvocation() {}
 
   bool is_const_;
-  Ref<Constructor> target_;
+  Ref<CanonicalName> target_reference_;
   Child<Arguments> arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(ConstructorInvocation);
 };
 
 
 class Not : public Expression {
  public:
   static Not* ReadFrom(Reader* reader);
 
@@ skipping 1125 matching lines @@
   static Name* ReadFrom(Reader* reader);
 
   virtual ~Name();
 
   DEFINE_CASTING_OPERATIONS(Name);
 
   virtual void AcceptVisitor(Visitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   String* string() { return string_; }
-  Library* library() { return library_; }
+  Library* library() {
+    if (library_reference_ == NULL) return NULL;
+    return library_reference_->AsLibrary();
+  }
 
  private:
-  Name(String* string, Library* library)
-      : string_(string), library_(library) {}  // NOLINT
+  Name(String* string, CanonicalName* library_reference)
+      : string_(string), library_reference_(library_reference) {}  // NOLINT
 
   Ref<String> string_;
-  Ref<Library> library_;
+  Ref<CanonicalName> library_reference_;
 
   DISALLOW_COPY_AND_ASSIGN(Name);
 };
 
 
 class InferredValue : public Node {
  public:
   static const uint8_t kNull = 1 << 0;
   static const uint8_t kInteger = 1 << 1;
   static const uint8_t kDouble = 1 << 2;
@@ skipping 23 matching lines @@
   bool CanBeNull() { return (value_bits_ & kNull) != 0; }
   bool CanBeInteger() { return (value_bits_ & kInteger) != 0; }
   bool CanBeDouble() { return (value_bits_ & kDouble) != 0; }
   bool CanBeString() { return (value_bits_ & kString) != 0; }
 
   bool IsAlwaysNull() { return value_bits_ == kNull; }
   bool IsAlwaysInteger() { return value_bits_ == kInteger; }
   bool IsAlwaysDouble() { return value_bits_ == kDouble; }
   bool IsAlwaysString() { return value_bits_ == kString; }
 
-  Class* klass() { return klass_; }
+  Class* klass() { return klass_reference_->AsClass(); }
   BaseClassKind kind() { return kind_; }
   uint8_t value_bits() { return value_bits_; }
 
  private:
   InferredValue() {}
 
-  Ref<Class> klass_;
+  Ref<CanonicalName> klass_reference_;
   BaseClassKind kind_;
   uint8_t value_bits_;
 
   DISALLOW_COPY_AND_ASSIGN(InferredValue);
 };
 
 
 class DartType : public Node {
  public:
   static DartType* ReadFrom(Reader* reader);
@@ skipping 65 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(Class* klass) : klass_(klass) {}
+  explicit InterfaceType(CanonicalName* klass_reference)
+      : klass_reference_(klass_reference) {}
   virtual ~InterfaceType();
 
   DEFINE_CASTING_OPERATIONS(InterfaceType);
 
   virtual void AcceptDartTypeVisitor(DartTypeVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
-  Class* klass() { return klass_; }
+  Class* klass() { return klass_reference_->AsClass(); }
   List<DartType>& type_arguments() { return type_arguments_; }
 
  private:
   InterfaceType() {}
 
-  Ref<Class> klass_;
+  Ref<CanonicalName> klass_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 84 matching lines @@
 
   DEFINE_CASTING_OPERATIONS(Program);
 
   virtual void AcceptTreeVisitor(TreeVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   StringTable& string_table() { return string_table_; }
   StringTable& source_uri_table() { return source_uri_table_; }
   SourceTable& source_table() { return source_table_; }
   List<Library>& libraries() { return libraries_; }
-  Procedure* main_method() { return main_method_; }
+  Procedure* main_method() {
+    if (main_method_reference_ == NULL) return NULL;
+    return main_method_reference_->AsProcedure();
+  }
+  CanonicalName* canonical_name_root() { return canonical_name_root_; }
   MallocGrowableArray<MallocGrowableArray<intptr_t>*> valid_token_positions;
   MallocGrowableArray<MallocGrowableArray<intptr_t>*> yield_token_positions;
 
  private:
   Program() {}
 
+  Child<CanonicalName> canonical_name_root_;
   List<Library> libraries_;
-  Ref<Procedure> main_method_;
+  Ref<CanonicalName> main_method_reference_;
   StringTable string_table_;
   StringTable source_uri_table_;
   SourceTable source_table_;
 
   DISALLOW_COPY_AND_ASSIGN(Program);
 };
 
 
 class Reference : public AllStatic {
  public:
-  static Member* ReadMemberFrom(Reader* reader, bool allow_null = false);
+  static CanonicalName* ReadMemberFrom(Reader* reader, bool allow_null = false);
 
-  static Class* ReadClassFrom(Reader* reader, bool allow_null = false);
+  static CanonicalName* ReadClassFrom(Reader* reader, bool allow_null = false);
 
   static String* ReadStringFrom(Reader* reader);
 };
 
 
 class ExpressionVisitor {
  public:
   virtual ~ExpressionVisitor() {}
 
   virtual void VisitDefaultExpression(Expression* node) = 0;
@@ skipping 405 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_