Revert "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 13 matching lines @@
 DECLARE_FLAG(bool, support_externalizable_strings);
 
 namespace kernel {
 
 #define Z (zone_)
 #define H (translation_helper_)
 #define T (type_translator_)
 #define I Isolate::Current()
 
 
-class NeedsExprTempVisitor : public RecursiveVisitor {
- public:
-  NeedsExprTempVisitor() : needs_expr_temp_(false) {}
-
-  virtual void VisitConditionalExpression(ConditionalExpression* node) {
-    needs_expr_temp_ = true;
-  }
-
-  virtual void VisitLogicalExpression(LogicalExpression* node) {
-    needs_expr_temp_ = true;
-  }
-
-  bool needs_expr_temp() const { return needs_expr_temp_; }
-
- private:
-  bool needs_expr_temp_;
-};
-
-
-static bool NeedsExprTemp(TreeNode* node) {
-  NeedsExprTempVisitor visitor;
-  node->AcceptVisitor(&visitor);
-  return visitor.needs_expr_temp();
-}
-
-
 static void DiscoverEnclosingElements(Zone* zone,
                                       const Function& function,
                                       Function* outermost_function,
                                       TreeNode** outermost_node,
                                       Class** klass) {
   // Find out if there is an enclosing kernel class (which will be used to
   // resolve type parameters).
   *outermost_function = function.raw();
   while (outermost_function->parent_function() != Object::null()) {
     *outermost_function = outermost_function->parent_function();
@@ skipping 48 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, 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 181 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);
-  bool has_expr_temp = false;
-  if (node_ != NULL && NeedsExprTemp(node_)) {
-    scope_->AddVariable(parsed_function->EnsureExpressionTemp());
-    has_expr_temp = true;
-  }
+  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 27 matching lines @@
 
         // 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->position());
-              if (!has_expr_temp && NeedsExprTemp(field->initializer())) {
-                scope_->AddVariable(parsed_function->EnsureExpressionTemp());
-                has_expr_temp = true;
-              }
               field->initializer()->AcceptExpressionVisitor(this);
               ExitScope(field->end_position());
             }
           }
         }
       } else if (function.IsFactory()) {
         LocalVariable* variable = MakeVariable(
             TokenPosition::kNoSource, TokenPosition::kNoSource,
             Symbols::TypeArgumentsParameter(), AbstractType::dynamic_type());
         scope_->InsertParameterAt(pos++, variable);
@@ skipping 6098 matching lines @@
     thread->clear_sticky_error();
     return error.raw();
   }
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)