Revert async changes.

runtime/vm/parser.cc

 // Copyright (c) 2012, 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/parser.h"
 
 #include "lib/invocation_mirror.h"
 #include "platform/utils.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 21 matching lines @@
 #include "vm/tags.h"
 #include "vm/timer.h"
 #include "vm/zone.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, enable_asserts, false, "Enable assert statements.");
 DEFINE_FLAG(bool, enable_type_checks, false, "Enable type checks.");
 DEFINE_FLAG(bool, trace_parser, false, "Trace parser operations.");
 DEFINE_FLAG(bool, warn_mixin_typedef, true, "Warning on legacy mixin typedef.");
-DEFINE_FLAG(bool, enable_async, false, "Enable async operations.");
 DECLARE_FLAG(bool, error_on_bad_type);
 DECLARE_FLAG(bool, throw_on_javascript_int_overflow);
 DECLARE_FLAG(bool, warn_on_javascript_compatibility);
 
 static void CheckedModeHandler(bool value) {
   FLAG_enable_asserts = value;
   FLAG_enable_type_checks = value;
 }
 
 // --enable-checked-mode and --checked both enable checked mode which is
@@ skipping 2839 matching lines @@
     AstNode* guarded_block_statements =
         new IfNode(Scanner::kNoSourcePos, comparison, ctor_block, NULL);
     current_block_->statements->Add(guarded_block_statements);
   }
   current_block_->statements->Add(new ReturnNode(func.end_token_pos()));
   SequenceNode* statements = CloseBlock();
   return statements;
 }
 
 
-// TODO(mlippautz): Once we know where these classes should come from, adjust
-// how we get their definition.
-RawClass* Parser::GetClassForAsync(const String& class_name) {
-  const Class& cls = Class::Handle(library_.LookupClass(class_name));
-  if (cls.IsNull()) {
-    ReportError("async modifier requires dart:async to be imported");
-  }
-  return cls.raw();
-}
-
-
 // Parser is at the opening parenthesis of the formal parameter
 // declaration of the function or constructor.
 // Parse the formal parameters and code.
 SequenceNode* Parser::ParseFunc(const Function& func,
                                 Array* default_parameter_values) {
   TRACE_PARSER("ParseFunc");
   Function& saved_innermost_function =
       Function::Handle(I, innermost_function().raw());
   innermost_function_ = func.raw();
 
   // Save current try index. Try index starts at zero for each function.
   intptr_t saved_try_index = last_used_try_index_;
   last_used_try_index_ = 0;
 
-  intptr_t formal_params_pos = TokenPos();
   // TODO(12455) : Need better validation mechanism.
 
   if (func.IsConstructor()) {
     SequenceNode* statements = ParseConstructor(func, default_parameter_values);
     innermost_function_ = saved_innermost_function.raw();
     last_used_try_index_ = saved_try_index;
     return statements;
   }
 
   ASSERT(!func.IsConstructor());
@@ skipping 14 matching lines @@
     ASSERT(current_class().raw() == func.Owner());
     params.AddReceiver(ReceiverType(current_class()), func.token_pos());
   } else if (func.IsFactory()) {
     // The first parameter of a factory is the TypeArguments vector of
     // the type of the instance to be allocated.
     params.AddFinalParameter(
         TokenPos(),
         &Symbols::TypeArgumentsParameter(),
         &Type::ZoneHandle(I, Type::DynamicType()));
   }
