Initialize the async jump variable with a smi to avoid polymorphic comparison.

runtime/vm/ast_transformer.cc

 // Copyright (c) 2014, 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 "vm/ast_transformer.h"
 
 #include "vm/parser.h"
 
 namespace dart {
 
@@ skipping 124 matching lines @@
   preamble_->Add(new(I) StoreLocalNode(
       Scanner::kNoSourcePos, result_param, result_));
   LoadLocalNode* load_result_param = new(I) LoadLocalNode(
       Scanner::kNoSourcePos, result_param);
   LocalScope* is_future_scope = ChainNewScope(preamble_->scope());
   SequenceNode* is_future_branch = new (I) SequenceNode(
       Scanner::kNoSourcePos, is_future_scope);
   AwaitMarkerNode* await_marker = new (I) AwaitMarkerNode(
       AwaitMarkerNode::kNewContinuationState);
   await_marker->set_scope(is_future_scope);
-  GetVariableInScope(is_future_scope, Symbols::AwaitJumpVar());

[hausner, 2014/10/14 16:29:55]

I am not sure why the lookup of these variables is here. But this lookup was
introduced by this CL

https://codereview.chromium.org//520223002

That fixed scope-related issues. Looking up the variable in this scope rather
than the top-level scope of the closure (as your change does) may have a subtle
desired side effect.

[Florian Schneider, 2014/10/15 11:40:59]

Here the side effect occurs twice (here and again when looking up the same
variables in the EffectGraphVisitr::VisitAwaitMarkerNode). Maybe the code
changed so that this became redundant.

-  GetVariableInScope(is_future_scope, Symbols::AwaitContextVar());
   is_future_branch->Add(await_marker);
   ArgumentListNode* args = new(I) ArgumentListNode(Scanner::kNoSourcePos);
   args->Add(new(I) LoadLocalNode(Scanner::kNoSourcePos, async_op));
   is_future_branch->Add(new (I) StoreLocalNode(
       Scanner::kNoSourcePos,
       result_param,
       new(I) InstanceCallNode(
           Scanner::kNoSourcePos,
           load_result_param,
           Symbols::FutureThen(),
@@ skipping 115 matching lines @@
 }
 
 
 LocalScope* AwaitTransformer::ChainNewScope(LocalScope* parent) {
   return new (I) LocalScope(
       parent, parent->function_level(), parent->loop_level());
 }
 
 
 void AwaitTransformer::VisitBinaryOpNode(BinaryOpNode* node) {
-  node->left()->Visit(this);
-  AstNode* new_left = result_;
+  AstNode* new_left = Transform(node->left());
   AstNode* new_right = NULL;
   // Preserve lazy evaluaton.
   if ((node->kind() == Token::kAND) || (node->kind() == Token::kOR)) {
     new_right = LazyTransform(node->kind(), new_left, node->right());
   } else {
     new_right = Transform(node->right());
   }
   LocalVariable* result = AddToPreambleNewTempVar(
       new(I) BinaryOpNode(node->token_pos(),
                           node->kind(),
                           new_left,
                           new_right));
   result_ = new(I) LoadLocalNode(Scanner::kNoSourcePos, result);
 }
 
 
 void AwaitTransformer::VisitBinaryOpWithMask32Node(
     BinaryOpWithMask32Node* node) {
-  node->left()->Visit(this);
-  AstNode* new_left = result_;
-  AstNode* new_right = NULL;
-  // Preserve lazy evaluaton.
-  if ((node->kind() == Token::kAND) || (node->kind() == Token::kOR)) {
-    new_right = LazyTransform(node->kind(), new_left, node->right());
-  } else {
-    new_right = Transform(node->right());
-  }
+  ASSERT((node->kind() != Token::kAND) && (node->kind() != Token::kOR));
+  AstNode* new_left = Transform(node->left());
+  AstNode* new_right = Transform(node->right());
   LocalVariable* result = AddToPreambleNewTempVar(
       new(I) BinaryOpWithMask32Node(node->token_pos(),
                                     node->kind(),
                                     new_left,
                                     new_right,
                                     node->mask32()));
   result_ = new(I) LoadLocalNode(Scanner::kNoSourcePos, result);
 }
 
 
@@ skipping 263 matching lines @@
 void AwaitTransformer::VisitThrowNode(ThrowNode* node) {
   // TODO(mlippautz): Check if relevant.
   AstNode* new_exception = Transform(node->exception());
   AstNode* new_stacktrace = Transform(node->stacktrace());
   result_ = new(I) ThrowNode(node->token_pos(),
                              new_exception,
                              new_stacktrace);
 }
 
 }  // namespace dart