[async-await] (simpler) fix for Return in try/finally in async functions

src/parsing/parser-base.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_PARSING_PARSER_BASE_H
 #define V8_PARSING_PARSER_BASE_H
 
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
 #include "src/bailout-reason.h"
@@ skipping 409 matching lines @@
     void SkipMaterializedLiterals(int count) {
       next_materialized_literal_index_ += count;
     }
 
     void AddProperty() { expected_property_count_++; }
     int expected_property_count() { return expected_property_count_; }
 
     FunctionKind kind() const { return scope()->function_kind(); }
     FunctionState* outer() const { return outer_function_state_; }
 
-    void set_generator_object_variable(typename Types::Variable* variable) {
-      DCHECK_NOT_NULL(variable);
-      DCHECK(IsResumableFunction(kind()));
-      DCHECK(scope()->has_forced_context_allocation());
-      generator_object_variable_ = variable;
-    }
     typename Types::Variable* generator_object_variable() const {
-      return generator_object_variable_;
+      return scope()->generator_object_var();
     }
 
-    void set_promise_variable(typename Types::Variable* variable) {
-      DCHECK(variable != NULL);
-      DCHECK(IsAsyncFunction(kind()));
-      promise_variable_ = variable;
-    }
     typename Types::Variable* promise_variable() const {
-      return promise_variable_;
+      return scope()->promise_var();
     }
 
     const ZoneList<DestructuringAssignment>&
         destructuring_assignments_to_rewrite() const {
       return destructuring_assignments_to_rewrite_;
     }
 
     TailCallExpressionList& tail_call_expressions() {
       return tail_call_expressions_;
     }
@@ skipping 919 matching lines @@
       if (is_sloppy(scope->language_mode())) {
         // For sloppy scopes we also have to record the call at function level,
         // in case it includes declarations that will be hoisted.
         scope->GetDeclarationScope()->RecordEvalCall();
       }
       return Call::IS_POSSIBLY_EVAL;
     }
     return Call::NOT_EVAL;
   }
 
+  inline StatementT NewReturnStatement(ExpressionT expr, int pos) {
+    if (V8_UNLIKELY(is_async_function())) {
+      return factory()->NewAsyncReturnStatement(expr, pos);
+    }
+    return factory()->NewReturnStatement(expr, pos);
+  }
+
   // Validation per ES6 object literals.
   class ObjectLiteralChecker {
    public:
     explicit ObjectLiteralChecker(ParserBase* parser)
         : parser_(parser), has_seen_proto_(false) {}
 
     void CheckDuplicateProto(Token::Value property);
 
    private:
     bool IsProto() { return this->scanner()->LiteralMatches("__proto__", 9); }
@@ skipping 2873 matching lines @@
           formal_parameters, body, kind == kAsyncArrowFunction, CHECK_OK);
       ExpressionClassifier classifier(this);
       if (kind == kAsyncArrowFunction) {
         ParseAsyncFunctionBody(scope(), body, kAsyncArrowFunction,
                                FunctionBodyType::kSingleExpression, accept_IN,
                                pos, CHECK_OK);
         impl()->RewriteNonPattern(CHECK_OK);
       } else {
         ExpressionT expression = ParseAssignmentExpression(accept_IN, CHECK_OK);
         impl()->RewriteNonPattern(CHECK_OK);
-        body->Add(
-            factory()->NewReturnStatement(expression, expression->position()),
-            zone());
+        body->Add(NewReturnStatement(expression, expression->position()),
+                  zone());

[Dan Ehrenberg, 2017/02/10 07:51:31]

Nit: Revert irrelevant formatting change

[caitp, 2017/02/10 08:05:07]

This isn't a formatting change, but the formatting does look weird, will fix
that later

         if (allow_tailcalls() && !is_sloppy(language_mode())) {
           // ES6 14.6.1 Static Semantics: IsInTailPosition
           impl()->MarkTailPosition(expression);
         }
       }
       materialized_literal_count = function_state.materialized_literal_count();
       expected_property_count = function_state.expected_property_count();
       impl()->MarkCollectedTailCallExpressions();
     }
 
@@ skipping 884 matching lines @@
       return_value = ParseExpression(true, CHECK_OK);
 
       if (allow_tailcalls() && !is_sloppy(language_mode()) && !is_resumable()) {
         // ES6 14.6.1 Static Semantics: IsInTailPosition
         function_state_->AddImplicitTailCallExpression(return_value);
       }
     }
   }
   ExpectSemicolon(CHECK_OK);
   return_value = impl()->RewriteReturn(return_value, loc.beg_pos);
-  return factory()->NewReturnStatement(return_value, loc.beg_pos);
+  return NewReturnStatement(return_value, loc.beg_pos);
 }
 
 template <typename Impl>
 typename ParserBase<Impl>::StatementT ParserBase<Impl>::ParseWithStatement(
     ZoneList<const AstRawString*>* labels, bool* ok) {
   // WithStatement ::
   //   'with' '(' Expression ')' Statement
 
   Expect(Token::WITH, CHECK_OK);
   int pos = position();
@@ skipping 577 matching lines @@
 }
 
 #undef CHECK_OK
 #undef CHECK_OK_CUSTOM
 #undef CHECK_OK_VOID
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_BASE_H