-  ASSERT((CurrentToken() == Token::kLPAREN) ||
-         func.IsGetterFunction() ||
-         func.is_async_closure());
+  ASSERT((CurrentToken() == Token::kLPAREN) || func.IsGetterFunction());
   const bool allow_explicit_default_values = true;
   if (func.IsGetterFunction()) {
     // Populate function scope with the formal parameters. Since in this case
     // we are compiling a getter this will at most populate the receiver.
     AddFormalParamsToScope(&params, current_block_->scope);
-  } else if (func.is_async_closure()) {
-    AddFormalParamsToScope(&params, current_block_->scope);
-    ASSERT(AbstractType::Handle(I, func.result_type()).IsResolved());
-    ASSERT(func.NumParameters() == params.parameters->length());
-    if (!Function::Handle(func.parent_function()).IsGetterFunction()) {
-      // Parse away any formal parameters, as they are accessed as as context
-      // variables.
-      ParseFormalParameterList(allow_explicit_default_values, false, &params);
-    }
   } else {
     ParseFormalParameterList(allow_explicit_default_values, false, &params);
 
     // The number of parameters and their type are not yet set in local
     // functions, since they are not 'top-level' parsed.
     if (func.IsLocalFunction()) {
       AddFormalParamsToFunction(&params, func);
     }
     SetupDefaultsForOptionalParams(&params, default_parameter_values);
     ASSERT(AbstractType::Handle(I, func.result_type()).IsResolved());
@@ skipping 20 matching lines @@
       if (IsInstantiatorRequired()) {
         // Make sure that the receiver of the enclosing instance function
         // (or implicit first parameter of an enclosing factory) is marked as
         // captured if type checks are enabled, because they may access it to
         // instantiate types.
         CaptureInstantiator();
       }
     }
   }
 
-  RawFunction::AsyncModifier func_modifier = ParseFunctionModifier();
-  func.set_modifier(func_modifier);
-
   OpenBlock();  // Open a nested scope for the outermost function block.
-
-  Function& async_closure = Function::ZoneHandle(I);
-  if (func.IsAsyncFunction() && !func.is_async_closure()) {
-    async_closure = OpenAsyncFunction(formal_params_pos);
-  }
-
   intptr_t end_token_pos = 0;
   if (CurrentToken() == Token::kLBRACE) {
     ConsumeToken();
     if (String::Handle(I, func.name()).Equals(
         Symbols::EqualOperator())) {
       const Class& owner = Class::Handle(I, func.Owner());
       if (!owner.IsObjectClass()) {
         AddEqualityNullCheck();
       }
     }
@@ skipping 40 matching lines @@
                                &func));  // Unpatched external function.
     end_token_pos = TokenPos();
   } else {
     UnexpectedToken();
   }
 
   ASSERT(func.end_token_pos() == func.token_pos() ||
          func.end_token_pos() == end_token_pos);
   func.set_end_token_pos(end_token_pos);
   SequenceNode* body = CloseBlock();
