Reland: VM [KERNEL] Avoid emitting :expr_temp and capturing :iterator

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 83 matching lines @@
 
 
 void ScopeBuilder::AddParameter(VariableDeclaration* declaration,
                                 intptr_t pos) {
   LocalVariable* variable = MakeVariable(
       declaration->position(), declaration->position(),
       H.DartSymbol(declaration->name()), T.TranslateVariableType(declaration));
   if (declaration->IsFinal()) {
     variable->set_is_final();
   }
+  if (variable->name().raw() == Symbols::IteratorParameter().raw()) {
+    variable->set_is_forced_stack();
+  }
   scope_->InsertParameterAt(pos, variable);
   result_->locals.Insert(declaration->kernel_offset(), 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);
   }
 }
@@ skipping 182 matching lines @@
     enclosing_scope = LocalScope::RestoreOuterScope(
         ContextScope::Handle(Z, function.context_scope()));
   }
   current_function_scope_ = scope_ = new (Z) LocalScope(enclosing_scope, 0, 0);
   scope_->set_begin_token_pos(function.token_pos());
   scope_->set_end_token_pos(function.end_token_pos());
 
   LocalVariable* context_var = parsed_function->current_context_var();
   context_var->set_is_forced_stack();
   scope_->AddVariable(context_var);
-  scope_->AddVariable(parsed_function->EnsureExpressionTemp());
 
   parsed_function->SetNodeSequence(
       new SequenceNode(TokenPosition::kNoSource, scope_));
 
   switch (function.kind()) {
     case RawFunction::kClosureFunction:
     case RawFunction::kRegularFunction:
     case RawFunction::kGetterFunction:
     case RawFunction::kSetterFunction:
     case RawFunction::kConstructor: {
@@ skipping 119 matching lines @@
             TokenPosition::kNoSource, TokenPosition::kNoSource,
             dart::String::ZoneHandle(Z, function.ParameterNameAt(i)),
             AbstractType::dynamic_type());
         scope_->InsertParameterAt(i, variable);
       }
       break;
     case RawFunction::kSignatureFunction:
     case RawFunction::kIrregexpFunction:
       UNREACHABLE();
   }
-
+  if (needs_expr_temp_) {
+    scope_->AddVariable(parsed_function_->EnsureExpressionTemp());
+  }
   parsed_function->AllocateVariables();
 
   return result_;
 }
 
 
 void ScopeBuilder::VisitThisExpression(ThisExpression* node) {
   HandleSpecialLoad(&result_->this_variable, Symbols::This());
 }
 
@@ skipping 21 matching lines @@
   LookupVariable(node->variable());
 }
 
 
 void ScopeBuilder::VisitVariableSet(VariableSet* node) {
   LookupVariable(node->variable());
   node->VisitChildren(this);
 }
 
 
+void ScopeBuilder::VisitConditionalExpression(ConditionalExpression* node) {
+  needs_expr_temp_ = true;
+  node->VisitChildren(this);
+}
+
+
+void ScopeBuilder::VisitLogicalExpression(LogicalExpression* node) {
+  needs_expr_temp_ = true;
+  node->VisitChildren(this);
+}
+
+
 void ScopeBuilder::HandleLocalFunction(TreeNode* parent,
                                        FunctionNode* function) {
   LocalScope* saved_function_scope = current_function_scope_;
   FunctionNode* saved_function_node = current_function_node_;
   ScopeBuilder::DepthState saved_depth_state = depth_;
   depth_ = DepthState(depth_.function_ + 1);
   EnterScope(parent, function->position());
   current_function_scope_ = scope_;
   current_function_node_ = function;
   if (depth_.function_ == 1) {
@@ skipping 5989 matching lines @@
     thread->clear_sticky_error();
     return error.raw();
   }
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)