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 NeedExprTempVisitor : public RecursiveVisitor {
+ public:
+  NeedExprTempVisitor() : need_expr_temp_(false) {}
+
+  virtual void VisitConditionalExpression(ConditionalExpression* node) {
+    need_expr_temp_ = true;
+  }
+
+  virtual void VisitLogicalExpression(LogicalExpression* node) {
+    need_expr_temp_ = true;
+  }
+
+  bool NeedTemp() const { return need_expr_temp_; }

[Vyacheslav Egorov (Google), 2017/03/27 14:31:46]

nit: style guide suggests naming simple getters like this:

bool needs_expr_temp() const {  ... }

+
+ private:
+  bool need_expr_temp_;

[Vyacheslav Egorov (Google), 2017/03/27 14:31:46]

better name is needs_expr_temp_.

+};
+
+
+bool NeedExprTemp(TreeNode* node) {

[Vyacheslav Egorov (Google), 2017/03/27 14:31:46]

static bool NeedsExprTemp(...)

+  NeedExprTempVisitor visitor;
+  node->AcceptVisitor(&visitor);
+  return visitor.NeedTemp();
+}
+
+
 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 249 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());
+  bool has_expr_temp = false;
+  if (node_ != NULL && NeedExprTemp(node_)) {
+    scope_->AddVariable(parsed_function->EnsureExpressionTemp());
+    has_expr_temp = true;
+  }
 
   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 && NeedExprTemp(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 6095 matching lines @@
     thread->clear_sticky_error();
     return error.raw();
   }
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)