-  if (func.IsAsyncFunction() && !func.is_async_closure()) {
-    body = CloseAsyncFunction(async_closure, body);
-  } else if (func.is_async_closure()) {
-    CloseAsyncClosure(body);
-  }
   current_block_->statements->Add(body);
   innermost_function_ = saved_innermost_function.raw();
   last_used_try_index_ = saved_try_index;
   return CloseBlock();
 }
 
 
 void Parser::AddEqualityNullCheck() {
   AstNode* argument =
       new LoadLocalNode(Scanner::kNoSourcePos,
@@ skipping 293 matching lines @@
   ASSERT((method->redirect_name == NULL) || method->IsConstructor());
 
   if (method->IsConstructor() &&
       method->has_external &&
       method->params.has_field_initializer) {
     ReportError(method->name_pos,
                 "external constructor '%s' may not have field initializers",
                 method->name->ToCString());
   }
 
-  RawFunction::AsyncModifier async_modifier = ParseFunctionModifier();
-  if ((method->IsFactoryOrConstructor() || method->IsSetter()) &&
-      async_modifier != RawFunction::kNoModifier) {
-    ReportError(method->name_pos,
-                "%s '%s' may not be async",
-                (method->IsSetter()) ? "setter" : "constructor",
-                method->name->ToCString());
-  }
-
   intptr_t method_end_pos = TokenPos();
   if ((CurrentToken() == Token::kLBRACE) ||
       (CurrentToken() == Token::kARROW)) {
     if (method->has_abstract) {
       ReportError(TokenPos(),
                   "abstract method '%s' may not have a function body",
                   method->name->ToCString());
     } else if (method->has_external) {
       ReportError(TokenPos(),
                   "external %s '%s' may not have a function body",
@@ skipping 94 matching lines @@
                     method->has_static,
                     method->has_const,
                     method->has_abstract,
                     method->has_external,
                     method->has_native,
                     current_class(),
                     method->decl_begin_pos));
   func.set_result_type(*method->type);
   func.set_end_token_pos(method_end_pos);
   func.set_is_redirecting(is_redirecting);
-  func.set_modifier(async_modifier);
   if (method->has_native && library_.is_dart_scheme() &&
       library_.IsPrivate(*method->name)) {
     func.set_is_visible(false);
   }
   if (method->IsFactoryOrConstructor() && library_.is_dart_scheme() &&
       library_.IsPrivate(*method->name)) {
     func.set_is_visible(false);
   }
   if (method->metadata_pos > 0) {
     library_.AddFunctionMetadata(func, method->metadata_pos);
@@ skipping 1300 matching lines @@
     } else if (CurrentToken() == Token::kSEMICOLON) {
       ConsumeToken();
       break;
     } else {
       ExpectSemicolon();  // Reports error.
     }
   }
 }
 
 
-RawFunction::AsyncModifier Parser::ParseFunctionModifier() {
-  if (FLAG_enable_async) {
-    if (CurrentLiteral()->raw() == Symbols::Async().raw()) {
-      ConsumeToken();
-      return RawFunction::kAsync;
-    }
-  }
-  return RawFunction::kNoModifier;
-}
-
-
 void Parser::ParseTopLevelFunction(TopLevel* top_level,
                                    intptr_t metadata_pos) {
   TRACE_PARSER("ParseTopLevelFunction");
   const intptr_t decl_begin_pos = TokenPos();
   AbstractType& result_type = Type::Handle(I, Type::DynamicType());
   const bool is_static = true;
   bool is_external = false;
   bool is_patch = false;
   if (is_patch_source() &&
       (CurrentToken() == Token::kIDENT) &&
@@ skipping 33 matching lines @@
   }
   // A setter named x= may co-exist with a function named x, thus we do
   // not need to check setters.
 
   CheckToken(Token::kLPAREN);
   const intptr_t function_pos = TokenPos();
   ParamList params;
   const bool allow_explicit_default_values = true;
   ParseFormalParameterList(allow_explicit_default_values, false, &params);
 
-  RawFunction::AsyncModifier func_modifier = ParseFunctionModifier();
-
   intptr_t function_end_pos = function_pos;
   bool is_native = false;
   if (is_external) {
     function_end_pos = TokenPos();
     ExpectSemicolon();
   } else if (CurrentToken() == Token::kLBRACE) {
     SkipBlock();
     function_end_pos = TokenPos();
     ExpectToken(Token::kRBRACE);
   } else if (CurrentToken() == Token::kARROW) {
@@ skipping 14 matching lines @@
                     RawFunction::kRegularFunction,
                     is_static,
                     /* is_const = */ false,
                     /* is_abstract = */ false,
                     is_external,
                     is_native,
                     current_class(),
                     decl_begin_pos));
   func.set_result_type(result_type);
   func.set_end_token_pos(function_end_pos);
-  func.set_modifier(func_modifier);
   if (is_native && library_.is_dart_scheme() && library_.IsPrivate(func_name)) {
     func.set_is_visible(false);
   }
   AddFormalParamsToFunction(&params, func);
   top_level->functions.Add(func);
   if (!is_patch) {
     library_.AddObject(func, func_name);
   } else {
     library_.ReplaceObject(func, func_name);
   }
@@ skipping 82 matching lines @@
   if (found && !is_patch) {
     ReportError(name_pos, "%s for '%s' is already defined",
                 is_getter ? "getter" : "setter",
                 field_name->ToCString());
   } else if (!found && is_patch) {
     ReportError(name_pos, "missing %s for '%s' cannot be patched",
                 is_getter ? "getter" : "setter",
                 field_name->ToCString());
   }
 
-  RawFunction::AsyncModifier func_modifier = ParseFunctionModifier();
-
   intptr_t accessor_end_pos = accessor_pos;
   bool is_native = false;
   if (is_external) {
     accessor_end_pos = TokenPos();
     ExpectSemicolon();
   } else if (CurrentToken() == Token::kLBRACE) {
     SkipBlock();
     accessor_end_pos = TokenPos();
     ExpectToken(Token::kRBRACE);
   } else if (CurrentToken() == Token::kARROW) {
@@ skipping 15 matching lines @@
                                 RawFunction::kSetterFunction,
                     is_static,
                     /* is_const = */ false,
                     /* is_abstract = */ false,
                     is_external,
                     is_native,
                     current_class(),
                     decl_begin_pos));
   func.set_result_type(result_type);
   func.set_end_token_pos(accessor_end_pos);
