Remove definitions from Kernel canonical names.

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 100 matching lines @@
   M(TreeNode)                                                                  \
   KERNEL_TREE_NODES_DO(M)
 
 #define KERNEL_VISITORS_DO(M)                                                  \
   M(ExpressionVisitor)                                                         \
   M(StatementVisitor)                                                          \
   M(MemberVisitor)                                                             \
   M(ClassVisitor)                                                              \
   M(InitializerVisitor)                                                        \
   M(DartTypeVisitor)                                                           \
-  M(ClassReferenceVisitor)                                                     \
-  M(MemberReferenceVisitor)                                                    \
   M(TreeVisitor)                                                               \
   M(Visitor)
 
 namespace dart {
 
 class Field;
 class ParsedFunction;
 class Zone;
 
 namespace kernel {
@@ skipping 230 matching lines @@
 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();
+  bool IsAdministrative();
+  bool IsPrivate();
+
+  bool IsRoot();
+  bool IsLibrary();
+  bool IsClass();
+  bool IsMember();
+  bool IsField();
+  bool IsConstructor();
+  bool IsProcedure();
+  bool IsMethod();
+  bool IsGetter();
+  bool IsSetter();
+  bool IsFactory();
+
+  // For a member (field, constructor, or procedure) return the canonical name
+  // of the enclosing class or library.
+  CanonicalName* EnclosingName();
 
   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();
 
@@ skipping 43 matching lines @@
 
 class LinkedNode : public TreeNode {
  public:
   virtual ~LinkedNode();
 
   CanonicalName* canonical_name() { return canonical_name_; }
 
  protected:
   LinkedNode() {}
 
- private:
   Ref<CanonicalName> canonical_name_;
 
+ private:
   friend class CanonicalName;
 
   DISALLOW_COPY_AND_ASSIGN(LinkedNode);
 };
 
 
 class Library : public LinkedNode {
  public:
   Library* ReadFrom(Reader* reader);
 
@@ skipping 53 matching lines @@
 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;
 
   Library* parent() { return parent_; }
   String* name() { return name_; }
   intptr_t source_uri_index() { return source_uri_index_; }
   bool is_abstract() { return is_abstract_; }
   List<Expression>& annotations() { return annotations_; }
   TokenPosition position() { return position_; }
 
   virtual List<TypeParameter>& type_parameters() = 0;
   virtual List<InterfaceType>& implemented_classes() = 0;
@@ skipping 21 matching lines @@
 
 class NormalClass : public Class {
  public:
   NormalClass* ReadFrom(Reader* reader);
 
   virtual ~NormalClass();
 
   DEFINE_CASTING_OPERATIONS(NormalClass);
 
   virtual void AcceptClassVisitor(ClassVisitor* visitor);
-  virtual void AcceptReferenceVisitor(ClassReferenceVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   virtual TypeParameterList& type_parameters() { return type_parameters_; }
   InterfaceType* super_class() { return super_class_; }
   virtual List<InterfaceType>& implemented_classes() {
     return implemented_classes_;
   }
   virtual List<Constructor>& constructors() { return constructors_; }
   virtual List<Procedure>& procedures() { return procedures_; }
   virtual List<Field>& fields() { return fields_; }
@@ skipping 17 matching lines @@
 
 class MixinClass : public Class {
  public:
   MixinClass* ReadFrom(Reader* reader);
 
   virtual ~MixinClass();
 
   DEFINE_CASTING_OPERATIONS(MixinClass);
 
   virtual void AcceptClassVisitor(ClassVisitor* visitor);
-  virtual void AcceptReferenceVisitor(ClassReferenceVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   virtual TypeParameterList& type_parameters() { return type_parameters_; }
   InterfaceType* first() { return first_; }
   InterfaceType* second() { return second_; }
   virtual List<InterfaceType>& implemented_classes() {
     return implemented_classes_;
   }
   virtual List<Constructor>& constructors() { return constructors_; }
   virtual List<Field>& fields() { return fields_; }
@@ skipping 20 matching lines @@
 
 
 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_; }
   Name* name() { return name_; }
   List<Expression>& annotations() { return annotations_; }
   TokenPosition position() { return position_; }
   TokenPosition end_position() { return end_position_; }
 
  protected:
   Member()
       : position_(TokenPosition::kNoSource),
@@ skipping 21 matching lines @@
     kFlagStatic = 1 << 2,
   };
 
   Field* ReadFrom(Reader* reader);
 
   virtual ~Field();
 
   DEFINE_CASTING_OPERATIONS(Field);
 
   virtual void AcceptMemberVisitor(MemberVisitor* visitor);
-  virtual void AcceptReferenceVisitor(MemberReferenceVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   bool IsConst() { return (flags_ & kFlagConst) == kFlagConst; }
   bool IsFinal() { return (flags_ & kFlagFinal) == kFlagFinal; }
   bool IsStatic() { return (flags_ & kFlagStatic) == kFlagStatic; }
   intptr_t source_uri_index() { return source_uri_index_; }
 
   DartType* type() { return type_; }
   Expression* initializer() { return initializer_; }
 
@@ skipping 19 matching lines @@
     kFlagExternal = 1 << 1,
   };
 
   Constructor* ReadFrom(Reader* reader);
 
   virtual ~Constructor();
 
   DEFINE_CASTING_OPERATIONS(Constructor);
 
   virtual void AcceptMemberVisitor(MemberVisitor* visitor);
-  virtual void AcceptReferenceVisitor(MemberReferenceVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   bool IsExternal() { return (flags_ & kFlagExternal) == kFlagExternal; }
   bool IsConst() { return (flags_ & kFlagConst) == kFlagConst; }
 
   FunctionNode* function() { return function_; }
   List<Initializer>& initializers() { return initializers_; }
 
  private:
   template <typename T>
@@ skipping 29 matching lines @@
     kIncompleteProcedure = 255
   };
 
   Procedure* ReadFrom(Reader* reader);
 
   virtual ~Procedure();
 
   DEFINE_CASTING_OPERATIONS(Procedure);
 
   virtual void AcceptMemberVisitor(MemberVisitor* visitor);
-  virtual void AcceptReferenceVisitor(MemberReferenceVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   ProcedureKind kind() { return kind_; }
   FunctionNode* function() { return function_; }
 
   bool IsStatic() { return (flags_ & kFlagStatic) == kFlagStatic; }
   bool IsAbstract() { return (flags_ & kFlagAbstract) == kFlagAbstract; }
   bool IsExternal() { return (flags_ & kFlagExternal) == kFlagExternal; }
   bool IsConst() { return (flags_ & kFlagConst) == kFlagConst; }
   intptr_t source_uri_index() { return source_uri_index_; }
@@ skipping 53 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_reference_->AsField(); }
+  CanonicalName* field() { return field_reference_; }
   Expression* value() { return value_; }
 
  private:
   FieldInitializer() {}
 
-  Ref<CanonicalName> field_reference_;
+  Ref<CanonicalName> field_reference_;  // Field.
   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_reference_->AsConstructor(); }
+  CanonicalName* target() { return target_reference_; }
   Arguments* arguments() { return arguments_; }
 
  private:
   SuperInitializer() {}
 
-  Ref<CanonicalName> target_reference_;
+  Ref<CanonicalName> target_reference_;  // Constructor.
   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_reference_->AsConstructor(); }
+  CanonicalName* target() { return target_reference_; }
   Arguments* arguments() { return arguments_; }
 
  private:
   RedirectingInitializer() {}
 
-  Ref<CanonicalName> target_reference_;
+  Ref<CanonicalName> target_reference_;  // Constructor.
   Child<Arguments> arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(RedirectingInitializer);
 };
 
 
 class LocalInitializer : public Initializer {
  public:
   static LocalInitializer* ReadFromImpl(Reader* reader);
 
@@ skipping 212 matching lines @@
   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_reference_->AsMember(); }
+  CanonicalName* target() { return target_reference_; }
 
  private:
   DirectPropertyGet() {}
 
   Child<Expression> receiver_;
-  Ref<CanonicalName> target_reference_;
+  Ref<CanonicalName> target_reference_;  // Member.
 
   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_reference_->AsMember(); }
+  CanonicalName* target() { return target_reference_; }
   Expression* value() { return value_; }
 
  private:
   DirectPropertySet() {}
 
   Child<Expression> receiver_;
-  Ref<CanonicalName> target_reference_;
+  Ref<CanonicalName> target_reference_;  // Member.
   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_reference_->AsMember(); }
