Revert "Fix scope/context behavior in await transformer."

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 31 matching lines @@
 FOR_EACH_UNREACHABLE_NODE(DEFINE_UNREACHABLE)
 #undef DEFINE_UNREACHABLE
 
 
 AstNode* AwaitTransformer::Transform(AstNode* expr) {
   expr->Visit(this);
   return result_;
 }
 
 
-LocalScope* AwaitTransformer::NewScope(LocalScope* parent) {
-  return new (I) LocalScope(
-      parent, parent->function_level(), parent->loop_level());
-}
-
-
 LocalVariable* AwaitTransformer::EnsureCurrentTempVar() {
   const char* await_temp_prefix = ":await_temp_var_";
   const String& cnt_str = String::ZoneHandle(
       I, String::NewFormatted("%s%d", await_temp_prefix, temp_cnt_));
   const String& symbol = String::ZoneHandle(I, Symbols::New(cnt_str));
   ASSERT(!symbol.IsNull());
   LocalVariable* await_tmp =
       parsed_function_->await_temps_scope()->LookupVariable(symbol, false);
   if (await_tmp == NULL) {
     await_tmp = new(I) LocalVariable(
@@ skipping 44 matching lines @@
   LocalVariable* result_param = preamble_->scope()->LookupVariable(
       Symbols::AsyncOperationParam(), false);
   ASSERT(result_param != NULL);
 
   node->expr()->Visit(this);
   preamble_->Add(new(I) StoreLocalNode(
       Scanner::kNoSourcePos, result_param, result_));
   LoadLocalNode* load_result_param = new(I) LoadLocalNode(
       Scanner::kNoSourcePos, result_param);
   SequenceNode* is_future_branch = new(I) SequenceNode(
-      Scanner::kNoSourcePos, NewScope(preamble_->scope()));
+      Scanner::kNoSourcePos, preamble_->scope());
   AwaitMarkerNode* await_marker =
       new(I) AwaitMarkerNode(AwaitMarkerNode::kNewContinuationState);
   await_marker->set_scope(preamble_->scope());
   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) InstanceCallNode(
       Scanner::kNoSourcePos, load_result_param, Symbols::FutureThen(), args));
   ReturnNode* continuation_return = new(I) ReturnNode(Scanner::kNoSourcePos);
   continuation_return->set_return_type(ReturnNode::kContinuation);
@@ skipping 46 matching lines @@
 //   t_3 = t_1 || t_2;  // Compiler takes care that lazy evaluation takes place
 //                         on this level.
 AstNode* AwaitTransformer::LazyTransform(const Token::Kind logical_op,
                                          AstNode* new_left,
                                          AstNode* right) {
   ASSERT(logical_op == Token::kAND || logical_op == Token::kOR);
   AstNode* result = NULL;
   const Token::Kind compare_logical_op = (logical_op == Token::kAND) ?
       Token::kEQ : Token::kNE;
   SequenceNode* eval = new(I) SequenceNode(
-      Scanner::kNoSourcePos, NewScope(preamble_->scope()));
+      Scanner::kNoSourcePos, preamble_->scope());
   SequenceNode* saved_preamble = preamble_;
   preamble_ = eval;
   result = Transform(right);
   preamble_ = saved_preamble;
   IfNode* right_body = new(I) IfNode(
       Scanner::kNoSourcePos,
       new(I) ComparisonNode(
           Scanner::kNoSourcePos,
           compare_logical_op,
           new_left,
@@ skipping 63 matching lines @@
       new(I) UnaryOpNode(node->token_pos(), node->kind(), new_operand));
   result_ = new(I) LoadLocalNode(Scanner::kNoSourcePos, result);
 }
 
 
 // ::= (<condition>) ? <true-branch> : <false-branch>
 //
 void AwaitTransformer::VisitConditionalExprNode(ConditionalExprNode* node) {
   AstNode* new_condition = Transform(node->condition());
   SequenceNode* new_true = new(I) SequenceNode(
-      Scanner::kNoSourcePos, NewScope(preamble_->scope()));
+      Scanner::kNoSourcePos, preamble_->scope());
   SequenceNode* saved_preamble = preamble_;
   preamble_ = new_true;
   AstNode* new_true_result = Transform(node->true_expr());
   SequenceNode* new_false = new(I) SequenceNode(
-      Scanner::kNoSourcePos, NewScope(preamble_->scope()));
+      Scanner::kNoSourcePos, preamble_->scope());
   preamble_ = new_false;
   AstNode* new_false_result = Transform(node->false_expr());
   preamble_ = saved_preamble;
   IfNode* new_if = new(I) IfNode(Scanner::kNoSourcePos,
                                  new_condition,
                                  new_true,
                                  new_false);
   preamble_->Add(new_if);
   LocalVariable* result = AddToPreambleNewTempVar(
       new(I) ConditionalExprNode(Scanner::kNoSourcePos,
@@ skipping 222 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