-  func.set_modifier(func_modifier);
   if (is_native && library_.is_dart_scheme() &&
       library_.IsPrivate(accessor_name)) {
     func.set_is_visible(false);
   }
   AddFormalParamsToFunction(&params, func);
   top_level->functions.Add(func);
   if (!is_patch) {
     library_.AddObject(func, accessor_name);
   } else {
     library_.ReplaceObject(func, accessor_name);
@@ skipping 396 matching lines @@
     // We are parsing a nested function while compiling the enclosing function.
     outer_scope =
         new(I) LocalScope(current_block_->scope,
                                   current_block_->scope->function_level() + 1,
                                   0);
   }
   ChainNewBlock(outer_scope);
 }
 
 
-RawFunction* Parser::OpenAsyncFunction(intptr_t formal_param_pos) {
-  // Create the closure containing the old body of this function.
-  Class& sig_cls = Class::ZoneHandle(I);
-  Type& sig_type = Type::ZoneHandle(I);
-  Function& closure = Function::ZoneHandle(I);
-  String& sig = String::ZoneHandle(I);
-  ParamList closure_params;
-  closure_params.AddFinalParameter(
-      formal_param_pos,
-      &Symbols::ClosureParameter(),
-      &Type::ZoneHandle(I, Type::DynamicType()));
-  closure = Function::NewClosureFunction(
-      Symbols::AnonymousClosure(),
-      innermost_function(),
-      formal_param_pos);
-  AddFormalParamsToFunction(&closure_params, closure);
-  closure.set_is_async_closure(true);
-  closure.set_result_type(AbstractType::Handle(Type::DynamicType()));
-  sig = closure.Signature();
-  sig_cls = library_.LookupLocalClass(sig);
-  if (sig_cls.IsNull()) {
-    sig_cls = Class::NewSignatureClass(sig, closure, script_, formal_param_pos);
-    library_.AddClass(sig_cls);
-  }
-  closure.set_signature_class(sig_cls);
-  sig_type = sig_cls.SignatureType();
-  if (!sig_type.IsFinalized()) {
-    ClassFinalizer::FinalizeType(
-        sig_cls, sig_type, ClassFinalizer::kCanonicalize);
-  }
-  ASSERT(AbstractType::Handle(I, closure.result_type()).IsResolved());
-  ASSERT(closure.NumParameters() == closure_params.parameters->length());
-  OpenFunctionBlock(closure);
-  AddFormalParamsToScope(&closure_params, current_block_->scope);
-  OpenBlock();
-  return closure.raw();
-}
-
-
 SequenceNode* Parser::CloseBlock() {
   SequenceNode* statements = current_block_->statements;
   if (current_block_->scope != NULL) {
     // Record the begin and end token index of the scope.
     ASSERT(statements != NULL);
     current_block_->scope->set_begin_token_pos(statements->token_pos());
     current_block_->scope->set_end_token_pos(TokenPos());
   }
   current_block_ = current_block_->parent;
   return statements;
 }
 
 
