Revert "Remove definitions from Kernel canonical names."

runtime/vm/kernel.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 "vm/kernel.h"
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 namespace dart {
 
 namespace kernel {
@@ skipping 15 matching lines @@
     delete children_[i];
   }
 }
 
 
 CanonicalName* CanonicalName::NewRoot() {
   return new CanonicalName();
 }
 
 
+void CanonicalName::BindTo(LinkedNode* new_target) {
+  ASSERT(new_target != NULL);
+  if (definition_ == new_target) return;
+  ASSERT(definition_ == NULL);
+  ASSERT(new_target->canonical_name_ == NULL);
+  definition_ = new_target;
+  new_target->canonical_name_ = this;
+}
+
+
+void CanonicalName::Unbind() {
+  if (definition_ == NULL) return;
+  ASSERT(definition_->canonical_name_ == this);
+  definition_->canonical_name_ = NULL;
+  definition_ = NULL;
+}
+
+
 CanonicalName* CanonicalName::AddChild(String* name) {
   CanonicalName* child = new CanonicalName();
   child->parent_ = this;
   child->name_ = name;
   children_.Add(child);
   return child;
 }
 
 
-bool CanonicalName::IsAdministrative() {
-  // Administrative names start with '@'.
-  return (name()->size() > 0) && (name()->buffer()[0] == '@');
+Library* CanonicalName::AsLibrary() {
+  return Library::Cast(definition());
 }
 
 
-bool CanonicalName::IsPrivate() {
-  // Private names start with '_'.
-  return (name()->size() > 0) && (name()->buffer()[0] == '_');
+Class* CanonicalName::AsClass() {
+  return Class::Cast(definition());
 }
 
 
-bool CanonicalName::IsRoot() {
-  // The root is the only canonical name with no parent.
-  return parent() == NULL;
+Member* CanonicalName::AsMember() {
+  return Member::Cast(definition());
 }
 
 
-bool CanonicalName::IsLibrary() {
-  // Libraries are the only canonical names with the root as their parent.
-  return !IsRoot() && parent()->IsRoot();
+Field* CanonicalName::AsField() {
+  return Field::Cast(definition());
 }
 
 
-bool CanonicalName::IsClass() {
-  // Classes have the library as their parent and are not an administrative
-  // name starting with @.
-  return !IsAdministrative() && !IsRoot() && parent()->IsLibrary();
+Constructor* CanonicalName::AsConstructor() {
+  return Constructor::Cast(definition());
 }
 
 
-bool CanonicalName::IsMember() {
-  return IsConstructor() || IsField() || IsProcedure();
+Procedure* CanonicalName::AsProcedure() {
+  return Procedure::Cast(definition());
 }
 
 
-// Note the two occurrences of the parameter 'literal'.
-#define COMPARE_NAME(canonical_name, literal)                                  \
-  memcmp((canonical_name)->name()->buffer(), (literal), strlen(literal)) == 0
-
-bool CanonicalName::IsField() {
-  // 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()) {
-    return false;
-  }
-  CanonicalName* kind = this->parent();
-  if (IsPrivate()) {
-    kind = kind->parent();
-  }
-  return COMPARE_NAME(kind, "@fields");
-}
-
-
-bool CanonicalName::IsConstructor() {
-  // 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()) {
-    return false;
-  }
-  CanonicalName* kind = this->parent();
-  if (IsPrivate()) {
-    kind = kind->parent();
-  }
-  return COMPARE_NAME(kind, "@constructors");
-}
-
-
-bool CanonicalName::IsProcedure() {
-  return IsMethod() || IsGetter() || IsSetter() || IsFactory();
-}
-
-
-bool CanonicalName::IsMethod() {
-  // 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()) {
-    return false;
-  }
-  CanonicalName* kind = this->parent();
-  if (IsPrivate()) {
-    kind = kind->parent();
-  }
-  return COMPARE_NAME(kind, "@methods");
-}
-
-
-bool CanonicalName::IsGetter() {
-  // 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()) {
-    return false;
-  }
-  CanonicalName* kind = this->parent();
-  if (IsPrivate()) {
-    kind = kind->parent();
-  }
-  return COMPARE_NAME(kind, "@getters");
-}
-
-
-bool CanonicalName::IsSetter() {
-  // 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()) {
-    return false;
-  }
-  CanonicalName* kind = this->parent();
-  if (IsPrivate()) {
-    kind = kind->parent();
-  }
-  return COMPARE_NAME(kind, "@setters");
-}
-
-
-bool CanonicalName::IsFactory() {
-  // 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()) {
-    return false;
-  }
-  CanonicalName* kind = this->parent();
-  if (IsPrivate()) {
-    kind = kind->parent();
-  }
-  return COMPARE_NAME(kind, "@factories");
-}
-
-#undef COMPARE_NAME
-
-
-CanonicalName* CanonicalName::EnclosingName() {
-  ASSERT(IsField() || IsConstructor() || IsProcedure());
-  CanonicalName* enclosing = parent()->parent();
-  if (IsPrivate()) {
-    enclosing = enclosing->parent();
-  }
-  ASSERT(enclosing->IsLibrary() || enclosing->IsClass());
-  return enclosing;
-}
-
-
 Node::~Node() {}
 
 
 TreeNode::~TreeNode() {}
 
 
 void TreeNode::AcceptVisitor(Visitor* visitor) {
   AcceptTreeVisitor(visitor);
 }
 
