clang-format runtime/vm

runtime/vm/ast.cc

 // Copyright (c) 2011, 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/ast.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
 #include "vm/isolate.h"
 #include "vm/log.h"
 #include "vm/object_store.h"
 #include "vm/resolver.h"
 
 
 namespace dart {
 
 #define DEFINE_VISIT_FUNCTION(BaseName)                                        \
-void BaseName##Node::Visit(AstNodeVisitor* visitor) {                          \
-  visitor->Visit##BaseName##Node(this);                                        \
-}
+  void BaseName##Node::Visit(AstNodeVisitor* visitor) {                        \
+    visitor->Visit##BaseName##Node(this);                                      \
+  }
 
 FOR_EACH_NODE(DEFINE_VISIT_FUNCTION)
 #undef DEFINE_VISIT_FUNCTION
 
 
 #define DEFINE_NAME_FUNCTION(BaseName)                                         \
-const char* BaseName##Node::Name() const {                                     \
-  return #BaseName;                                                            \
-}
+  const char* BaseName##Node::Name() const { return #BaseName; }
 
 FOR_EACH_NODE(DEFINE_NAME_FUNCTION)
 #undef DEFINE_NAME_FUNCTION
 
 
 const Field* AstNode::MayCloneField(const Field& value) {
   if (Compiler::IsBackgroundCompilation() ||
       FLAG_force_clone_compiler_objects) {
     return &Field::ZoneHandle(value.CloneFromOriginal());
   } else {
     ASSERT(value.IsZoneHandle());
     return &value;
   }
 }
 
 
 // A visitor class to collect all the nodes (including children) into an
 // array.
 class AstNodeCollector : public AstNodeVisitor {
  public:
-  explicit AstNodeCollector(GrowableArray<AstNode*>* nodes)
-    : nodes_(nodes) { }
+  explicit AstNodeCollector(GrowableArray<AstNode*>* nodes) : nodes_(nodes) {}
 
 #define DEFINE_VISITOR_FUNCTION(BaseName)                                      \
   virtual void Visit##BaseName##Node(BaseName##Node* node) {                   \
     nodes_->Add(node);                                                         \
     node->VisitChildren(this);                                                 \
   }
 
-FOR_EACH_NODE(DEFINE_VISITOR_FUNCTION)
+  FOR_EACH_NODE(DEFINE_VISITOR_FUNCTION)
 #undef DEFINE_VISITOR_FUNCTION
 
  private:
   GrowableArray<AstNode*>* nodes_;
   DISALLOW_COPY_AND_ASSIGN(AstNodeCollector);
 };
 
 
 void SequenceNode::CollectAllNodes(GrowableArray<AstNode*>* nodes) {
   AstNodeCollector node_collector(nodes);
   this->Visit(&node_collector);
 }
 
 
 void SequenceNode::VisitChildren(AstNodeVisitor* visitor) const {
   for (intptr_t i = 0; i < this->length(); i++) {
     NodeAt(i)->Visit(visitor);
   }
 }
 
 
 void SequenceNode::Add(AstNode* node) {
   if (node->IsReturnNode()) {
     node->AsReturnNode()->set_scope(scope());
   }
   nodes_.Add(node);
 }
 
 
-void PrimaryNode::VisitChildren(AstNodeVisitor* visitor) const {
-}
+void PrimaryNode::VisitChildren(AstNodeVisitor* visitor) const {}
 
 
 void ArgumentListNode::VisitChildren(AstNodeVisitor* visitor) const {
   for (intptr_t i = 0; i < this->length(); i++) {
     NodeAt(i)->Visit(visitor);
   }
 }
 
 
 LetNode::LetNode(TokenPosition token_pos)
-  : AstNode(token_pos),
-    vars_(1),
-    initializers_(1),
-    nodes_(1) { }
+    : AstNode(token_pos), vars_(1), initializers_(1), nodes_(1) {}
 
 
 LocalVariable* LetNode::AddInitializer(AstNode* node) {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   initializers_.Add(node);
   char name[64];
-  OS::SNPrint(name, sizeof(name), ":lt%s_%" Pd "",
-      token_pos().ToCString(), vars_.length());
+  OS::SNPrint(name, sizeof(name), ":lt%s_%" Pd "", token_pos().ToCString(),
+              vars_.length());
   LocalVariable* temp_var =
-      new LocalVariable(TokenPosition::kNoSource,
-                        token_pos(),
+      new LocalVariable(TokenPosition::kNoSource, token_pos(),
                         String::ZoneHandle(zone, Symbols::New(thread, name)),
                         Object::dynamic_type());
   vars_.Add(temp_var);
   return temp_var;
 }
 
 
 void LetNode::VisitChildren(AstNodeVisitor* visitor) const {
   for (intptr_t i = 0; i < num_temps(); ++i) {
     initializers_[i]->Visit(visitor);
@@ skipping 100 matching lines @@
   return NULL;
 }
 
 
 const char* TypeNode::TypeName() const {
   return String::Handle(type().UserVisibleName()).ToCString();
 }
 
 
 bool ComparisonNode::IsKindValid() const {
-  return Token::IsRelationalOperator(kind_)
-      || Token::IsEqualityOperator(kind_)
-      || Token::IsTypeTestOperator(kind_)
-      || Token::IsTypeCastOperator(kind_);
+  return Token::IsRelationalOperator(kind_) ||
+         Token::IsEqualityOperator(kind_) || Token::IsTypeTestOperator(kind_) ||
+         Token::IsTypeCastOperator(kind_);
 }
 
 
 const char* ComparisonNode::TokenName() const {
   return (kind_ == Token::kAS) ? "as" : Token::Str(kind_);
 }
 
 
 bool ComparisonNode::IsPotentiallyConst() const {
   switch (kind_) {
     case Token::kLT:
     case Token::kGT:
     case Token::kLTE:
     case Token::kGTE:
     case Token::kEQ:
     case Token::kNE:
     case Token::kEQ_STRICT:
     case Token::kNE_STRICT:
       return this->left()->IsPotentiallyConst() &&
-          this->right()->IsPotentiallyConst();
+             this->right()->IsPotentiallyConst();
     default:
       return false;
   }
 }
 
 
 const Instance* ComparisonNode::EvalConstExpr() const {
   const Instance* left_val = this->left()->EvalConstExpr();
   if (left_val == NULL) {
     return NULL;
   }
   const Instance* right_val = this->right()->EvalConstExpr();
   if (right_val == NULL) {
     return NULL;
   }
   switch (kind_) {
     case Token::kLT:
     case Token::kGT:
     case Token::kLTE:
     case Token::kGTE:
       if ((left_val->IsNumber() || left_val->IsNull()) &&
           (right_val->IsNumber() || right_val->IsNull())) {
         return &Bool::False();
       }
       return NULL;
     case Token::kEQ:
     case Token::kNE:
       // The comparison is a compile time const if both operands are either a
       // number, string, or boolean value (but not necessarily the same type).
-      if ((left_val->IsNumber() ||
-          left_val->IsString() ||
-          left_val->IsBool() ||
-          left_val->IsNull()) &&
-          (right_val->IsNumber() ||
-          right_val->IsString() ||
-          right_val->IsBool() ||
-          right_val->IsNull())) {
+      if ((left_val->IsNumber() || left_val->IsString() || left_val->IsBool() ||
+           left_val->IsNull()) &&
+          (right_val->IsNumber() || right_val->IsString() ||
+           right_val->IsBool() || right_val->IsNull())) {
         return &Bool::False();
       }
       return NULL;
     case Token::kEQ_STRICT:
     case Token::kNE_STRICT:
       // identical(a, b) is a compile time const if both operands are
       // compile time constants, regardless of their type.
       return &Bool::True();
     default:
       return NULL;
   }
   return NULL;
 }
 
 
-
 bool BinaryOpNode::IsKindValid() const {
   switch (kind_) {
     case Token::kADD:
     case Token::kSUB:
     case Token::kMUL:
     case Token::kDIV:
     case Token::kTRUNCDIV:
     case Token::kMOD:
     case Token::kOR:
     case Token::kAND:
@@ skipping 20 matching lines @@
     case Token::kOR:
     case Token::kAND:
       if (this->left()->IsLiteralNode() &&
           this->left()->AsLiteralNode()->literal().IsNull()) {
         return false;
       }
       if (this->right()->IsLiteralNode() &&
           this->right()->AsLiteralNode()->literal().IsNull()) {
         return false;
       }
-      // Fall-through intentional.
+    // Fall-through intentional.
     case Token::kADD:
     case Token::kSUB:
     case Token::kMUL:
     case Token::kDIV:
     case Token::kMOD:
     case Token::kTRUNCDIV:
     case Token::kBIT_OR:
     case Token::kBIT_XOR:
     case Token::kBIT_AND:
     case Token::kSHL:
     case Token::kSHR:
     case Token::kIFNULL:
       return this->left()->IsPotentiallyConst() &&
-          this->right()->IsPotentiallyConst();
+             this->right()->IsPotentiallyConst();
     default:
       UNREACHABLE();
       return false;
   }
 }
 
 
 const Instance* BinaryOpNode::EvalConstExpr() const {
   const Instance* left_val = this->left()->EvalConstExpr();
   if (left_val == NULL) {
     return NULL;
   }
   if (!left_val->IsNumber() && !left_val->IsBool() && !left_val->IsString() &&
       kind_ != Token::kIFNULL) {
     return NULL;
   }
   const Instance* right_val = this->right()->EvalConstExpr();
   if (right_val == NULL) {
     return NULL;
   }
   switch (kind_) {
     case Token::kADD:
       if (left_val->IsString()) {
         return right_val->IsString() ? left_val : NULL;
       }
-      // Fall-through intentional.
+    // Fall-through intentional.
     case Token::kSUB:
     case Token::kMUL:
     case Token::kDIV:
     case Token::kMOD:
     case Token::kTRUNCDIV:
       if (left_val->IsInteger()) {
         if (right_val->IsInteger()) {
           return left_val;
         } else if (right_val->IsNumber()) {
           return right_val;
         }
-      } else if (left_val->IsNumber() &&
-                 right_val->IsNumber()) {
+      } else if (left_val->IsNumber() && right_val->IsNumber()) {
         return left_val;
       }
       return NULL;
     case Token::kBIT_OR:
     case Token::kBIT_XOR:
     case Token::kBIT_AND:
     case Token::kSHL:
     case Token::kSHR:
-      if (left_val->IsInteger() &&
-          right_val->IsInteger()) {
+      if (left_val->IsInteger() && right_val->IsInteger()) {
         return right_val;
       }
       return NULL;
     case Token::kOR:
     case Token::kAND:
       if (left_val->IsBool() && right_val->IsBool()) {
         return left_val;
       }
       return NULL;
     case Token::kIFNULL:
@@ skipping 54 matching lines @@
     case Token::kBIT_NOT:
       return val->IsInteger() ? val : NULL;
     default:
       return NULL;
   }
 }
 
 
 bool ConditionalExprNode::IsPotentiallyConst() const {
   return this->condition()->IsPotentiallyConst() &&
-    this->true_expr()->IsPotentiallyConst() &&
-    this->false_expr()->IsPotentiallyConst();
+         this->true_expr()->IsPotentiallyConst() &&
+         this->false_expr()->IsPotentiallyConst();
 }
 
 
 const Instance* ConditionalExprNode::EvalConstExpr() const {
   const Instance* cond = this->condition()->EvalConstExpr();
-  if ((cond != NULL) &&
-      cond->IsBool() &&
+  if ((cond != NULL) && cond->IsBool() &&
       (this->true_expr()->EvalConstExpr() != NULL) &&
       (this->false_expr()->EvalConstExpr() != NULL)) {
     return cond;
   }
   return NULL;
 }
 
 
 bool ClosureNode::IsPotentiallyConst() const {
   if (function().IsImplicitStaticClosureFunction()) {
     return true;
   }
   return false;
 }
 
 
 const Instance* ClosureNode::EvalConstExpr() const {
-  if (!is_deferred_reference_ &&
-      function().IsImplicitStaticClosureFunction()) {
+  if (!is_deferred_reference_ && function().IsImplicitStaticClosureFunction()) {
     // Return a value that represents an instance. Only the type is relevant.
     return &Instance::Handle();
   }
   return NULL;
 }
 
 
 AstNode* ClosureNode::MakeAssignmentNode(AstNode* rhs) {
   if (scope() == NULL) {
     // This is an implicit closure node created because a static getter was not
     // found. Change the getter into a setter. If it does not exist,
     // noSuchMethod will be called.
-    return new StaticSetterNode(token_pos(),
-                                receiver(),
+    return new StaticSetterNode(token_pos(), receiver(),
                                 Class::ZoneHandle(function().Owner()),
-                                String::ZoneHandle(function().name()),
-                                rhs);
+                                String::ZoneHandle(function().name()), rhs);
   }
   return NULL;
 }
 
 
 const char* UnaryOpNode::TokenName() const {
   return Token::Str(kind_);
 }
 
 
@@ skipping 26 matching lines @@
   }
   return new StoreLocalNode(token_pos(), &local(), rhs);
 }
 
 
 AstNode* LoadStaticFieldNode::MakeAssignmentNode(AstNode* rhs) {
   if (field().is_final()) {
     return NULL;
   }
   if (Isolate::Current()->type_checks()) {
-    rhs = new AssignableNode(
-        field().token_pos(),
-        rhs,
-        AbstractType::ZoneHandle(field().type()),
-        String::ZoneHandle(field().name()));
+    rhs = new AssignableNode(field().token_pos(), rhs,
+                             AbstractType::ZoneHandle(field().type()),
+                             String::ZoneHandle(field().name()));
   }
-  return new StoreStaticFieldNode(
-      token_pos(), Field::ZoneHandle(field().Original()), rhs);
+  return new StoreStaticFieldNode(token_pos(),
+                                  Field::ZoneHandle(field().Original()), rhs);
 }
 
 
 AstNode* InstanceGetterNode::MakeAssignmentNode(AstNode* rhs) {
-  return new InstanceSetterNode(token_pos(),
-                                receiver(),
-                                field_name(),
-                                rhs,
+  return new InstanceSetterNode(token_pos(), receiver(), field_name(), rhs,
                                 is_conditional());
 }
 
 
 bool InstanceGetterNode::IsPotentiallyConst() const {
-  return field_name().Equals(Symbols::Length()) &&
-    !is_conditional() &&
-    receiver()->IsPotentiallyConst();
+  return field_name().Equals(Symbols::Length()) && !is_conditional() &&
+         receiver()->IsPotentiallyConst();
 }
 
 
 const Instance* InstanceGetterNode::EvalConstExpr() const {
   if (field_name().Equals(Symbols::Length()) && !is_conditional()) {
     const Instance* receiver_val = receiver()->EvalConstExpr();
     if ((receiver_val != NULL) && receiver_val->IsString()) {
       return &Instance::ZoneHandle(Smi::New(1));
     }
   }
   return NULL;
 }
 
 
 AstNode* LoadIndexedNode::MakeAssignmentNode(AstNode* rhs) {
-  return new StoreIndexedNode(token_pos(), array(), index_expr(),
-                              rhs, super_class());
+  return new StoreIndexedNode(token_pos(), array(), index_expr(), rhs,
+                              super_class());
 }
 
 
 AstNode* StaticGetterNode::MakeAssignmentNode(AstNode* rhs) {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   Isolate* isolate = thread->isolate();
   if (is_super_getter()) {
     ASSERT(receiver() != NULL);
     const String& setter_name =
         String::ZoneHandle(zone, Field::LookupSetterSymbol(field_name_));
     Function& setter = Function::ZoneHandle(zone);
     if (!setter_name.IsNull()) {
       setter = Resolver::ResolveDynamicAnyArgs(zone, cls(), setter_name);
     }
     if (setter.IsNull() || setter.is_abstract()) {
       // No instance setter found in super class chain,
       // noSuchMethod will be called at runtime.
-      return new StaticSetterNode(token_pos(),
-                                  receiver(),
-                                  cls(),
-                                  field_name_,
+      return new StaticSetterNode(token_pos(), receiver(), cls(), field_name_,
                                   rhs);
     }
-    return new StaticSetterNode(token_pos(),
-                                receiver(),
-                                field_name_,
-                                setter,
+    return new StaticSetterNode(token_pos(), receiver(), field_name_, setter,
                                 rhs);
   }
 
   if (owner().IsLibraryPrefix()) {
     const LibraryPrefix& prefix = LibraryPrefix::Cast(owner_);
     // The parser has already dealt with the pathological case where a
     // library imports itself. See Parser::ResolveIdentInPrefixScope()
     ASSERT(field_name_.CharAt(0) != Library::kPrivateIdentifierStart);
 
     // If the prefix is not yet loaded, the getter doesn't exist. Return a
     // setter that will throw a NSME at runtime.
     if (!prefix.is_loaded()) {
       return new StaticSetterNode(token_pos(), NULL, cls(), field_name_, rhs);
     }
 
     Object& obj = Object::Handle(zone, prefix.LookupObject(field_name_));
     if (obj.IsField()) {
       const Field& field = Field::ZoneHandle(zone, Field::Cast(obj).raw());
       if (!field.is_final()) {
         if (isolate->type_checks()) {
-          rhs = new AssignableNode(field.token_pos(),
-                                   rhs,
+          rhs = new AssignableNode(field.token_pos(), rhs,
                                    AbstractType::ZoneHandle(zone, field.type()),
                                    field_name_);
         }
         return new StoreStaticFieldNode(token_pos(), field, rhs);
       }
     }
 
     // No field found in prefix. Look for a setter function.
     const String& setter_name =
-         String::Handle(zone, Field::LookupSetterSymbol(field_name_));
+        String::Handle(zone, Field::LookupSetterSymbol(field_name_));
     if (!setter_name.IsNull()) {
       obj = prefix.LookupObject(setter_name);
       if (obj.IsFunction()) {
         const Function& setter =
             Function::ZoneHandle(zone, Function::Cast(obj).raw());
         ASSERT(setter.is_static() && setter.IsSetterFunction());
-        return new StaticSetterNode(
-            token_pos(), NULL, field_name_, setter, rhs);
+        return new StaticSetterNode(token_pos(), NULL, field_name_, setter,
+                                    rhs);
       }
     }
 
     // No writeable field and no setter found in the prefix. Return a
     // non-existing setter that will throw an NSM error.
     return new StaticSetterNode(token_pos(), NULL, cls(), field_name_, rhs);
   }
 
   if (owner().IsLibrary()) {
     const Library& library = Library::Cast(owner());
     Object& obj = Object::Handle(zone, library.ResolveName(field_name_));
     if (obj.IsField()) {
       const Field& field = Field::ZoneHandle(zone, Field::Cast(obj).raw());
       if (!field.is_final()) {
         if (isolate->type_checks()) {
-          rhs = new AssignableNode(field.token_pos(),
-                                   rhs,
+          rhs = new AssignableNode(field.token_pos(), rhs,
                                    AbstractType::ZoneHandle(zone, field.type()),
                                    field_name_);
         }
         return new StoreStaticFieldNode(token_pos(), field, rhs);
       }
     }
 
     // No field found in library. Look for a setter function.
     const String& setter_name =
         String::Handle(zone, Field::LookupSetterSymbol(field_name_));
     if (!setter_name.IsNull()) {
       obj = library.ResolveName(setter_name);
       if (obj.IsFunction()) {
         const Function& setter =
             Function::ZoneHandle(zone, Function::Cast(obj).raw());
         ASSERT(setter.is_static() && setter.IsSetterFunction());
-        return
-            new StaticSetterNode(token_pos(), NULL, field_name_, setter, rhs);
+        return new StaticSetterNode(token_pos(), NULL, field_name_, setter,
+                                    rhs);
       }
     }
 
     // No writeable field and no setter found in the library. Return a
     // non-existing setter that will throw an NSM error.
     return new StaticSetterNode(token_pos(), NULL, cls(), field_name_, rhs);
   }
 
   const Function& setter =
       Function::ZoneHandle(zone, cls().LookupSetterFunction(field_name_));
   if (!setter.IsNull() && setter.IsStaticFunction()) {
     return new StaticSetterNode(token_pos(), NULL, field_name_, setter, rhs);
   }
   // Could not find a static setter. Look for a field.
   // Access to a lazily initialized static field that has not yet been
   // initialized is compiled to a static implicit getter.
   // A setter may not exist for such a field.
-  const Field& field = Field::ZoneHandle(zone,
-                                         cls().LookupStaticField(field_name_));
+  const Field& field =
+      Field::ZoneHandle(zone, cls().LookupStaticField(field_name_));
   if (!field.IsNull()) {
     if (field.is_final()) {
       // Attempting to assign to a final variable will cause a NoSuchMethodError
       // to be thrown. Change static getter to non-existent static setter in
       // order to trigger the throw at runtime.
       return new StaticSetterNode(token_pos(), NULL, cls(), field_name_, rhs);
     }
 #if defined(DEBUG)
     const String& getter_name =
         String::Handle(zone, Field::LookupGetterSymbol(field_name_));
     ASSERT(!getter_name.IsNull());
     const Function& getter =
         Function::Handle(zone, cls().LookupStaticFunction(getter_name));
     ASSERT(!getter.IsNull() &&
            (getter.kind() == RawFunction::kImplicitStaticFinalGetter));
 #endif
     if (isolate->type_checks()) {
-      rhs = new AssignableNode(
-          field.token_pos(),
-          rhs,
-          AbstractType::ZoneHandle(zone, field.type()),
-          String::ZoneHandle(zone, field.name()));
+      rhs = new AssignableNode(field.token_pos(), rhs,
+                               AbstractType::ZoneHandle(zone, field.type()),
+                               String::ZoneHandle(zone, field.name()));
     }
     return new StoreStaticFieldNode(token_pos(), field, rhs);
   }
   // Didn't find a static setter or a static field. Make a call to
   // the non-existent setter to trigger a NoSuchMethodError at runtime.
   return new StaticSetterNode(token_pos(), NULL, cls(), field_name_, rhs);
 }
 
 
 AstNode* StaticCallNode::MakeAssignmentNode(AstNode* rhs) {
@@ skipping 44 matching lines @@
   if (result.IsError() || result.IsNull()) {
     // TODO(turnidge): We could get better error messages by returning
     // the Error object directly to the parser.  This will involve
     // replumbing all of the EvalConstExpr methods.
     return NULL;
   }
   return &Instance::ZoneHandle(Instance::Cast(result).raw());
 }
 
 }  // namespace dart