-SequenceNode* Parser::CloseAsyncFunction(const Function& closure,
-                                         SequenceNode* closure_body) {
-  ASSERT(!closure.IsNull());
-  ASSERT(closure_body != NULL);
-  // The block for the async closure body has already been closed. Close the
-  // corresponding function block.
-  CloseBlock();
-
-  // Create and return a new future that executes a closure with the current
-  // body.
-
-  bool found = false;
-
-  // No need to capture parameters or other variables, since they have already
-  // been captured in the corresponding scope as the body has been parsed within
-  // a nested block (contained in the async funtion's block).
-  const Class& future = Class::ZoneHandle(I,
-      GetClassForAsync(Symbols::Future()));
-  ASSERT(!future.IsNull());
-  const Function& constructor = Function::ZoneHandle(I,
-      future.LookupFunction(Symbols::FutureConstructor()));
-  ASSERT(!constructor.IsNull());
-  const Class& completer = Class::ZoneHandle(I,
-      GetClassForAsync(Symbols::Completer()));
-  ASSERT(!completer.IsNull());
-  const Function& completer_constructor = Function::ZoneHandle(I,
-      completer.LookupFunction(Symbols::CompleterConstructor()));
-  ASSERT(!completer_constructor.IsNull());
-
-  // Add to AST:
-  //   var :async_op;
-  //   var :async_completer;
-  LocalVariable* async_op_var = new (I) LocalVariable(
-      Scanner::kNoSourcePos,
-      Symbols::AsyncOperation(),
-      Type::ZoneHandle(I, Type::DynamicType()));
-  current_block_->scope->AddVariable(async_op_var);
-  found = closure_body->scope()->CaptureVariable(Symbols::AsyncOperation());
-  ASSERT(found);
-  LocalVariable* async_completer = new (I) LocalVariable(
-      Scanner::kNoSourcePos,
-      Symbols::AsyncCompleter(),
-      Type::ZoneHandle(I, Type::DynamicType()));
-  current_block_->scope->AddVariable(async_completer);
-  found = closure_body->scope()->CaptureVariable(Symbols::AsyncCompleter());
-  ASSERT(found);
-
-  // Add to AST:
-  //   :async_completer = new Completer();
-  ArgumentListNode* empty_args = new (I) ArgumentListNode(
-      Scanner::kNoSourcePos);
-  ConstructorCallNode* completer_constructor_node = new (I) ConstructorCallNode(
-      Scanner::kNoSourcePos,
-      TypeArguments::ZoneHandle(I),
-      completer_constructor,
-      empty_args);
-  StoreLocalNode* store_completer = new (I) StoreLocalNode(
-      Scanner::kNoSourcePos,
-      async_completer,
-      completer_constructor_node);
-  current_block_->statements->Add(store_completer);
-
-  // Add to AST:
-  //   :async_op = <closure>;  (containing the original body)
-  ClosureNode* cn = new(I) ClosureNode(
-      Scanner::kNoSourcePos, closure, NULL, closure_body->scope());
-  StoreLocalNode* store_async_op = new (I) StoreLocalNode(
-      Scanner::kNoSourcePos,
-      async_op_var,
-      cn);
-  current_block_->statements->Add(store_async_op);
-
-  // Add to AST:
-  //   new Future(:async_op);
-  ArgumentListNode* arguments = new (I) ArgumentListNode(Scanner::kNoSourcePos);
-  arguments->Add(new (I) LoadLocalNode(
-      Scanner::kNoSourcePos, async_op_var));
-  ConstructorCallNode* future_node = new (I) ConstructorCallNode(
-      Scanner::kNoSourcePos, TypeArguments::ZoneHandle(I), constructor,
-      arguments);
-  current_block_->statements->Add(future_node);
-
-  // Add to AST:
-  //   return :async_completer.future;
-  ReturnNode* return_node = new (I) ReturnNode(
-      Scanner::kNoSourcePos,
-      new (I) InstanceGetterNode(
-          Scanner::kNoSourcePos,
-          new (I) LoadLocalNode(
-              Scanner::kNoSourcePos,
-              async_completer),
-          Symbols::CompleterFuture()));
-  current_block_->statements->Add(return_node);
-  return CloseBlock();
-}
-
-
-void Parser::CloseAsyncClosure(SequenceNode* body) {
-  ASSERT(body != NULL);
-  // Replace an optional ReturnNode with the appropriate completer calls.
-  intptr_t last_index = body->length() - 1;
-  AstNode* last = NULL;
-  if (last_index >= 0) {
-    // Non-empty async closure.
-    last = body->NodeAt(last_index);
-  }
-  ArgumentListNode* args = new (I) ArgumentListNode(Scanner::kNoSourcePos);
-  LocalVariable* completer = body->scope()->LookupVariable(
-      Symbols::AsyncCompleter(), false);
-  ASSERT(completer != NULL);
-  if (last != NULL && last->IsReturnNode()) {
-    // Replace
-    //   return <expr>;
-    // with
-    //   completer.complete(<expr>);
-    args->Add(body->NodeAt(last_index)->AsReturnNode()->value());
-    body->ReplaceNodeAt(last_index,
-        new (I) InstanceCallNode(
-          Scanner::kNoSourcePos,
-          new (I) LoadLocalNode(Scanner::kNoSourcePos, completer),
-          Symbols::CompleterComplete(),
-          args));
-  } else {
-    // Add to AST:
-    //   completer.complete();
-    body->Add(
-        new (I) InstanceCallNode(
-          Scanner::kNoSourcePos,
-          new (I) LoadLocalNode(Scanner::kNoSourcePos, completer),
-          Symbols::CompleterComplete(),
-          args));
-  }
-}
-
-
 // Set up default values for all optional parameters to the function.
 void Parser::SetupDefaultsForOptionalParams(const ParamList* params,
                                             Array* default_values) {
   if (params->num_optional_parameters > 0) {
     // Build array of default parameter values.
     ParamDesc* param =
       params->parameters->data() + params->num_fixed_parameters;
     *default_values = Array::New(params->num_optional_parameters);
     for (int i = 0; i < params->num_optional_parameters; i++) {
       ASSERT(param->default_value != NULL);
@@ skipping 755 matching lines @@
   } else {
     SetPosition(saved_pos);
     return false;
   }
   // Check parameter list and the following token.
   if (CurrentToken() == Token::kLPAREN) {
     SkipToMatchingParenthesis();
     if ((CurrentToken() == Token::kLBRACE) ||
         (CurrentToken() == Token::kARROW) ||
         (is_top_level_ && IsLiteral("native")) ||
-        is_external ||
-        (FLAG_enable_async &&
-            CurrentLiteral()->raw() == Symbols::Async().raw())) {
+        is_external) {
       SetPosition(saved_pos);
       return true;
     }
   }
   SetPosition(saved_pos);
   return false;
 }
 
 
 bool Parser::IsTopLevelAccessor() {
@@ skipping 4518 matching lines @@
       SkipType(true);
     }
     ExpectIdentifier("function name expected");
   }
   if (CurrentToken() == Token::kLPAREN) {
     const bool allow_explicit_default_values = true;
     ParamList params;
     params.skipped = true;
     ParseFormalParameterList(allow_explicit_default_values, false, &params);
   }
