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

runtime/vm/kernel_binary_flowgraph.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_binary_flowgraph.h"
 
 #include "vm/compiler.h"
 #include "vm/longjump.h"
 #include "vm/object_store.h"
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 
 namespace dart {
 namespace kernel {
 
 #define Z (zone_)
 #define H (translation_helper_)
 #define T (type_translator_)
 #define I Isolate::Current()
 
 static bool IsStaticInitializer(const Function& function, Zone* zone) {
   return (function.kind() == RawFunction::kImplicitStaticFinalGetter) &&
          dart::String::Handle(zone, function.name())
              .StartsWith(Symbols::InitPrefix());
 }
 
-
 StreamingScopeBuilder::StreamingScopeBuilder(ParsedFunction* parsed_function,
                                              intptr_t kernel_offset,
                                              const uint8_t* buffer,
                                              intptr_t buffer_length)
     : result_(NULL),
       parsed_function_(parsed_function),
       kernel_offset_(kernel_offset),
       translation_helper_(Thread::Current()),
       zone_(translation_helper_.zone()),
       current_function_scope_(NULL),
@@ skipping 772 matching lines @@
       }
       // TODO(jensj): From kernel_binary.cc
       // forinstmt->variable_->set_end_position(forinstmt->position_);
       ExitScope(position, builder_->reader_->max_position());
       --depth_.loop_;
       --depth_.for_in_;
       return;
     }
     case kSwitchStatement: {
       AddSwitchVariable();
-      VisitExpression();                           // read condition.
+      VisitExpression();                            // read condition.
       int case_count = builder_->ReadListLength();  // read number of cases.
       for (intptr_t i = 0; i < case_count; ++i) {
         int expression_count =
             builder_->ReadListLength();  // read number of expressions.
         for (intptr_t j = 0; j < expression_count; ++j) {
           builder_->ReadPosition();  // read jth position.
           VisitExpression();         // read jth expression.
         }
         builder_->ReadBool();  // read is_default.
         VisitStatement();      // read body.
@@ skipping 301 matching lines @@
   current_function_scope_ = saved_function_scope;
   current_function_async_marker_ = saved_function_async_marker;
 }
 
 void StreamingScopeBuilder::EnterScope(intptr_t kernel_offset) {
   scope_ = new (Z) LocalScope(scope_, depth_.function_, depth_.loop_);
   ASSERT(kernel_offset >= 0);
   result_->scopes.Insert(kernel_offset, scope_);
 }
 
-
 void StreamingScopeBuilder::ExitScope(TokenPosition start_position,
                                       TokenPosition end_position) {
   scope_->set_begin_token_pos(start_position);
   scope_->set_end_token_pos(end_position);
   scope_ = scope_->parent();
 }
 
 void StreamingScopeBuilder::AddPositionalAndNamedParameters(intptr_t pos) {
   // List of positional.
   intptr_t list_length = builder_->ReadListLength();  // read list length.
@@ skipping 86 matching lines @@
   }
 
   variables->Add(v);
 }
 
 void StreamingScopeBuilder::AddTryVariables() {
   AddExceptionVariable(&result_->catch_context_variables,
                        ":saved_try_context_var", depth_.try_);
 }
 
-
 void StreamingScopeBuilder::AddCatchVariables() {
   AddExceptionVariable(&result_->exception_variables, ":exception",
                        depth_.catch_);
   AddExceptionVariable(&result_->stack_trace_variables, ":stack_trace",
                        depth_.catch_);
 }
 
-
 void StreamingScopeBuilder::AddIteratorVariable() {
   if (depth_.function_ > 0) return;
   if (result_->iterator_variables.length() >= depth_.for_in_) return;
 
   ASSERT(result_->iterator_variables.length() == depth_.for_in_ - 1);
   LocalVariable* iterator =
       MakeVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
                    GenerateName(":iterator", depth_.for_in_ - 1),
                    AbstractType::dynamic_type());
   current_function_scope_->AddVariable(iterator);
