Small cleanups in the Kernel FlowGraphBuilder

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 1301 matching lines @@
   // instructions do not make a copy of the handle, so we do it.
   return dart::Instance::ZoneHandle(Z, result_.raw());
 }
 
 
 Object& ConstantEvaluator::EvaluateExpressionSafe(Expression* expression) {
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     return EvaluateExpression(expression);
   } else {
-    Thread* thread = Thread::Current();
+    Thread* thread = H.thread();
     Error& error = Error::Handle(Z);
     error = thread->sticky_error();
     thread->clear_sticky_error();
     return error;
   }
 }
 
 
 Instance& ConstantEvaluator::EvaluateConstructorInvocation(
     ConstructorInvocation* node) {
@@ skipping 510 matching lines @@
 }
 
 
 FlowGraphBuilder::FlowGraphBuilder(
     TreeNode* node,
     ParsedFunction* parsed_function,
     const ZoneGrowableArray<const ICData*>& ic_data_array,
     InlineExitCollector* exit_collector,
     intptr_t osr_id,
     intptr_t first_block_id)
-    : zone_(Thread::Current()->zone()),
-      translation_helper_(Thread::Current(),
-                          zone_,
-                          Thread::Current()->isolate()),
+    : translation_helper_(Thread::Current()),
+      zone_(translation_helper_.zone()),
       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),
@@ skipping 318 matching lines @@
 
 Fragment FlowGraphBuilder::CatchBlockEntry(const Array& handler_types,
                                            intptr_t handler_index) {
   ASSERT(CurrentException()->is_captured() ==
          CurrentStackTrace()->is_captured());
   const bool should_restore_closure_context =
       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(),
+      /* needs_stacktrace = */ true, H.thread()->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
   // :current_context_var to point to closure context in the
   // same way as normal function prologue does.
   // Update current context depth to reflect that.
   const intptr_t saved_context_depth = context_depth_;
@@ skipping 349 matching lines @@
   return Fragment(store);
 }
 
 
 Fragment FlowGraphBuilder::StoreInstanceFieldGuarded(const dart::Field& field) {
   Fragment instructions;
   const dart::Field& field_clone = MayCloneField(Z, field);
   if (FLAG_use_field_guards) {
     LocalVariable* store_expression = MakeTemporary();
     instructions += LoadLocal(store_expression);
-    instructions +=
-        GuardFieldClass(field_clone, Thread::Current()->GetNextDeoptId());
+    instructions += GuardFieldClass(field_clone, H.thread()->GetNextDeoptId());
     instructions += LoadLocal(store_expression);
-    instructions +=
-        GuardFieldLength(field_clone, Thread::Current()->GetNextDeoptId());
+    instructions += GuardFieldLength(field_clone, H.thread()->GetNextDeoptId());
   }
   instructions += StoreInstanceField(field_clone);
   return instructions;
 }
 
 
 Fragment FlowGraphBuilder::StoreInstanceField(
     intptr_t offset,
     StoreBarrierType emit_store_barrier) {
   Value* value = Pop();
@@ skipping 2324 matching lines @@
   instructions += LoadLocal(catch_block_->exception_var());
   instructions += PushArgument();
   instructions += LoadLocal(catch_block_->stack_trace_var());
   instructions += PushArgument();
   instructions += RethrowException(catch_block_->catch_try_index());
 
   fragment_ = instructions;
 }
 
 
-void FlowGraphBuilder::VisitBlockExpression(BlockExpression* node) {
-  Fragment instructions = TranslateStatement(node->body());
-  instructions += TranslateExpression(node->value());
-  fragment_ = instructions;
-}
-
-
 Fragment FlowGraphBuilder::TranslateArguments(Arguments* node,
                                               Array* argument_names) {
   Fragment instructions;
 
   List<Expression>& positional = node->positional();
   for (intptr_t i = 0; i < positional.length(); ++i) {
     instructions += TranslateExpression(positional[i]);
     instructions += PushArgument();
   }
 
@@ skipping 916 matching lines @@
   instructions += LoadLocal(parsed_function_->current_context_var());
   instructions += StoreInstanceField(Closure::context_offset());
 
   return instructions;
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)