+  CanonicalName* target() { return target_reference_; }
 
  private:
   StaticGet() {}
 
-  Ref<CanonicalName> target_reference_;
+  Ref<CanonicalName> target_reference_;  // Member.
 
   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_reference_->AsMember(); }
+  CanonicalName* target() { return target_reference_; }
   Expression* expression() { return expression_; }
 
  private:
   StaticSet() {}
 
-  Ref<CanonicalName> target_reference_;
+  Ref<CanonicalName> target_reference_;  // Member.
   Child<Expression> expression_;
 
   DISALLOW_COPY_AND_ASSIGN(StaticSet);
 };
 
 
 class Arguments : public TreeNode {
  public:
   static Arguments* ReadFrom(Reader* reader);
 
@@ skipping 79 matching lines @@
   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_reference_->AsProcedure(); }
+  CanonicalName* target() { return target_reference_; }
   Arguments* arguments() { return arguments_; }
 
  private:
   DirectMethodInvocation() {}
 
   Child<Expression> receiver_;
-  Ref<CanonicalName> target_reference_;
+  Ref<CanonicalName> target_reference_;  // Procedure.
   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_reference_->AsProcedure(); }
+  CanonicalName* procedure() { return procedure_reference_; }
   Arguments* arguments() { return arguments_; }
   bool is_const() { return is_const_; }
 
  private:
   StaticInvocation() {}
 
