clang-format runtime/vm

runtime/vm/kernel_to_il.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 <map>
 #include <set>
 #include <string>
 
 #include "vm/kernel_to_il.h"
 
@@ skipping 45 matching lines @@
   }
 }
 
 
 void ScopeBuilder::EnterScope(TreeNode* node) {
   scope_ = new (Z) LocalScope(scope_, depth_.function_, depth_.loop_);
   result_->scopes.Insert(node, scope_);
 }
 
 
-void ScopeBuilder::ExitScope() { scope_ = scope_->parent(); }
+void ScopeBuilder::ExitScope() {
+  scope_ = scope_->parent();
+}
 
 
 LocalVariable* ScopeBuilder::MakeVariable(const dart::String& name,
                                           const AbstractType& type) {
   return new (Z) LocalVariable(TokenPosition::kNoSource,
-                               TokenPosition::kNoSource,
-                               name,
-                               type);
+                               TokenPosition::kNoSource, name, type);
 }
 
 
 void ScopeBuilder::AddParameters(FunctionNode* function, intptr_t pos) {
   List<VariableDeclaration>& positional = function->positional_parameters();
   for (intptr_t i = 0; i < positional.length(); ++i) {
     AddParameter(positional[i], pos++);
   }
   List<VariableDeclaration>& named = function->named_parameters();
   for (intptr_t i = 0; i < named.length(); ++i) {
     AddParameter(named[i], pos++);
   }
 }
 
 
 void ScopeBuilder::AddParameter(VariableDeclaration* declaration,
                                 intptr_t pos) {
-  LocalVariable* variable =
-      MakeVariable(H.DartSymbol(declaration->name()),
-                   T.TranslateVariableType(declaration));
+  LocalVariable* variable = MakeVariable(H.DartSymbol(declaration->name()),
+                                         T.TranslateVariableType(declaration));
   if (declaration->IsFinal()) {
     variable->set_is_final();
   }
   scope_->InsertParameterAt(pos, variable);
   result_->locals.Insert(declaration, variable);
 
   // The default value may contain 'let' bindings for which the constant
   // evaluator needs scope bindings.
   Expression* defaultValue = declaration->initializer();
   if (defaultValue != NULL) {
     defaultValue->AcceptExpressionVisitor(this);
   }
 }
 
 
 void ScopeBuilder::AddExceptionVariable(
-    GrowableArray<LocalVariable*>* variables, const char* prefix,
+    GrowableArray<LocalVariable*>* variables,
+    const char* prefix,
     intptr_t nesting_depth) {
   LocalVariable* v = NULL;
 
   // If we are inside a function with yield points then Kernel transformer
   // could have lifted some of the auxiliary exception variables into the
   // context to preserve them across yield points because they might
   // be needed for rethrow.
   // Check if it did and capture such variables instead of introducing
   // new local ones.
   // Note: function that wrap kSyncYielding function does not contain
@@ skipping 139 matching lines @@
   ParsedFunction* parsed_function = parsed_function_;
   const dart::Function& function = parsed_function->function();
 
   // Setup a [ActiveClassScope] and a [ActiveMemberScope] which will be used
   // e.g. for type translation.
   const dart::Class& klass =
       dart::Class::Handle(zone_, parsed_function_->function().Owner());
   Function& outermost_function = Function::Handle(Z);
   TreeNode* outermost_node = NULL;
   Class* kernel_klass = NULL;
-  DiscoverEnclosingElements(
-      Z, function, &outermost_function, &outermost_node, &kernel_klass);
+  DiscoverEnclosingElements(Z, function, &outermost_function, &outermost_node,
+                            &kernel_klass);
   // Use [klass]/[kernel_klass] as active class.  Type parameters will get
   // resolved via [kernel_klass] unless we are nested inside a static factory
   // in which case we will use [member].
   ActiveClassScope active_class_scope(&active_class_, kernel_klass, &klass);
   Member* member = ((outermost_node != NULL) && outermost_node->IsMember())
                        ? Member::Cast(outermost_node)
                        : NULL;
   ActiveMemberScope active_member(&active_class_, member);
 
 
@@ skipping 23 matching lines @@
         node = Procedure::Cast(node_)->function();
       } else if (node_->IsConstructor()) {
         node = Constructor::Cast(node_)->function();
       } else {
         node = FunctionNode::Cast(node_);
       }
       current_function_node_ = node;
 
       intptr_t pos = 0;
       if (function.IsClosureFunction()) {
-        LocalVariable* variable =
-            MakeVariable(Symbols::ClosureParameter(),
-                         AbstractType::dynamic_type());
+        LocalVariable* variable = MakeVariable(Symbols::ClosureParameter(),
+                                               AbstractType::dynamic_type());
         variable->set_is_forced_stack();
         scope_->InsertParameterAt(pos++, variable);
       } else if (!function.is_static()) {
         // We use [is_static] instead of [IsStaticFunction] because the latter
         // returns `false` for constructors.
         dart::Class& klass = dart::Class::Handle(Z, function.Owner());
         Type& klass_type = H.GetCanonicalType(klass);
         LocalVariable* variable = MakeVariable(Symbols::This(), klass_type);
         scope_->InsertParameterAt(pos++, variable);
         result_->this_variable = variable;
 
         // We visit instance field initializers because they might contain
         // [Let] expressions and we need to have a mapping.
         if (node_->IsConstructor()) {
           Class* klass = Class::Cast(Constructor::Cast(node_)->parent());
 
           for (intptr_t i = 0; i < klass->fields().length(); i++) {
             Field* field = klass->fields()[i];
             if (!field->IsStatic() && (field->initializer() != NULL)) {
               EnterScope(field);
               field->initializer()->AcceptExpressionVisitor(this);
               ExitScope();
             }
           }
         }
       } else if (function.IsFactory()) {
         LocalVariable* variable = MakeVariable(
-            Symbols::TypeArgumentsParameter(),
-            AbstractType::dynamic_type());
+            Symbols::TypeArgumentsParameter(), AbstractType::dynamic_type());
         scope_->InsertParameterAt(pos++, variable);
         result_->type_arguments_variable = variable;
       }
       AddParameters(node, pos);
 
       // We generate a syntethic body for implicit closure functions - which
       // will forward the call to the real function.
       //     -> see BuildGraphOfImplicitClosureFunction
       if (!function.IsImplicitClosureFunction()) {
         node_->AcceptVisitor(this);
@@ skipping 12 matching lines @@
       bool is_method = !function.IsStaticFunction();
       intptr_t pos = 0;
       if (is_method) {
         dart::Class& klass = dart::Class::Handle(Z, function.Owner());
         Type& klass_type = H.GetCanonicalType(klass);
         LocalVariable* variable = MakeVariable(Symbols::This(), klass_type);
         scope_->InsertParameterAt(pos++, variable);
         result_->this_variable = variable;
       }
       if (is_setter) {
-        result_->setter_value = MakeVariable(
-            Symbols::Value(), AbstractType::dynamic_type());
+        result_->setter_value =
+            MakeVariable(Symbols::Value(), AbstractType::dynamic_type());
         scope_->InsertParameterAt(pos++, result_->setter_value);
       }
       break;
     }
     case RawFunction::kMethodExtractor: {
       // Add a receiver parameter.  Though it is captured, we emit code to
       // explicitly copy it to a fixed offset in a freshly-allocated context
       // instead of using the generic code for regular functions.
       // Therefore, it isn't necessary to mark it as captured here.
       dart::Class& klass = dart::Class::Handle(Z, function.Owner());
@@ skipping 176 matching lines @@
   VisitVariableDeclaration(node->variable());
   node->body()->AcceptStatementVisitor(this);
   ExitScope();
   --depth_.loop_;
   --depth_.for_in_;
 }
 
 
 void ScopeBuilder::AddSwitchVariable() {
   if ((depth_.function_ == 0) && (result_->switch_variable == NULL)) {
-    LocalVariable* variable = MakeVariable(
-        Symbols::SwitchExpr(),
-        AbstractType::dynamic_type());
+    LocalVariable* variable =
+        MakeVariable(Symbols::SwitchExpr(), AbstractType::dynamic_type());
     variable->set_is_forced_stack();
     current_function_scope_->AddVariable(variable);
     result_->switch_variable = variable;
   }
 }
 
 
 void ScopeBuilder::VisitSwitchStatement(SwitchStatement* node) {
   AddSwitchVariable();
   node->VisitChildren(this);
 }
 
 
 void ScopeBuilder::VisitReturnStatement(ReturnStatement* node) {
   if ((depth_.function_ == 0) && (depth_.finally_ > 0) &&
       (result_->finally_return_variable == NULL)) {
     const dart::String& name = H.DartSymbol(":try_finally_return_value");
-    LocalVariable* variable = MakeVariable(
-        name,
-        AbstractType::dynamic_type());
+    LocalVariable* variable = MakeVariable(name, AbstractType::dynamic_type());
     current_function_scope_->AddVariable(variable);
     result_->finally_return_variable = variable;
   }
   node->VisitChildren(this);
 }
 
 
 void ScopeBuilder::VisitTryCatch(TryCatch* node) {
   ++depth_.try_;
   AddTryVariables();
@@ skipping 269 matching lines @@
 
  private:
   FlowGraphBuilder* builder_;
   TryCatchBlock* outer_;
   intptr_t try_index_;
 };
 
 
 class CatchBlock {
  public:
-  CatchBlock(FlowGraphBuilder* builder, LocalVariable* exception_var,
-             LocalVariable* stack_trace_var, intptr_t catch_try_index)
+  CatchBlock(FlowGraphBuilder* builder,
+             LocalVariable* exception_var,
+             LocalVariable* stack_trace_var,
+             intptr_t catch_try_index)
       : builder_(builder),
         outer_(builder->catch_block_),
         exception_var_(exception_var),
         stack_trace_var_(stack_trace_var),
         catch_try_index_(catch_try_index) {
     builder_->catch_block_ = this;
   }
   ~CatchBlock() { builder_->catch_block_ = outer_; }
 
   LocalVariable* exception_var() { return exception_var_; }
@@ skipping 123 matching lines @@
   // The VM uses `get:fieldname` and `set:fieldname`.
   //
   // => In order to be consistent, we remove the `=` always and adopt the VM
   //    conventions.
   String* content = kernel_name->string();
   ASSERT(content->size() > 0);
   intptr_t skip = 0;
   if (content->buffer()[content->size() - 1] == '=') {
     skip = 1;
   }
-  dart::String& name = dart::String::ZoneHandle(Z, dart::String::FromUTF8(
-        content->buffer(), content->size() - skip, allocation_space_));
+  dart::String& name = dart::String::ZoneHandle(
+      Z, dart::String::FromUTF8(content->buffer(), content->size() - skip,
+                                allocation_space_));
   ManglePrivateName(kernel_name->library(), &name, false);
   name = dart::Field::SetterSymbol(name);
   return name;
 }
 
 
 const dart::String& TranslationHelper::DartGetterName(Name* kernel_name) {
   dart::String& name = DartString(kernel_name->string());
   ManglePrivateName(kernel_name->library(), &name, false);
   name = dart::Field::GetterSymbol(name);
@@ skipping 118 matching lines @@
 dart::RawFunction* TranslationHelper::LookupConstructorByKernelConstructor(
     Constructor* constructor) {
   Class* kernel_klass = Class::Cast(constructor->parent());
   dart::Class& klass =
       dart::Class::Handle(Z, LookupClassByKernelClass(kernel_klass));
   return LookupConstructorByKernelConstructor(klass, constructor);
 }
 
 
 dart::RawFunction* TranslationHelper::LookupConstructorByKernelConstructor(
-    const dart::Class& owner, Constructor* constructor) {
+    const dart::Class& owner,
+    Constructor* constructor) {
   dart::RawFunction* function =
       owner.LookupConstructorAllowPrivate(DartConstructorName(constructor));
   ASSERT(function != Object::null());
   return function;
 }
 
 
 dart::Type& TranslationHelper::GetCanonicalType(const dart::Class& klass) {
   ASSERT(!klass.IsNull());
   // Note that if cls is _Closure, the returned type will be _Closure,
@@ skipping 19 matching lines @@
 
   va_list args;
   va_start(args, format);
   Report::MessageV(Report::kError, null_script, TokenPosition::kNoSource,
                    Report::AtLocation, format, args);
   va_end(args);
   UNREACHABLE();
 }
 
 
-void TranslationHelper::ReportError(const Error& prev_error, const char* format,
+void TranslationHelper::ReportError(const Error& prev_error,
+                                    const char* format,
                                     ...) {
   const Script& null_script = Script::Handle(Z);
 
   va_list args;
   va_start(args, format);
   Report::LongJumpV(prev_error, null_script, TokenPosition::kNoSource, format,
                     args);
   va_end(args);
   UNREACHABLE();
 }
 
 
 dart::String& TranslationHelper::ManglePrivateName(Library* kernel_library,
                                                    dart::String* name_to_modify,
                                                    bool symbolize) {
   if (name_to_modify->Length() >= 1 && name_to_modify->CharAt(0) == '_') {
     const dart::Library& library =
         dart::Library::Handle(Z, LookupLibraryByKernelLibrary(kernel_library));
     *name_to_modify = library.PrivateName(*name_to_modify);
   } else if (symbolize) {
     *name_to_modify = Symbols::New(thread_, *name_to_modify);
   }
   return *name_to_modify;
 }
 
 
 const Array& TranslationHelper::ArgumentNames(List<NamedExpression>* named) {
   if (named->length() == 0) return Array::ZoneHandle(Z);
 
-  const Array& names = Array::ZoneHandle(Z,
-      Array::New(named->length(), allocation_space_));
+  const Array& names =
+      Array::ZoneHandle(Z, Array::New(named->length(), allocation_space_));
   for (intptr_t i = 0; i < named->length(); ++i) {
     names.SetAt(i, DartSymbol((*named)[i]->name()));
   }
   return names;
 }
 
 
 ConstantEvaluator::ConstantEvaluator(FlowGraphBuilder* builder,
                                      Zone* zone,
                                      TranslationHelper* h,
                                      DartTypeTranslator* type_translator)
     : builder_(builder),
       isolate_(Isolate::Current()),
       zone_(zone),
       translation_helper_(*h),
       type_translator_(*type_translator),
       script_(dart::Script::Handle(
-            zone, builder_->parsed_function_->function().script())),
+          zone,
+          builder_->parsed_function_->function().script())),
       result_(dart::Instance::Handle(zone)) {}
 
 
 Instance& ConstantEvaluator::EvaluateExpression(Expression* expression) {
   if (!GetCachedConstant(expression, &result_)) {
     expression->AcceptExpressionVisitor(this);
     CacheConstantValue(expression, result_);
   }
   // We return a new `ZoneHandle` here on purpose: The intermediate language
   // instructions do not make a copy of the handle, so we do it.
@@ skipping 86 matching lines @@
 void ConstantEvaluator::VisitTypeLiteral(TypeLiteral* node) {
   const AbstractType& type = T.TranslateType(node->type());
   if (type.IsMalformed()) {
     H.ReportError("Malformed type literal in constant expression.");
   }
   result_ = type.raw();
 }
 
 
 RawObject* ConstantEvaluator::EvaluateConstConstructorCall(
-    const dart::Class& type_class, const TypeArguments& type_arguments,
-    const Function& constructor, const Object& argument) {
+    const dart::Class& type_class,
+    const TypeArguments& type_arguments,
+    const Function& constructor,
+    const Object& argument) {
   // Factories have one extra argument: the type arguments.
   // Constructors have 1 extra arguments: receiver.
   const int kNumArgs = 1;
   const int kNumExtraArgs = 1;
   const int num_arguments = kNumArgs + kNumExtraArgs;
   const Array& arg_values =
       Array::Handle(Z, Array::New(num_arguments, Heap::kOld));
   Instance& instance = Instance::Handle(Z);
   if (!constructor.IsFactory()) {
     instance = Instance::New(type_class, Heap::kOld);
@@ skipping 54 matching lines @@
 
   const Function& function = builder_->parsed_function_->function();
   if (function.kind() == RawFunction::kImplicitStaticFinalGetter) {
     // Don't cache constants in initializer expressions. They get
     // evaluated only once.
     return;
   }
   const intptr_t kInitialConstMapSize = 16;
   ASSERT(!script_.InVMHeap());
   if (script_.compile_time_constants() == Array::null()) {
-    const Array& array =
-        Array::Handle(HashTables::New<KernelConstantsMap>(kInitialConstMapSize,
-                                                          Heap::kNew));
+    const Array& array = Array::Handle(
+        HashTables::New<KernelConstantsMap>(kInitialConstMapSize, Heap::kNew));
     script_.set_compile_time_constants(array);
   }
   KernelConstantsMap constants(script_.compile_time_constants());
   constants.InsertNewOrGetValue(node, value);
   script_.set_compile_time_constants(constants.Release());
 }
 
 
 void ConstantEvaluator::VisitSymbolLiteral(SymbolLiteral* node) {
   const dart::String& symbol_value = H.DartSymbol(node->value());
@@ skipping 265 matching lines @@
 
 void ConstantEvaluator::VisitNot(Not* node) {
   EvaluateExpression(node->expression());
   ASSERT(result_.IsBool());
   result_ =
       Bool::Cast(result_).value() ? Bool::False().raw() : Bool::True().raw();
 }
 
 
 const TypeArguments* ConstantEvaluator::TranslateTypeArguments(
-    const Function& target, dart::Class* target_klass,
+    const Function& target,
+    dart::Class* target_klass,
     Arguments* kernel_arguments) {
   List<DartType>& kernel_type_arguments = kernel_arguments->types();
 
   const TypeArguments* type_arguments = NULL;
   if (kernel_type_arguments.length() > 0) {
     type_arguments = &T.TranslateInstantiatedTypeArguments(
         *target_klass, kernel_type_arguments.raw_array(),
         kernel_type_arguments.length());
 
     if (!(type_arguments->IsNull() || type_arguments->IsInstantiated())) {
@@ skipping 51 matching lines @@
   const Object& result = Object::Handle(
       Z, DartEntry::InvokeFunction(function, arguments, args_descriptor));
   if (result.IsError()) {
     H.ReportError(Error::Cast(result), "error evaluating constant constructor");
   }
   return result;
 }
 
 
 FlowGraphBuilder::FlowGraphBuilder(
-    TreeNode* node, ParsedFunction* parsed_function,
+    TreeNode* node,
+    ParsedFunction* parsed_function,
     const ZoneGrowableArray<const ICData*>& ic_data_array,
-    InlineExitCollector* exit_collector, intptr_t osr_id,
+    InlineExitCollector* exit_collector,
+    intptr_t osr_id,
     intptr_t first_block_id)
     : zone_(Thread::Current()->zone()),
-      translation_helper_(Thread::Current(), zone_,
+      translation_helper_(Thread::Current(),
+                          zone_,
                           Thread::Current()->isolate()),
       node_(node),
       parsed_function_(parsed_function),
       osr_id_(osr_id),
       ic_data_array_(ic_data_array),
       exit_collector_(exit_collector),
       next_block_id_(first_block_id),
       next_function_id_(0),
       context_depth_(0),
       loop_depth_(0),
       try_depth_(0),
       catch_depth_(0),
       for_in_depth_(0),
       stack_(NULL),
       pending_argument_count_(0),
       graph_entry_(NULL),
       scopes_(NULL),
       breakable_block_(NULL),
       switch_block_(NULL),
       try_finally_block_(NULL),
       try_catch_block_(NULL),
       next_used_try_index_(0),
       catch_block_(NULL),
       type_translator_(&translation_helper_, &active_class_),
-      constant_evaluator_(this, zone_, &translation_helper_,
+      constant_evaluator_(this,
+                          zone_,
+                          &translation_helper_,
                           &type_translator_) {}
 
 
 FlowGraphBuilder::~FlowGraphBuilder() {}
 
 
 Fragment FlowGraphBuilder::TranslateFinallyFinalizers(
-    TryFinallyBlock* outer_finally, intptr_t target_context_depth) {
+    TryFinallyBlock* outer_finally,
+    intptr_t target_context_depth) {
   TryFinallyBlock* const saved_block = try_finally_block_;
   const intptr_t saved_depth = context_depth_;
   const intptr_t saved_try_depth = try_depth_;
 
   Fragment instructions;
 
   // While translating the body of a finalizer we need to set the try-finally
   // block which is active when translating the body.
   while (try_finally_block_ != outer_finally) {
     // Set correct try depth (in case there are nested try statements).
@@ skipping 243 matching lines @@
       TokenPosition::kNoSource, negate ? Token::kNE_STRICT : Token::kEQ_STRICT,
       left_value, right_value, false);
   BranchInstr* branch = new (Z) BranchInstr(compare);
   *then_entry = *branch->true_successor_address() = BuildTargetEntry();
   *otherwise_entry = *branch->false_successor_address() = BuildTargetEntry();
   return Fragment(branch).closed();
 }
 
 
 Fragment FlowGraphBuilder::BranchIfStrictEqual(
-    TargetEntryInstr** then_entry, TargetEntryInstr** otherwise_entry) {
+    TargetEntryInstr** then_entry,
+    TargetEntryInstr** otherwise_entry) {
   Value* rhs = Pop();
   Value* lhs = Pop();
   StrictCompareInstr* compare = new (Z) StrictCompareInstr(
       TokenPosition::kNoSource, Token::kEQ_STRICT, lhs, rhs, false);
   BranchInstr* branch = new (Z) BranchInstr(compare);
   *then_entry = *branch->true_successor_address() = BuildTargetEntry();
   *otherwise_entry = *branch->false_successor_address() = BuildTargetEntry();
   return Fragment(branch).closed();
 }
 
 
 Fragment FlowGraphBuilder::CatchBlockEntry(const Array& handler_types,
                                            intptr_t handler_index) {
   ASSERT(CurrentException()->is_captured() ==
-             CurrentStackTrace()->is_captured());
+         CurrentStackTrace()->is_captured());
   const bool should_restore_closure_context =
-      CurrentException()->is_captured() ||
-      CurrentCatchContext()->is_captured();
+      CurrentException()->is_captured() || CurrentCatchContext()->is_captured();
   CatchBlockEntryInstr* entry = new (Z) CatchBlockEntryInstr(
       AllocateBlockId(), CurrentTryIndex(), graph_entry_, handler_types,
       handler_index, *CurrentException(), *CurrentStackTrace(),
       /* needs_stacktrace = */ true, Thread::Current()->GetNextDeoptId(),
       should_restore_closure_context);
   graph_entry_->AddCatchEntry(entry);
   Fragment instructions(entry);
 
   // :saved_try_context_var can be captured in the context of
   // of the closure, in this case CatchBlockEntryInstr restores
@@ skipping 177 matching lines @@
 Fragment FlowGraphBuilder::LoadField(intptr_t offset, intptr_t class_id) {
   LoadFieldInstr* load = new (Z) LoadFieldInstr(
       Pop(), offset, AbstractType::ZoneHandle(Z), TokenPosition::kNoSource);
   load->set_result_cid(class_id);
   Push(load);
   return Fragment(load);
 }
 
 
 Fragment FlowGraphBuilder::LoadNativeField(MethodRecognizer::Kind kind,
-                                           intptr_t offset, const Type& type,
+                                           intptr_t offset,
+                                           const Type& type,
                                            intptr_t class_id,
                                            bool is_immutable) {
   LoadFieldInstr* load =
       new (Z) LoadFieldInstr(Pop(), offset, type, TokenPosition::kNoSource);
   load->set_recognized_kind(kind);
   load->set_result_cid(class_id);
   load->set_is_immutable(is_immutable);
   Push(load);
   return Fragment(load);
 }
@@ skipping 109 matching lines @@
   }
   Push(call);
   return Fragment(call);
 }
 
 
 Fragment FlowGraphBuilder::StoreIndexed(intptr_t class_id) {
   Value* value = Pop();
   Value* index = Pop();
   const StoreBarrierType emit_store_barrier =
-      value->BindsToConstant()
-          ? kNoStoreBarrier
-          : kEmitStoreBarrier;
+      value->BindsToConstant() ? kNoStoreBarrier : kEmitStoreBarrier;
   StoreIndexedInstr* store = new (Z) StoreIndexedInstr(
       Pop(),  // Array.
       index, value, emit_store_barrier, Instance::ElementSizeFor(class_id),
       class_id, kAlignedAccess, Thread::kNoDeoptId, TokenPosition::kNoSource);
   Push(store);
   return Fragment(store);
 }
 
 
 Fragment FlowGraphBuilder::StoreInstanceField(
-    const dart::Field& field, StoreBarrierType emit_store_barrier) {
+    const dart::Field& field,
+    StoreBarrierType emit_store_barrier) {
   Value* value = Pop();
   if (value->BindsToConstant()) {
     emit_store_barrier = kNoStoreBarrier;
   }
   StoreInstanceFieldInstr* store = new (Z) StoreInstanceFieldInstr(
       field, Pop(), value, emit_store_barrier, TokenPosition::kNoSource);
   return Fragment(store);
 }
 
 
 Fragment FlowGraphBuilder::StoreInstanceFieldGuarded(const dart::Field& field) {
   Fragment instructions;
   if (FLAG_use_field_guards) {
     LocalVariable* store_expression = MakeTemporary();
     instructions += LoadLocal(store_expression);
     instructions += GuardFieldClass(field, Thread::Current()->GetNextDeoptId());
     instructions += LoadLocal(store_expression);
     instructions +=
         GuardFieldLength(field, Thread::Current()->GetNextDeoptId());
   }
   instructions += StoreInstanceField(field);
   return instructions;
 }
 
 
 Fragment FlowGraphBuilder::StoreInstanceField(
-    intptr_t offset, StoreBarrierType emit_store_barrier) {
+    intptr_t offset,
+    StoreBarrierType emit_store_barrier) {
   Value* value = Pop();
   if (value->BindsToConstant()) {
     emit_store_barrier = kNoStoreBarrier;
   }
   StoreInstanceFieldInstr* store = new (Z) StoreInstanceFieldInstr(
       offset, Pop(), value, emit_store_barrier, TokenPosition::kNoSource);
   return Fragment(store);
 }
 
 
@@ skipping 107 matching lines @@
 
   instructions += StaticCall(throw_function, 6);
   // Leave "result" on the stack since callers expect it to be there (even
   // though the function will result in an exception).
 
   return instructions;
 }
 
 
 dart::RawFunction* FlowGraphBuilder::LookupMethodByMember(
-    Member* target, const dart::String& method_name) {
+    Member* target,
+    const dart::String& method_name) {
   Class* kernel_klass = Class::Cast(target->parent());
   dart::Class& klass =
       dart::Class::Handle(Z, H.LookupClassByKernelClass(kernel_klass));
 
   dart::RawFunction* function = klass.LookupFunctionAllowPrivate(method_name);
   ASSERT(function != Object::null());
   return function;
 }
 
 
 LocalVariable* FlowGraphBuilder::MakeTemporary() {
   char name[64];
   intptr_t index = stack_->definition()->temp_index();
   OS::SNPrint(name, 64, ":temp%" Pd, index);
-  LocalVariable* variable = new (Z) LocalVariable(
-      TokenPosition::kNoSource,
-      TokenPosition::kNoSource,
-      H.DartSymbol(name),
-      Object::dynamic_type());
+  LocalVariable* variable =
+      new (Z) LocalVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
+                            H.DartSymbol(name), Object::dynamic_type());
   // Set the index relative to the base of the expression stack including
   // outgoing arguments.
   variable->set_index(parsed_function_->first_stack_local_index() -
                       parsed_function_->num_stack_locals() -
                       pending_argument_count_ - index);
 
   // The value has uses as if it were a local variable.  Mark the definition
   // as used so that its temp index will not be cleared (causing it to never
   // be materialized in the expression stack).
   stack_->definition()->set_ssa_temp_index(0);
@@ skipping 125 matching lines @@
   const dart::Function& function = parsed_function_->function();
 
   if (function.IsConstructorClosureFunction()) return NULL;
 
   dart::Class& klass =
       dart::Class::Handle(zone_, parsed_function_->function().Owner());
 
   Function& outermost_function = Function::Handle(Z);
   TreeNode* outermost_node = NULL;
   Class* kernel_klass = NULL;
-  DiscoverEnclosingElements(
-      Z, function, &outermost_function, &outermost_node, &kernel_klass);
+  DiscoverEnclosingElements(Z, function, &outermost_function, &outermost_node,
+                            &kernel_klass);
 
   // Mark that we are using [klass]/[kernell_klass] as active class.  Resolving
   // of type parameters will get resolved via [kernell_klass] unless we are
   // nested inside a static factory in which case we will use [member].
   ActiveClassScope active_class_scope(&active_class_, kernel_klass, &klass);
   Member* member = ((outermost_node != NULL) && outermost_node->IsMember())
                        ? Member::Cast(outermost_node)
                        : NULL;
   ActiveMemberScope active_member(&active_class_, member);
 
@@ skipping 53 matching lines @@
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 FlowGraph* FlowGraphBuilder::BuildGraphOfFunction(FunctionNode* function,
                                                   Constructor* constructor) {
   const Function& dart_function = parsed_function_->function();
   TargetEntryInstr* normal_entry = BuildTargetEntry();
-  graph_entry_ = new (Z)
-      GraphEntryInstr(*parsed_function_, normal_entry, osr_id_);
+  graph_entry_ =
+      new (Z) GraphEntryInstr(*parsed_function_, normal_entry, osr_id_);
 
   SetupDefaultParameterValues(function);
 
   Fragment body;
   if (!dart_function.is_native()) body += CheckStackOverflowInPrologue();
   intptr_t context_size =
       parsed_function_->node_sequence()->scope()->num_context_variables();
   if (context_size > 0) {
     body += PushContext(context_size);
     LocalVariable* context = MakeTemporary();
 
     // Copy captured parameters from the stack into the context.
     LocalScope* scope = parsed_function_->node_sequence()->scope();
     intptr_t parameter_count = dart_function.NumParameters();
     intptr_t parameter_index = parsed_function_->first_parameter_index();
     for (intptr_t i = 0; i < parameter_count; ++i, --parameter_index) {
       LocalVariable* variable = scope->VariableAt(i);
       if (variable->is_captured()) {
         // There is no LocalVariable describing the on-stack parameter so
         // create one directly and use the same type.
-        LocalVariable* parameter =
-            new (Z) LocalVariable(TokenPosition::kNoSource,
-                                  TokenPosition::kNoSource,
-                                  Symbols::TempParam(),
-                                  variable->type());
+        LocalVariable* parameter = new (Z)
+            LocalVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
+                          Symbols::TempParam(), variable->type());
         parameter->set_index(parameter_index);
         // Mark the stack variable so it will be ignored by the code for
         // try/catch.
         parameter->set_is_captured_parameter(true);
 
         // Copy the parameter from the stack to the context.  Overwrite it
         // with a null constant on the stack so the original value is
         // eligible for garbage collection.
         body += LoadLocal(context);
         body += LoadLocal(parameter);
@@ skipping 125 matching lines @@
     body = dispatch;
 
     context_depth_ = current_context_depth;
   }
   normal_entry->LinkTo(body.entry);
 
   // When compiling for OSR, use a depth first search to prune instructions
   // unreachable from the OSR entry. Catch entries are always considered
   // reachable, even if they become unreachable after OSR.
   if (osr_id_ != Compiler::kNoOSRDeoptId) {
-    BitVector* block_marks = new(Z) BitVector(Z, next_block_id_);
+    BitVector* block_marks = new (Z) BitVector(Z, next_block_id_);
     bool found = graph_entry_->PruneUnreachable(graph_entry_, NULL, osr_id_,
                                                 block_marks);
     ASSERT(found);
   }
   return new (Z) FlowGraph(*parsed_function_, graph_entry_, next_block_id_ - 1);
 }
 
 
 Fragment FlowGraphBuilder::NativeFunctionBody(FunctionNode* kernel_function,
                                               const Function& function) {
@@ skipping 145 matching lines @@
       dart::String& name = dart::String::ZoneHandle(Z, function.native_name());
       body += NativeCall(&name, &function);
       break;
     }
   }
   return body + Return();
 }
 
 
 FlowGraph* FlowGraphBuilder::BuildGraphOfFieldAccessor(
-    Field* kernel_field, LocalVariable* setter_value) {
+    Field* kernel_field,
+    LocalVariable* setter_value) {
   const dart::Function& function = parsed_function_->function();
 
   bool is_setter = function.IsImplicitSetterFunction();
   bool is_method = !function.IsStaticFunction();
   dart::Field& field =
       dart::Field::ZoneHandle(Z, H.LookupFieldByKernelField(kernel_field));
 
   TargetEntryInstr* normal_entry = BuildTargetEntry();
   graph_entry_ = new (Z)
       GraphEntryInstr(*parsed_function_, normal_entry, Compiler::kNoOSRDeoptId);
@@ skipping 115 matching lines @@
   Fragment body(normal_entry);
   body += CheckStackOverflowInPrologue();
   body += BuildImplicitClosureCreation(function);
   body += Return();
 
   return new (Z) FlowGraph(*parsed_function_, graph_entry_, next_block_id_ - 1);
 }
 
 
 FlowGraph* FlowGraphBuilder::BuildGraphOfImplicitClosureFunction(
-    FunctionNode* kernel_function, const Function& function) {
+    FunctionNode* kernel_function,
+    const Function& function) {
   const Function& target = Function::ZoneHandle(Z, function.parent_function());
 
   TargetEntryInstr* normal_entry = BuildTargetEntry();
   graph_entry_ = new (Z)
       GraphEntryInstr(*parsed_function_, normal_entry, Compiler::kNoOSRDeoptId);
   SetupDefaultParameterValues(kernel_function);
 
   Fragment body(normal_entry);
   body += CheckStackOverflowInPrologue();
 
@@ skipping 267 matching lines @@
   return new (Z) TargetEntryInstr(AllocateBlockId(), CurrentTryIndex());
 }
 
 
 JoinEntryInstr* FlowGraphBuilder::BuildJoinEntry() {
   return new (Z) JoinEntryInstr(AllocateBlockId(), CurrentTryIndex());
 }
 
 
 Fragment FlowGraphBuilder::TranslateInitializers(
-    Class* kernel_klass, List<Initializer>* initializers) {
+    Class* kernel_klass,
+    List<Initializer>* initializers) {
   Fragment instructions;
 
   // These come from:
   //   class A {
   //     var x = (expr);
   //   }
   for (intptr_t i = 0; i < kernel_klass->fields().length(); i++) {
     Field* kernel_field = kernel_klass->fields()[i];
     Expression* init = kernel_field->initializer();
     if (!kernel_field->IsStatic() && init != NULL) {
@@ skipping 370 matching lines @@
   result_ = Object::dynamic_type().raw();
 }
 
 
 void DartTypeTranslator::VisitVoidType(VoidType* node) {
   result_ = Object::void_type().raw();
 }
 
 
 const TypeArguments& DartTypeTranslator::TranslateTypeArguments(
-    DartType** dart_types, intptr_t length) {
+    DartType** dart_types,
+    intptr_t length) {
   bool only_dynamic = true;
   for (intptr_t i = 0; i < length; i++) {
     if (!dart_types[i]->IsDynamicType()) {
       only_dynamic = false;
       break;
     }
   }
   TypeArguments& type_arguments = TypeArguments::ZoneHandle(Z);
   if (!only_dynamic) {
     type_arguments = TypeArguments::New(length);
     for (intptr_t i = 0; i < length; i++) {
       dart_types[i]->AcceptDartTypeVisitor(this);
       if (result_.IsMalformed()) {
         type_arguments = TypeArguments::null();
         return type_arguments;
       }
       type_arguments.SetTypeAt(i, result_);
     }
     if (finalize_) {
       type_arguments = type_arguments.Canonicalize();
     }
   }
   return type_arguments;
 }
 
 
 const TypeArguments& DartTypeTranslator::TranslateInstantiatedTypeArguments(
-    const dart::Class& receiver_class, DartType** receiver_type_arguments,
+    const dart::Class& receiver_class,
+    DartType** receiver_type_arguments,
     intptr_t length) {
   const TypeArguments& type_arguments =
       TranslateTypeArguments(receiver_type_arguments, length);
   if (type_arguments.IsNull()) return type_arguments;
 
   // We make a temporary [Type] object and use `ClassFinalizer::FinalizeType` to
   // finalize the argument types.
   // (This can for example make the [type_arguments] vector larger)
   Type& type = Type::Handle(
       Z, Type::New(receiver_class, type_arguments, TokenPosition::kNoSource));
@@ skipping 1651 matching lines @@
   instructions += LoadLocal(closure);
   instructions += LoadLocal(parsed_function_->current_context_var());
   instructions += StoreInstanceField(Closure::context_offset());
 
   return instructions;
 }
 
 
 }  // namespace kernel
 }  // namespace dart