@@ skipping 90 matching lines @@
     StreamingFlowGraphBuilder* builder,
     bool finalize)
     : builder_(builder),
       translation_helper_(builder->translation_helper_),
       active_class_(builder->active_class()),
       type_parameter_scope_(NULL),
       zone_(translation_helper_.zone()),
       result_(AbstractType::Handle(translation_helper_.zone())),
       finalize_(finalize) {}
 
-
 AbstractType& StreamingDartTypeTranslator::BuildType() {
   BuildTypeInternal();
 
   // We return a new `ZoneHandle` here on purpose: The intermediate language
   // instructions do not make a copy of the handle, so we do it.
   return dart::AbstractType::ZoneHandle(Z, result_.raw());
 }
 
 AbstractType& StreamingDartTypeTranslator::BuildTypeWithoutFinalization() {
   bool saved_finalize = finalize_;
@@ skipping 307 matching lines @@
       Z, Type::New(receiver_class, type_arguments, TokenPosition::kNoSource));
   if (finalize_) {
     type ^= ClassFinalizer::FinalizeType(*active_class_->klass, type);
   }
 
   const TypeArguments& instantiated_type_arguments =
       TypeArguments::ZoneHandle(Z, type.arguments());
   return instantiated_type_arguments;
 }
 
-
 const Type& StreamingDartTypeTranslator::ReceiverType(
     const dart::Class& klass) {
   ASSERT(!klass.IsNull());
   ASSERT(!klass.IsTypedefClass());
   // Note that if klass is _Closure, the returned type will be _Closure,
   // and not the signature type.
   Type& type = Type::ZoneHandle(Z, klass.CanonicalType());
   if (!type.IsNull()) {
     return type;
   }
   type = Type::New(klass, TypeArguments::Handle(Z, klass.type_parameters()),
                    klass.token_pos());
   if (klass.is_type_finalized()) {
     type ^= ClassFinalizer::FinalizeType(klass, type);
     klass.SetCanonicalType(type);
   }
   return type;
 }
 
-
 StreamingConstantEvaluator::StreamingConstantEvaluator(
     StreamingFlowGraphBuilder* builder)
     : builder_(builder),
       isolate_(Isolate::Current()),
       zone_(builder_->zone_),
       translation_helper_(builder_->translation_helper_),
       type_translator_(builder_->type_translator_),
       script_(Script::Handle(
           zone_,
           // TODO(jensj): This was added to temporarily be able to let the scope
           // builder have a StreamingFlowGraphBuilder to get access to
           // reading functions.
           (builder == NULL || builder_->flow_graph_builder_ == NULL)
               ? Script::null()
               : builder_->parsed_function()->function().script())),
       result_(Instance::Handle(zone_)) {}
 