-  Ref<CanonicalName> procedure_reference_;
+  Ref<CanonicalName> procedure_reference_;  // Procedure.
   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_reference_->AsConstructor(); }
+  CanonicalName* target() { return target_reference_; }
   Arguments* arguments() { return arguments_; }
 
  private:
   ConstructorInvocation() {}
 
   bool is_const_;
-  Ref<CanonicalName> target_reference_;
+  Ref<CanonicalName> target_reference_;  // Constructor.
   Child<Arguments> arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(ConstructorInvocation);
 };
 
 
 class Not : public Expression {
  public:
   static Not* ReadFrom(Reader* reader);
 
@@ skipping 1128 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() {
-    if (library_reference_ == NULL) return NULL;
-    return library_reference_->AsLibrary();
-  }
-  CanonicalName* library_reference() { return library_reference_; }
+  CanonicalName* library() { return library_reference_; }
 
  private:
   Name(String* string, CanonicalName* library_reference)
       : string_(string), library_reference_(library_reference) {}  // NOLINT
 
   Ref<String> string_;
-  Ref<CanonicalName> library_reference_;
+  Ref<CanonicalName> library_reference_;  // Library.
 
   DISALLOW_COPY_AND_ASSIGN(Name);
 };
 
 
 class DartType : public Node {
  public:
   static DartType* ReadFrom(Reader* reader);
 
   virtual ~DartType();
@@ skipping 72 matching lines @@
 
   explicit InterfaceType(CanonicalName* class_reference)
       : class_reference_(class_reference) {}
   virtual ~InterfaceType();
 
   DEFINE_CASTING_OPERATIONS(InterfaceType);
 
   virtual void AcceptDartTypeVisitor(DartTypeVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
-  Class* klass() { return class_reference_->AsClass(); }
-  CanonicalName* class_reference() { return class_reference_; }
+  CanonicalName* klass() { return class_reference_; }
   List<DartType>& type_arguments() { return type_arguments_; }
 
  private:
   InterfaceType() {}
 
-  Ref<CanonicalName> class_reference_;
+  Ref<CanonicalName> class_reference_;  // Class.
   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() {
-    if (main_method_reference_ == NULL) return NULL;
-    return main_method_reference_->AsProcedure();
-  }
+  CanonicalName* main_method() { return main_method_reference_; }
   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<CanonicalName> main_method_reference_;
+  Ref<CanonicalName> main_method_reference_;  // Procedure.
   StringTable string_table_;
   StringTable source_uri_table_;
   SourceTable source_table_;
 
   DISALLOW_COPY_AND_ASSIGN(Program);
 };
 
 
 class Reference : public AllStatic {
  public:
@@ skipping 234 matching lines @@
   }
   virtual void VisitFunctionType(FunctionType* node) {
     VisitDefaultDartType(node);
   }
   virtual void VisitTypeParameterType(TypeParameterType* node) {
     VisitDefaultDartType(node);
   }
 };
 
 
-class ClassReferenceVisitor {
- public:
-  virtual ~ClassReferenceVisitor() {}
-
-  virtual void VisitDefaultClassReference(Class* node) = 0;
-  virtual void VisitNormalClassReference(NormalClass* node) {
-    VisitDefaultClassReference(node);
-  }
-  virtual void VisitMixinClassReference(MixinClass* node) {
-    VisitDefaultClassReference(node);
-  }
-};
-
-
-class MemberReferenceVisitor {
- public:
-  virtual ~MemberReferenceVisitor() {}
-
-  virtual void VisitDefaultMemberReference(Member* node) = 0;
-  virtual void VisitFieldReference(Field* node) {
-    VisitDefaultMemberReference(node);
-  }
-  virtual void VisitConstructorReference(Constructor* node) {
-    VisitDefaultMemberReference(node);
-  }
-  virtual void VisitProcedureReference(Procedure* node) {
-    VisitDefaultMemberReference(node);
-  }
-};
-
-
 class TreeVisitor : public ExpressionVisitor,
                     public StatementVisitor,
                     public MemberVisitor,
                     public ClassVisitor,
                     public InitializerVisitor {
  public:
   virtual ~TreeVisitor() {}
 
   virtual void VisitDefaultTreeNode(TreeNode* node) = 0;
   virtual void VisitDefaultStatement(Statement* node) {
@@ skipping 19 matching lines @@
   virtual void VisitNamedExpression(NamedExpression* node) {
     VisitDefaultTreeNode(node);
   }
   virtual void VisitSwitchCase(SwitchCase* node) { VisitDefaultTreeNode(node); }
   virtual void VisitCatch(Catch* node) { VisitDefaultTreeNode(node); }
   virtual void VisitMapEntry(MapEntry* node) { VisitDefaultTreeNode(node); }
   virtual void VisitProgram(Program* node) { VisitDefaultTreeNode(node); }
 };
 
 
-class Visitor : public TreeVisitor,
-                public DartTypeVisitor,
-                public ClassReferenceVisitor,
-                public MemberReferenceVisitor {
+class Visitor : public TreeVisitor, public DartTypeVisitor {
  public:
   virtual ~Visitor() {}
 
   virtual void VisitDefaultNode(Node* node) = 0;
   virtual void VisitDefaultTreeNode(TreeNode* node) { VisitDefaultNode(node); }
   virtual void VisitDefaultDartType(DartType* node) { VisitDefaultNode(node); }
   virtual void VisitName(Name* node) { VisitDefaultNode(node); }
   virtual void VisitDefaultClassReference(Class* node) {
     VisitDefaultNode(node);
   }
@@ skipping 87 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_