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;
 }
 
 
-Library* CanonicalName::AsLibrary() {
-  return Library::Cast(definition());
+bool CanonicalName::IsAdministrative() {
+  // Administrative names start with '@'.
+  return (name()->size() > 0) && (name()->buffer()[0] == '@');
 }
 
 
-Class* CanonicalName::AsClass() {
-  return Class::Cast(definition());
+bool CanonicalName::IsPrivate() {
+  // Private names start with '_'.
+  return (name()->size() > 0) && (name()->buffer()[0] == '_');
 }
 
 
-Member* CanonicalName::AsMember() {
-  return Member::Cast(definition());
+bool CanonicalName::IsRoot() {
+  // The root is the only canonical name with no parent.
+  return parent() == NULL;
 }
 
 
-Field* CanonicalName::AsField() {
-  return Field::Cast(definition());
+bool CanonicalName::IsLibrary() {
+  // Libraries are the only canonical names with the root as their parent.
+  return !IsRoot() && parent()->IsRoot();
 }
 
 
-Constructor* CanonicalName::AsConstructor() {
-  return Constructor::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();
 }
 
 
-Procedure* CanonicalName::AsProcedure() {
-  return Procedure::Cast(definition());
+bool CanonicalName::IsMember() {
+  return IsConstructor() || IsField() || IsProcedure();
 }
 
 
+// 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) {
-  target()->AcceptReferenceVisitor(visitor);
-}
+void StaticGet::VisitChildren(Visitor* 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)