-
 Instance& StreamingConstantEvaluator::EvaluateExpression(intptr_t offset,
                                                          bool reset_position) {
   if (!GetCachedConstant(offset, &result_)) {
     intptr_t original_offset = builder_->ReaderOffset();
     builder_->SetOffset(offset);
     uint8_t payload = 0;
     Tag tag = builder_->ReadTag(&payload);  // read tag.
     switch (tag) {
       case kVariableGet:
         EvaluateVariableGet();
@@ skipping 481 matching lines @@
   result_ = H.Canonicalize(result_);
 }
 
 void StreamingConstantEvaluator::EvaluateLet() {
   intptr_t kernel_position = builder_->ReaderOffset();
   LocalVariable* local = builder_->LookupVariable(kernel_position);
 
   // read variable declaration.
   VariableDeclarationHelper helper(builder_);
   helper.ReadUntilExcluding(VariableDeclarationHelper::kInitializer);
-  Tag tag = builder_->ReadTag();    // read (first part of) initializer.
+  Tag tag = builder_->ReadTag();  // read (first part of) initializer.
   if (tag == kNothing) {
     local->SetConstValue(Instance::ZoneHandle(Z, dart::Instance::null()));
   } else {
     local->SetConstValue(EvaluateExpression(
         builder_->ReaderOffset(), false));  // read rest of initializer.
   }
 
   EvaluateExpression(builder_->ReaderOffset(), false);  // read body
 }
 
@@ skipping 185 matching lines @@
   // Mutator compiler thread may add constants while background compiler
   // is running, and thus change the value of 'compile_time_constants';
   // do not assert that 'compile_time_constants' has not changed.
   constants.Release();
   if (FLAG_compiler_stats && is_present) {
     ++H.thread()->compiler_stats()->num_const_cache_hits;
   }
   return is_present;
 }
 
-
 void StreamingConstantEvaluator::CacheConstantValue(intptr_t kernel_offset,
                                                     const Instance& value) {
   ASSERT(Thread::Current()->IsMutatorThread());
 
   if (builder_ == NULL || builder_->flow_graph_builder_ == NULL) return;
 
   const Function& function = builder_->parsed_function()->function();
   if (function.kind() == RawFunction::kImplicitStaticFinalGetter) {
     // Don't cache constants in initializer expressions. They get
     // evaluated only once.
@@ skipping 940 matching lines @@
     case RawFunction::kInvokeFieldDispatcher:
       return flow_graph_builder_->BuildGraphOfInvokeFieldDispatcher(function);
     case RawFunction::kSignatureFunction:
     case RawFunction::kIrregexpFunction:
       break;
   }
   UNREACHABLE();
   return NULL;
 }
 
-
 Fragment StreamingFlowGraphBuilder::BuildStatementAt(intptr_t kernel_offset) {
   SetOffset(kernel_offset);
   return BuildStatement();  // read statement.
 }
 
 Fragment StreamingFlowGraphBuilder::BuildExpression(TokenPosition* position) {
   uint8_t payload = 0;
   Tag tag = ReadTag(&payload);  // read tag.
   switch (tag) {
     case kInvalidExpression:
@@ skipping 286 matching lines @@
 void StreamingFlowGraphBuilder::SkipInterfaceType(bool simple) {
   ReadUInt();  // read klass_name.
   if (!simple) {
     SkipListOfDartTypes();  // read list of types.
   }
 }
 
 void StreamingFlowGraphBuilder::SkipFunctionType(bool simple) {
   if (!simple) {
     SkipTypeParametersList();  // read type_parameters.
-    ReadUInt();  // read required parameter count.
-    ReadUInt();  // read total parameter count.
+    ReadUInt();                // read required parameter count.
+    ReadUInt();                // read total parameter count.
   }
 
   SkipListOfDartTypes();  // read positional_parameters types.
 
   if (!simple) {
     const intptr_t named_count =
         ReadListLength();  // read named_parameters list length.
     for (intptr_t i = 0; i < named_count; ++i) {
       // read string reference (i.e. named_parameters[i].name).
       SkipStringReference();
@@ skipping 128 matching lines @@
       SkipBytes(1);      // read operator.
       SkipExpression();  // read right.
       return;
     case kConditionalExpression:
       SkipExpression();        // read condition.
       SkipExpression();        // read then.
       SkipExpression();        // read otherwise.
       SkipOptionalDartType();  // read unused static type.
       return;
     case kStringConcatenation:
-      ReadPosition();                           // read position.
-      SkipListOfExpressions();                  // read list of expressions.
+      ReadPosition();           // read position.
+      SkipListOfExpressions();  // read list of expressions.
       return;
     case kIsExpression:
       ReadPosition();    // read position.
       SkipExpression();  // read operand.
       SkipDartType();    // read type.
       return;
     case kAsExpression:
       ReadPosition();    // read position.
       SkipExpression();  // read operand.
       SkipDartType();    // read type.
       return;
     case kSymbolLiteral:
       SkipStringReference();  // read index into string table.
       return;
     case kTypeLiteral:
       SkipDartType();  // read type.
       return;
     case kThisExpression:
       return;
     case kRethrow:
       ReadPosition();  // read position.
       return;
     case kThrow:
       ReadPosition();    // read position.
       SkipExpression();  // read expression.
       return;
     case kListLiteral:
     case kConstListLiteral:
-      ReadPosition();                           // read position.
-      SkipDartType();                           // read type.
-      SkipListOfExpressions();                  // read list of expressions.
+      ReadPosition();           // read position.
+      SkipDartType();           // read type.
+      SkipListOfExpressions();  // read list of expressions.
       return;
     case kMapLiteral:
     case kConstMapLiteral: {
       ReadPosition();                           // read position.
       SkipDartType();                           // read key type.
       SkipDartType();                           // read value type.
       intptr_t list_length = ReadListLength();  // read list length.
       for (intptr_t i = 0; i < list_length; ++i) {
         SkipExpression();  // read ith key.
         SkipExpression();  // read ith value.
@@ skipping 72 matching lines @@
     case kWhileStatement:
       SkipExpression();  // read condition.
       SkipStatement();   // read body.
       return;
     case kDoStatement:
       SkipStatement();   // read body.
       SkipExpression();  // read condition.
       return;
     case kForStatement: {
       SkipListOfVariableDeclarations();  // read variables.
-      Tag tag = ReadTag();  // Read first part of condition.
+      Tag tag = ReadTag();               // Read first part of condition.
       if (tag == kSomething) {
         SkipExpression();  // read rest of condition.
       }
       SkipListOfExpressions();  // read updates.
-      SkipStatement();  // read body.
+      SkipStatement();          // read body.
       return;
     }
     case kForInStatement:
     case kAsyncForInStatement:
       ReadPosition();             // read position.
       SkipVariableDeclaration();  // read variable.
       SkipExpression();           // read iterable.
       SkipStatement();            // read body.
       return;
     case kSwitchStatement: {
-      SkipExpression();                  // read condition.
+      SkipExpression();                   // read condition.
       int case_count = ReadListLength();  // read number of cases.
       for (intptr_t i = 0; i < case_count; ++i) {
         int expression_count = ReadListLength();  // read number of expressions.
         for (intptr_t j = 0; j < expression_count; ++j) {
           ReadPosition();    // read jth position.
           SkipExpression();  // read jth expression.
         }
         ReadBool();       // read is_default.
         SkipStatement();  // read body.
       }
@@ skipping 272 matching lines @@
   intptr_t list_length = ReadListLength();  // read types list length.
   return T.BuildInstantiatedTypeArguments(klass, list_length);  // read types.
 }
 
 intptr_t StreamingFlowGraphBuilder::PeekArgumentsCount() {
   return PeekUInt();
 }
 
 intptr_t StreamingFlowGraphBuilder::PeekArgumentsTypeCount() {
   AlternativeReadingScope alt(reader_);
-  ReadUInt();                               // read arguments count.
-  return ReadListLength();                  // read length of types list.
+  ReadUInt();               // read arguments count.
+  return ReadListLength();  // read length of types list.
 }
 
 void StreamingFlowGraphBuilder::SkipArgumentsBeforeActualArguments() {
-  ReadUInt();  // read arguments count.
+  ReadUInt();             // read arguments count.
   SkipListOfDartTypes();  // read list of types.
 }
 
 LocalVariable* StreamingFlowGraphBuilder::LookupVariable(
     intptr_t kernel_offset) {
   return flow_graph_builder_->LookupVariable(kernel_offset);
 }
 
 LocalVariable* StreamingFlowGraphBuilder::MakeTemporary() {
   return flow_graph_builder_->MakeTemporary();
@@ skipping 1042 matching lines @@
 
     // Let condition be always true.
     instructions += Constant(Bool::True());
   } else {
     instructions += PushArgument();
 
     // See if simple instanceOf is applicable.
     if (dart::FlowGraphBuilder::SimpleInstanceOfType(type)) {
       instructions += Constant(type);
       instructions += PushArgument();  // Type.
-      instructions += InstanceCall(position, dart::Library::PrivateCoreLibName(
-                                                 Symbols::_simpleInstanceOf()),
-                                   Token::kIS, 2, 2);  // 2 checked arguments.
+      instructions += InstanceCall(
+          position,
+          dart::Library::PrivateCoreLibName(Symbols::_simpleInstanceOf()),
+          Token::kIS, 2, 2);  // 2 checked arguments.
       return instructions;
     }
 
     if (!type.IsInstantiated(kCurrentClass)) {
       instructions += LoadInstantiatorTypeArguments();
     } else {
       instructions += NullConstant();
     }
     instructions += PushArgument();  // Instantiator type arguments.
 
@@ skipping 240 matching lines @@
 
       instructions += LoadLocal(array);
       instructions += IntConstant(2 * i + 1);
       instructions += BuildExpression();  // read ith value.
       instructions += StoreIndexed(kArrayCid);
       instructions += Drop();
     }
   }
   instructions += PushArgument();  // The array.
 
-
   const dart::Class& map_class =
       dart::Class::Handle(Z, dart::Library::LookupCoreClass(Symbols::Map()));
   const Function& factory_method = Function::ZoneHandle(
       Z, map_class.LookupFactory(
              dart::Library::PrivateCoreLibName(Symbols::MapLiteralFactory())));
 
   return instructions + StaticCall(position, factory_method, 2);
 }
 
 Fragment StreamingFlowGraphBuilder::BuildFunctionExpression() {
   intptr_t offset = ReaderOffset() - 1;  // -1 to include tag byte.
   return BuildFunctionNode(offset, TokenPosition::kNoSource, false, -1);
 }
 
 Fragment StreamingFlowGraphBuilder::BuildLet(TokenPosition* position) {
   if (position != NULL) *position = TokenPosition::kNoSource;
 
-  Fragment instructions = BuildVariableDeclaration();       // read variable.
-  instructions += BuildExpression();                        // read body.
+  Fragment instructions = BuildVariableDeclaration();  // read variable.
+  instructions += BuildExpression();                   // read body.
   return instructions;
 }
 
-
 Fragment StreamingFlowGraphBuilder::BuildBigIntLiteral(
     TokenPosition* position) {
   if (position != NULL) *position = TokenPosition::kNoSource;
 
   const dart::String& value =
       H.DartString(ReadStringReference());  // read index into string table.
   return Constant(Integer::ZoneHandle(Z, Integer::New(value, Heap::kOld)));
 }
 
 Fragment StreamingFlowGraphBuilder::BuildStringLiteral(
@@ skipping 113 matching lines @@
   const dart::Function& target = dart::Function::ZoneHandle(
       Z, klass.LookupStaticFunctionAllowPrivate(Symbols::ThrowNew()));
   ASSERT(!target.IsNull());
 
   // Build call to _AsertionError._throwNew(start, end, message)
   Fragment otherwise_fragment(otherwise);
   otherwise_fragment += IntConstant(condition_start_offset.Pos());
   otherwise_fragment += PushArgument();  // start
   otherwise_fragment += IntConstant(condition_end_offset.Pos());
   otherwise_fragment += PushArgument();  // end
-  Tag tag = ReadTag();  // read (first part of) message.
+  Tag tag = ReadTag();                   // read (first part of) message.
   if (tag == kSomething) {
     otherwise_fragment += BuildExpression();  // read (rest of) message.
   } else {
     otherwise_fragment += Constant(Instance::ZoneHandle(Z));  // null.
   }
   otherwise_fragment += PushArgument();  // message
 
   otherwise_fragment += StaticCall(TokenPosition::kNoSource, target, 3);
   otherwise_fragment += Drop();
 
@@ skipping 62 matching lines @@
     body += Goto(join);
 
     Fragment loop(join);
     loop += CheckStackOverflow();
     loop += condition;
     entry = new (Z) GotoInstr(join, Thread::Current()->GetNextDeoptId());
   } else {
     entry = condition.entry;
   }
 
-
   loop_depth_dec();
   return Fragment(entry, loop_exit);
 }
 
 Fragment StreamingFlowGraphBuilder::BuildDoStatement() {
   loop_depth_inc();
   Fragment body = BuildStatement();  // read body.
 
   if (body.is_closed()) {
     SkipExpression();  // read condition.
@@ skipping 136 matching lines @@
   }
 
   loop_depth_dec();
   for_in_depth_dec();
   return Fragment(instructions.entry, loop_exit);
 }
 
 Fragment StreamingFlowGraphBuilder::BuildSwitchStatement() {
   // We need the number of cases. So start by getting that, then go back.
   intptr_t offset = ReaderOffset();
-  SkipExpression();                  // temporarily skip condition
+  SkipExpression();                   // temporarily skip condition
   int case_count = ReadListLength();  // read number of cases.
   SetOffset(offset);
 
   SwitchBlock block(flow_graph_builder_, case_count);
 
   // Instead of using a variable we should reuse the expression on the stack,
   // since it won't be assigned again, we don't need phi nodes.
   Fragment head_instructions = BuildExpression();  // read condition.
   head_instructions +=
       StoreLocal(TokenPosition::kNoSource, scopes()->switch_variable);
@@ skipping 392 matching lines @@
 
   return Fragment(try_body.entry, after_try);
 }
 
 Fragment StreamingFlowGraphBuilder::BuildTryFinally() {
   // Note on streaming:
   // We only stream this TryFinally if we can stream everything inside it,
   // so creating a "TryFinallyBlock" with a kernel binary offset instead of an
   // AST node isn't a problem.
 
-
   InlineBailout("kernel::FlowgraphBuilder::VisitTryFinally");
 
   // There are 5 different cases where we need to execute the finally block:
   //
   //  a) 1/2/3th case: Special control flow going out of `node->body()`:
   //
   //   * [BreakStatement] transfers control to a [LabledStatement]
   //   * [ContinueSwitchStatement] transfers control to a [SwitchCase]
   //   * [ReturnStatement] returns a value
   //
@@ skipping 131 matching lines @@
     continuation += BranchIfNull(&no_error, &error);
 
     Fragment rethrow(error);
     rethrow += LoadLocal(exception_var);
     rethrow += PushArgument();
     rethrow += LoadLocal(stack_trace_var);
     rethrow += PushArgument();
     rethrow += RethrowException(position, CatchClauseNode::kInvalidTryIndex);
     Drop();
 
-
     continuation = Fragment(continuation.entry, no_error);
   }
 
   return continuation;
 }
 
 Fragment StreamingFlowGraphBuilder::BuildVariableDeclaration() {
   intptr_t kernel_position_no_tag = ReaderOffset();
   LocalVariable* variable = LookupVariable(kernel_position_no_tag);
 
   VariableDeclarationHelper helper(this);
   helper.ReadUntilExcluding(VariableDeclarationHelper::kType);
   dart::String& name = H.DartSymbol(helper.name_index_);
-  AbstractType& type = T.BuildType();                        // read type.
-  Tag tag = ReadTag();  // read (first part of) initializer.
+  AbstractType& type = T.BuildType();  // read type.
+  Tag tag = ReadTag();                 // read (first part of) initializer.
 
   Fragment instructions;
   if (tag == kNothing) {
     instructions += NullConstant();
   } else {
     if (helper.IsConst()) {
       const Instance& constant_value = constant_evaluator_.EvaluateExpression(
           ReaderOffset());  // read initializer form current position.
       variable->SetConstValue(constant_value);
       instructions += Constant(constant_value);
@@ skipping 148 matching lines @@
       TokenPosition::kNoSource, Closure::function_offset());
 
   instructions += LoadLocal(closure);
   instructions += LoadLocal(parsed_function()->current_context_var());
   instructions += flow_graph_builder_->StoreInstanceField(
       TokenPosition::kNoSource, Closure::context_offset());
 
   return instructions;
 }
 
-
 void StreamingFlowGraphBuilder::SetupFunctionParameters(
     const dart::Class& klass,
     const dart::Function& function,
     bool is_method,
     bool is_closure,
     FunctionNodeHelper* function_node_helper) {
   ASSERT(!(is_method && is_closure));
   bool is_factory = function.IsFactory();
   intptr_t extra_parameters = (is_method || is_closure || is_factory) ? 1 : 0;
 
@@ skipping 287 matching lines @@
     }
   }
 
   return Array::Handle(Array::null());
 }
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)