@@ skipping 25 matching lines @@
 
 
 NormalClass::~NormalClass() {}
 
 
 void NormalClass::AcceptClassVisitor(ClassVisitor* visitor) {
   visitor->VisitNormalClass(this);
 }
 
 
+void NormalClass::AcceptReferenceVisitor(ClassReferenceVisitor* visitor) {
+  visitor->VisitNormalClassReference(this);
+}
+
+
 void NormalClass::VisitChildren(Visitor* visitor) {
   VisitList(&type_parameters(), visitor);
   if (super_class() != NULL) visitor->VisitInterfaceType(super_class());
   VisitList(&implemented_classes(), visitor);
   VisitList(&constructors(), visitor);
   VisitList(&procedures(), visitor);
   VisitList(&fields(), visitor);
 }
 
 
 MixinClass::~MixinClass() {}
 
 
 void MixinClass::AcceptClassVisitor(ClassVisitor* visitor) {
   visitor->VisitMixinClass(this);
 }
 
 
+void MixinClass::AcceptReferenceVisitor(ClassReferenceVisitor* visitor) {
+  visitor->VisitMixinClassReference(this);
+}
+
+
 void MixinClass::VisitChildren(Visitor* visitor) {
   VisitList(&type_parameters(), visitor);
   visitor->VisitInterfaceType(first());
   visitor->VisitInterfaceType(second());
   VisitList(&implemented_classes(), visitor);
   VisitList(&constructors(), visitor);
 }
 
 
 Member::~Member() {}
 
 
 void Member::AcceptTreeVisitor(TreeVisitor* visitor) {
   AcceptMemberVisitor(visitor);
 }
 
 
 Field::~Field() {}
 
 
 void Field::AcceptMemberVisitor(MemberVisitor* visitor) {
   visitor->VisitField(this);
 }
 
 
+void Field::AcceptReferenceVisitor(MemberReferenceVisitor* visitor) {
+  visitor->VisitFieldReference(this);
+}
+
+
 void Field::VisitChildren(Visitor* visitor) {
   type()->AcceptDartTypeVisitor(visitor);
   visitor->VisitName(name());
   if (initializer() != NULL) initializer()->AcceptExpressionVisitor(visitor);
 }
 
 
 Constructor::~Constructor() {}
 
 
 void Constructor::AcceptMemberVisitor(MemberVisitor* visitor) {
   visitor->VisitConstructor(this);
 }
 
 
+void Constructor::AcceptReferenceVisitor(MemberReferenceVisitor* visitor) {
+  visitor->VisitConstructorReference(this);
+}
+
+
 void Constructor::VisitChildren(Visitor* visitor) {
   visitor->VisitName(name());
   visitor->VisitFunctionNode(function());
   VisitList(&initializers(), visitor);
 }
 
 
 Procedure::~Procedure() {}
 
 
 void Procedure::AcceptMemberVisitor(MemberVisitor* visitor) {
   visitor->VisitProcedure(this);
 }
 
 
+void Procedure::AcceptReferenceVisitor(MemberReferenceVisitor* visitor) {
+  visitor->VisitProcedureReference(this);
+}
+
+
 void Procedure::VisitChildren(Visitor* visitor) {
   visitor->VisitName(name());
   if (function() != NULL) visitor->VisitFunctionNode(function());
 }
 
 
 Initializer::~Initializer() {}
 
 
 void Initializer::AcceptTreeVisitor(TreeVisitor* visitor) {
@@ skipping 14 matching lines @@
 
 FieldInitializer::~FieldInitializer() {}
 
 
 void FieldInitializer::AcceptInitializerVisitor(InitializerVisitor* visitor) {
   visitor->VisitFieldInitializer(this);
 }
 
 
 void FieldInitializer::VisitChildren(Visitor* visitor) {
+  visitor->VisitFieldReference(field());
   value()->AcceptExpressionVisitor(visitor);
 }
 
 
 SuperInitializer::~SuperInitializer() {}
 
 
 void SuperInitializer::AcceptInitializerVisitor(InitializerVisitor* visitor) {
   visitor->VisitSuperInitializer(this);
 }
 
 
 void SuperInitializer::VisitChildren(Visitor* visitor) {
+  visitor->VisitConstructorReference(target());
   visitor->VisitArguments(arguments());
 }
 
 
 RedirectingInitializer::~RedirectingInitializer() {}
 
 
 void RedirectingInitializer::AcceptInitializerVisitor(
     InitializerVisitor* visitor) {
   visitor->VisitRedirectingInitializer(this);
 }
 
 
 void RedirectingInitializer::VisitChildren(Visitor* visitor) {
+  visitor->VisitConstructorReference(target());
   visitor->VisitArguments(arguments());
 }
 
 
 LocalInitializer::~LocalInitializer() {}
 
 
 void LocalInitializer::AcceptInitializerVisitor(InitializerVisitor* visitor) {
   visitor->VisitLocalInitializer(this);
 }
@@ skipping 96 matching lines @@
 DirectPropertyGet::~DirectPropertyGet() {}
 
 
 void DirectPropertyGet::AcceptExpressionVisitor(ExpressionVisitor* visitor) {
   visitor->VisitDirectPropertyGet(this);
 }
 
 
 void DirectPropertyGet::VisitChildren(Visitor* visitor) {
   receiver()->AcceptExpressionVisitor(visitor);
+  target()->AcceptReferenceVisitor(visitor);
 }
 
 
 DirectPropertySet::~DirectPropertySet() {}
 
 
 void DirectPropertySet::AcceptExpressionVisitor(ExpressionVisitor* visitor) {
   visitor->VisitDirectPropertySet(this);
 }
 
 
 void DirectPropertySet::VisitChildren(Visitor* visitor) {
   receiver()->AcceptExpressionVisitor(visitor);
+  target()->AcceptReferenceVisitor(visitor);
   value()->AcceptExpressionVisitor(visitor);
 }
 
 
 StaticGet::~StaticGet() {}
 
 
 void StaticGet::AcceptExpressionVisitor(ExpressionVisitor* visitor) {
   visitor->VisitStaticGet(this);
 }
 
 
-void StaticGet::VisitChildren(Visitor* visitor) {}
+void StaticGet::VisitChildren(Visitor* visitor) {
+  target()->AcceptReferenceVisitor(visitor);
+}
 
 
 StaticSet::~StaticSet() {}
 
 
 void StaticSet::AcceptExpressionVisitor(ExpressionVisitor* visitor) {
   visitor->VisitStaticSet(this);
 }
 
 
 void StaticSet::VisitChildren(Visitor* visitor) {
+  target()->AcceptReferenceVisitor(visitor);
   expression()->AcceptExpressionVisitor(visitor);
 }
 
 
 Arguments::~Arguments() {}
 
 
 void Arguments::AcceptTreeVisitor(TreeVisitor* visitor) {
   visitor->VisitArguments(this);
 }
@@ skipping 38 matching lines @@
 
 
 void DirectMethodInvocation::AcceptExpressionVisitor(
     ExpressionVisitor* visitor) {
   visitor->VisitDirectMethodInvocation(this);
 }
 
 
 void DirectMethodInvocation::VisitChildren(Visitor* visitor) {
   receiver()->AcceptExpressionVisitor(visitor);
+  visitor->VisitProcedureReference(target());
   visitor->VisitArguments(arguments());
 }
 
 
 StaticInvocation::~StaticInvocation() {}
 
 
 void StaticInvocation::AcceptExpressionVisitor(ExpressionVisitor* visitor) {
   visitor->VisitStaticInvocation(this);
 }
 
 
 void StaticInvocation::VisitChildren(Visitor* visitor) {
+  visitor->VisitProcedureReference(procedure());
   visitor->VisitArguments(arguments());
 }
 
 
 ConstructorInvocation::~ConstructorInvocation() {}
 
 
 void ConstructorInvocation::AcceptExpressionVisitor(
     ExpressionVisitor* visitor) {
   visitor->VisitConstructorInvocation(this);
 }
 
 
 void ConstructorInvocation::VisitChildren(Visitor* visitor) {
+  visitor->VisitConstructorReference(target());
   visitor->VisitArguments(arguments());
 }
 
 
 Not::~Not() {}
 
 
 void Not::AcceptExpressionVisitor(ExpressionVisitor* visitor) {
   visitor->VisitNot(this);
 }
@@ skipping 631 matching lines @@
 
 InterfaceType::~InterfaceType() {}
 
 
 void InterfaceType::AcceptDartTypeVisitor(DartTypeVisitor* visitor) {
   visitor->VisitInterfaceType(this);
 }
 
 
 void InterfaceType::VisitChildren(Visitor* visitor) {
+  klass()->AcceptReferenceVisitor(visitor);
   VisitList(&type_arguments(), visitor);
 }
 
 
 FunctionType::~FunctionType() {}
 
 
 void FunctionType::AcceptDartTypeVisitor(DartTypeVisitor* visitor) {
   visitor->VisitFunctionType(this);
 }
@@ skipping 43 matching lines @@
 }
 
 
 void Program::AcceptTreeVisitor(TreeVisitor* visitor) {
   visitor->VisitProgram(this);
 }
 
 
 void Program::VisitChildren(Visitor* visitor) {
   VisitList(&libraries(), visitor);
+  visitor->VisitProcedureReference(main_method());
 }
 
 
 }  // namespace kernel
 
 }  // namespace dart
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)