Fix debugging of async code

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/ast_transformer.h"
 #include "vm/bootstrap.h"
@@ skipping 834 matching lines @@
   SequenceNode* node_sequence = NULL;
   Array& default_parameter_values = Array::ZoneHandle(isolate, Array::null());
   switch (func.kind()) {
     case RawFunction::kRegularFunction:
     case RawFunction::kClosureFunction:
     case RawFunction::kGetterFunction:
     case RawFunction::kSetterFunction:
     case RawFunction::kConstructor:
       // The call to a redirecting factory is redirected.
       ASSERT(!func.IsRedirectingFactory());
-      if (!func.IsImplicitConstructor() && !func.is_async_closure()) {
+      if (!func.IsImplicitConstructor()) {
         parser.SkipFunctionPreamble();
       }
       node_sequence = parser.ParseFunc(func, &default_parameter_values);
       break;
     case RawFunction::kImplicitGetter:
       ASSERT(!func.is_static());
       node_sequence = parser.ParseInstanceGetter(func);
       break;
     case RawFunction::kImplicitSetter:
       ASSERT(!func.is_static());
@@ skipping 2128 matching lines @@
                                 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.
-
   // In case of nested async functions we also need to save the currently saved
   // try context, the corresponding stack variable, and the scope where
   // temporaries are added.
   LocalVariable* saved_saved_try_ctx = parsed_function()->saved_try_ctx();
   const String& saved_async_saved_try_ctx_name =
       String::Handle(I, parsed_function()->async_saved_try_ctx_name());
   parsed_function()->reset_saved_try_ctx_vars();
   LocalScope* saved_async_temp_scope = async_temp_scope_;
 
   if (func.IsConstructor()) {
@@ skipping 53 matching lines @@
     error_param.type = &dynamic_type;
     params.parameters->Add(result_param);
     params.parameters->Add(error_param);
     params.num_optional_parameters += 2;
     params.has_optional_positional_parameters = true;
     SetupDefaultsForOptionalParams(&params, default_parameter_values);
     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.
+      // Parse and discard any formal parameters. They are accessed as
+      // context variables.
       ParamList parse_away;
       ParseFormalParameterList(allow_explicit_default_values,
                                false,
                                &parse_away);
     }
   } 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.
@@ skipping 32 matching lines @@
     }
   }
 
   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);
+    async_closure = OpenAsyncFunction(func.token_pos());
   } else if (func.is_async_closure()) {
     OpenAsyncClosure();
   }
 
   BoolScope allow_await(&this->await_is_keyword_,
                         func.IsAsyncFunction() || func.is_async_closure());
   intptr_t end_token_pos = 0;
   if (CurrentToken() == Token::kLBRACE) {
     ConsumeToken();
     if (String::Handle(I, func.name()).Equals(Symbols::EqualOperator())) {
@@ skipping 2841 matching lines @@
   OpenBlock();
   PushTryBlock(current_block_);
 
   if (innermost_function().is_async_closure() ||
       innermost_function().IsAsyncFunction()) {
     SetupSavedTryContext(context_var);
   }
 }
 
 
-RawFunction* Parser::OpenAsyncFunction(intptr_t formal_param_pos) {
+RawFunction* Parser::OpenAsyncFunction(intptr_t async_func_pos) {
   TRACE_PARSER("OpenAsyncFunction");
   AddAsyncClosureVariables();
   Function& closure = Function::Handle(I);
   bool is_new_closure = false;
 
   // Check whether a function for the asynchronous function body of
   // this async function has already been created by a previous
   // compilation of this function.
   const Function& found_func = Function::Handle(
-      I, current_class().LookupClosureFunction(formal_param_pos));
+      I, current_class().LookupClosureFunction(async_func_pos));
   if (!found_func.IsNull() &&
-      (found_func.token_pos() == formal_param_pos) &&
+      (found_func.token_pos() == async_func_pos) &&
       (found_func.script() == innermost_function().script()) &&
       (found_func.parent_function() == innermost_function().raw())) {
     ASSERT(found_func.is_async_closure());
     closure = found_func.raw();
   } else {
     // Create the closure containing the body of this async function.
     const String& async_func_name =
         String::Handle(I, innermost_function().name());
     String& closure_name = String::Handle(I,
         String::NewFormatted("<%s_async_body>", async_func_name.ToCString()));
     closure = Function::NewClosureFunction(
         String::Handle(I, Symbols::New(closure_name)),
         innermost_function(),
-        formal_param_pos);
+        async_func_pos);
     closure.set_is_async_closure(true);
     closure.set_result_type(AbstractType::Handle(Type::DynamicType()));
     is_new_closure = true;
   }
   // Create the parameter list for the async body closure.
   ParamList closure_params;
   const Type& dynamic_type = Type::ZoneHandle(I, Type::DynamicType());
   closure_params.AddFinalParameter(
-      formal_param_pos, &Symbols::ClosureParameter(), &dynamic_type);
+      async_func_pos, &Symbols::ClosureParameter(), &dynamic_type);
   ParamDesc result_param;
   result_param.name = &Symbols::AsyncOperationParam();
   result_param.default_value = &Object::null_instance();
   result_param.type = &dynamic_type;
   closure_params.parameters->Add(result_param);
   ParamDesc error_param;
   error_param.name = &Symbols::AsyncOperationErrorParam();
   error_param.default_value = &Object::null_instance();
   error_param.type = &dynamic_type;
   closure_params.parameters->Add(error_param);
   closure_params.has_optional_positional_parameters = true;
   closure_params.num_optional_parameters += 2;
 
   if (is_new_closure) {
     // Add the parameters to the newly created closure.
     AddFormalParamsToFunction(&closure_params, closure);
 
     // Create and set the signature class of the closure.
     const String& sig = String::Handle(I, closure.Signature());
     Class& sig_cls = Class::Handle(I, library_.LookupLocalClass(sig));
     if (sig_cls.IsNull()) {
       sig_cls =
-          Class::NewSignatureClass(sig, closure, script_, formal_param_pos);
+          Class::NewSignatureClass(sig, closure, script_, closure.token_pos());
       library_.AddClass(sig_cls);
     }
     closure.set_signature_class(sig_cls);
     const Type& sig_type = Type::Handle(I, 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());
@@ skipping 6138 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart