VM: Re-format to use at most one newline between functions

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);                                      \
   }
 
 FOR_EACH_NODE(DEFINE_VISIT_FUNCTION)
 #undef DEFINE_VISIT_FUNCTION
 
-
 #define DEFINE_NAME_FUNCTION(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) {}
 
 #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)
 #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 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) {}
 
-
 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());
   LocalVariable* temp_var =
       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);
   }
   for (intptr_t i = 0; i < nodes_.length(); ++i) {
     nodes_[i]->Visit(visitor);
   }
 }
 
 bool LetNode::IsPotentiallyConst() const {
@@ skipping 19 matching lines @@
   const Instance* last = NULL;
   for (intptr_t i = 0; i < nodes_.length(); i++) {
     last = nodes_[i]->EvalConstExpr();
     if (last == NULL) {
       return NULL;
     }
   }
   return last;
 }
 
-
 void ArrayNode::VisitChildren(AstNodeVisitor* visitor) const {
   for (intptr_t i = 0; i < this->length(); i++) {
     ElementAt(i)->Visit(visitor);
   }
 }
 
-
 bool StringInterpolateNode::IsPotentiallyConst() const {
   for (int i = 0; i < value_->length(); i++) {
     if (!value_->ElementAt(i)->IsPotentiallyConst()) {
       return false;
     }
   }
   return true;
 }
 
-
 bool LiteralNode::IsPotentiallyConst() const {
   return true;
 }
 
-
 AstNode* LiteralNode::ApplyUnaryOp(Token::Kind unary_op_kind) {
   if (unary_op_kind == Token::kNEGATE) {
     if (literal().IsSmi()) {
       const Smi& smi = Smi::Cast(literal());
       const Instance& literal =
           Instance::ZoneHandle(Integer::New(-smi.Value(), Heap::kOld));
       return new LiteralNode(this->token_pos(), literal);
     }
     if (literal().IsMint()) {
       const Mint& mint = Mint::Cast(literal());
@@ skipping 24 matching lines @@
     }
   } else if (unary_op_kind == Token::kNOT) {
     if (literal().IsBool()) {
       const Bool& boolean = Bool::Cast(literal());
       return new LiteralNode(this->token_pos(), Bool::Get(!boolean.value()));
     }
   }
   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_);
 }
 
-
 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();
     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_) {
@@ skipping 21 matching lines @@
     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:
     case Token::kIFNULL:
     case Token::kBIT_OR:
     case Token::kBIT_XOR:
     case Token::kBIT_AND:
     case Token::kSHL:
     case Token::kSHR:
       return true;
     default:
       return false;
   }
 }
 
-
 const char* BinaryOpNode::TokenName() const {
   return Token::Str(kind_);
 }
 
-
 bool BinaryOpNode::IsPotentiallyConst() const {
   switch (kind_) {
     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()) {
@@ skipping 13 matching lines @@
     case Token::kSHR:
     case Token::kIFNULL:
       return this->left()->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();
@@ skipping 41 matching lines @@
         return right_val;
       }
       return left_val;
     default:
       UNREACHABLE();
       return NULL;
   }
   return NULL;
 }
 
-
 AstNode* UnaryOpNode::UnaryOpOrLiteral(TokenPosition token_pos,
                                        Token::Kind kind,
                                        AstNode* operand) {
   AstNode* new_operand = operand->ApplyUnaryOp(kind);
   if (new_operand != NULL) {
     return new_operand;
   }
   return new UnaryOpNode(token_pos, kind, operand);
 }
 
-
 bool UnaryOpNode::IsKindValid() const {
   switch (kind_) {
     case Token::kNEGATE:
     case Token::kNOT:
     case Token::kBIT_NOT:
       return true;
     default:
       return false;
   }
 }
 
-
 bool UnaryOpNode::IsPotentiallyConst() const {
   if (this->operand()->IsLiteralNode() &&
       this->operand()->AsLiteralNode()->literal().IsNull()) {
     return false;
   }
   return this->operand()->IsPotentiallyConst();
 }
 
-
 const Instance* UnaryOpNode::EvalConstExpr() const {
   const Instance* val = this->operand()->EvalConstExpr();
   if (val == NULL) {
     return NULL;
   }
   switch (kind_) {
     case Token::kNEGATE:
       return val->IsNumber() ? val : NULL;
     case Token::kNOT:
       return val->IsBool() ? val : NULL;
     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();
 }
 
-
 const Instance* ConditionalExprNode::EvalConstExpr() const {
   const Instance* cond = this->condition()->EvalConstExpr();
   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()) {
     // 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(),
                                 Class::ZoneHandle(function().Owner()),
                                 String::ZoneHandle(function().name()), rhs);
   }
   return NULL;
 }
 
-
 const char* UnaryOpNode::TokenName() const {
   return Token::Str(kind_);
 }
 
-
 const char* JumpNode::TokenName() const {
   return Token::Str(kind_);
 }
 
-
 bool LoadLocalNode::IsPotentiallyConst() const {
   // Parameters of const constructors are implicitly final and can be
   // used in initializer expressions.
   // We can't check here whether the local variable is indeed a parameter,
   // but this code is executed before any other local variables are
   // added to the scope.
   return local().is_final();
 }
 
-
 const Instance* LoadLocalNode::EvalConstExpr() const {
   if (local().IsConst()) {
     return local().ConstValue();
   }
   return NULL;
 }
 
-
 AstNode* LoadLocalNode::MakeAssignmentNode(AstNode* rhs) {
   if (local().is_final()) {
     return NULL;
   }
   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()));
   }
   return new StoreStaticFieldNode(token_pos(),
                                   Field::ZoneHandle(field().Original()), rhs);
 }
 
-
 AstNode* InstanceGetterNode::MakeAssignmentNode(AstNode* 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();
 }
 
-
 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());
 }
 
-
 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()) {
@@ skipping 119 matching lines @@
                                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) {
   // Return this node if it represents a 'throw NoSuchMethodError' indicating
   // that a getter was not found, otherwise return null.
   const Class& cls = Class::Handle(function().Owner());
   const String& cls_name = String::Handle(cls.Name());
   const String& func_name = String::Handle(function().name());
   if (cls_name.Equals(Symbols::NoSuchMethodError()) &&
       func_name.StartsWith(Symbols::ThrowNew())) {
     return this;
   }
   return NULL;
 }
 
-
 bool StaticGetterNode::IsPotentiallyConst() const {
   if (is_deferred_reference_) {
     return false;
   }
   const String& getter_name =
       String::Handle(Field::GetterName(this->field_name()));
   const Function& getter_func =
       Function::Handle(this->cls().LookupStaticFunction(getter_name));
   if (getter_func.IsNull() || !getter_func.is_const()) {
     return false;
   }
   return true;
 }
 
-
 const Instance* StaticGetterNode::EvalConstExpr() const {
   if (is_deferred_reference_) {
     return NULL;
   }
   const String& getter_name =
       String::Handle(Field::LookupGetterSymbol(this->field_name()));
   if (getter_name.IsNull()) {
     return NULL;
   }
   const Function& getter_func =
       Function::Handle(this->cls().LookupStaticFunction(getter_name));
   if (getter_func.IsNull() || !getter_func.is_const()) {
     return NULL;
   }
   const Object& result = Object::Handle(
       DartEntry::InvokeFunction(getter_func, Object::empty_array()));
   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