-  ParseFunctionModifier();
   if (CurrentToken() == Token::kLBRACE) {
     SkipBlock();
     ExpectToken(Token::kRBRACE);
   } else if (CurrentToken() == Token::kARROW) {
     ConsumeToken();
     SkipExpr();
   }
 }
 
 
 // Skips function/method/constructor/getter/setter preambles until the formal
 // parameter list. It is enough to skip the tokens, since we have already
 // previously parsed the function.
 void Parser::SkipFunctionPreamble() {
   while (true) {
     const Token::Kind token = CurrentToken();
     if (token == Token::kLPAREN ||
         token == Token::kARROW ||
         token == Token::kSEMICOLON ||
         token == Token::kLBRACE) {
       return;
     }
     // Case handles "native" keyword, but also return types of form
     // native.SomeType where native is the name of a library.
     if (token == Token::kIDENT && LookaheadToken(1) != Token::kPERIOD) {
-      if (CurrentLiteral()->raw() == Symbols::Native().raw() ||
-          CurrentLiteral()->raw() == Symbols::Async().raw()) {
+      if (CurrentLiteral()->raw() == Symbols::Native().raw()) {
         return;
       }
     }
     ConsumeToken();
   }
 }
 
 
 void Parser::SkipListLiteral() {
   if (CurrentToken() == Token::kINDEX) {
@@ skipping 274 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart