Revert "[parser] Simplify ParseFunctionBody"

This reverts commit 2963f1b2.

Reason for revert: Speculative revert, possibly causing timeout in layout test https://ci.chromium.org/p/chromium/builders/luci.chromium.ci/WebKit%20Linux%20Trusty%20MSAN/11631

Original change's description:
> [parser] Simplify ParseFunctionBody
> 
> - Merge is_simple branches at the top
> - Remove block around inner_body parsing. Always merge fully at the end.
> - Remove conditional inner block adding to outer body. Simply add it to the
>   inner body making merge push it to the parent.
> 
> Change-Id: I1f062918a7abac354b949136463517bd0440984f
> Reviewed-on: https://chromium-review.googlesource.com/c/1386111
> Commit-Queue: Toon Verwaest <verwaest@chromium.org>
> Reviewed-by: Igor Sheludko <ishell@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#58390}

TBR=ishell@chromium.org,verwaest@chromium.org

# Not skipping CQ checks because original CL landed > 1 day ago.

Change-Id: I0ab903df5caaadff56625e9b46b03981c8a9b930
Reviewed-on: https://chromium-review.googlesource.com/c/1388524Reviewed-by: Maya Lekova <mslekova@chromium.org>
Commit-Queue: Maya Lekova <mslekova@chromium.org>
Cr-Commit-Position: refs/heads/master@{#58436}

src/parsing/parser-base.h

@@ -3808,13 +3808,9 @@ void ParserBase<Impl>::ParseFunctionBody(
     const FormalParametersT& parameters, FunctionKind kind,
     FunctionLiteral::FunctionType function_type, FunctionBodyType body_type) {
   if (IsResumableFunction(kind)) impl()->PrepareGeneratorVariables();
-
-  DeclarationScope* function_scope = parameters.scope;
-  DeclarationScope* inner_scope = function_scope;
-
   // Building the parameter initialization block declares the parameters.
   // TODO(verwaest): Rely on ArrowHeadParsingScope instead.
-  if (V8_UNLIKELY(!parameters.is_simple)) {
+  if (!parameters.is_simple) {
     if (has_error()) return;
     BlockT init_block = impl()->BuildParameterInitializationBlock(parameters);
     if (IsAsyncFunction(kind) && !IsAsyncGeneratorFunction(kind)) {
@@ -3822,92 +3818,100 @@ void ParserBase<Impl>::ParseFunctionBody(
     }
     body->Add(init_block);
     if (has_error()) return;
-
-    inner_scope = NewVarblockScope();
-    inner_scope->set_start_position(scanner()->location().beg_pos);
   }
 
-  StatementListT inner_body(pointer_buffer());
-
+  DeclarationScope* function_scope = scope()->AsDeclarationScope();
+  bool allow_duplicate_parameters = false;
+  BlockT inner_block = impl()->NullBlock();
   {
-    BlockState block_state(&scope_, inner_scope);
+    StatementListT inner_body(pointer_buffer());
+    DeclarationScope* inner_scope = function_scope;
 
-    if (body_type == FunctionBodyType::kExpression) {
-      ExpressionT expression = ParseAssignmentExpression();
+    if (!parameters.is_simple) {
+      inner_scope = NewVarblockScope();
+      inner_scope->set_start_position(scanner()->location().beg_pos);
+    }
 
-      if (IsAsyncFunction(kind)) {
-        BlockT block = factory()->NewBlock(1, true);
-        impl()->RewriteAsyncFunctionBody(&inner_body, block, expression);
-      } else {
-        inner_body.Add(
-            BuildReturnStatement(expression, expression->position()));
-      }
-    } else {
-      DCHECK(accept_IN_);
-      DCHECK_EQ(FunctionBodyType::kBlock, body_type);
-      // If we are parsing the source as if it is wrapped in a function, the
-      // source ends without a closing brace.
-      Token::Value closing_token = function_type == FunctionLiteral::kWrapped
-                                       ? Token::EOS
-                                       : Token::RBRACE;
-
-      if (IsAsyncGeneratorFunction(kind)) {
-        impl()->ParseAndRewriteAsyncGeneratorFunctionBody(pos, kind,
-                                                          &inner_body);
-      } else if (IsGeneratorFunction(kind)) {
-        impl()->ParseAndRewriteGeneratorFunctionBody(pos, kind, &inner_body);
-      } else if (IsAsyncFunction(kind)) {
-        ParseAsyncFunctionBody(inner_scope, &inner_body);
+    {
+      BlockState block_state(&scope_, inner_scope);
+
+      if (body_type == FunctionBodyType::kExpression) {
+        ExpressionT expression = ParseAssignmentExpression();
+
+        if (IsAsyncFunction(kind)) {
+          BlockT block = factory()->NewBlock(1, true);
+          impl()->RewriteAsyncFunctionBody(&inner_body, block, expression);
+        } else {
+          inner_body.Add(
+              BuildReturnStatement(expression, expression->position()));
+        }
       } else {
-        ParseStatementList(&inner_body, closing_token);
-      }
+        DCHECK(accept_IN_);
+        DCHECK_EQ(FunctionBodyType::kBlock, body_type);
+        // If we are parsing the source as if it is wrapped in a function, the
+        // source ends without a closing brace.
+        Token::Value closing_token = function_type == FunctionLiteral::kWrapped
+                                         ? Token::EOS
+                                         : Token::RBRACE;
+
+        if (IsAsyncGeneratorFunction(kind)) {
+          impl()->ParseAndRewriteAsyncGeneratorFunctionBody(pos, kind,
+                                                            &inner_body);
+        } else if (IsGeneratorFunction(kind)) {
+          impl()->ParseAndRewriteGeneratorFunctionBody(pos, kind, &inner_body);
+        } else if (IsAsyncFunction(kind)) {
+          ParseAsyncFunctionBody(inner_scope, &inner_body);
+        } else {
+          ParseStatementList(&inner_body, closing_token);
+        }
 
-      if (IsDerivedConstructor(kind)) {
-        inner_body.Add(factory()->NewReturnStatement(impl()->ThisExpression(),
-                                                     kNoSourcePosition));
+        if (IsDerivedConstructor(kind)) {
+          inner_body.Add(factory()->NewReturnStatement(impl()->ThisExpression(),
+                                                       kNoSourcePosition));
+        }
+        Expect(closing_token);
       }
-      Expect(closing_token);
     }
-  }
 
-  scope()->set_end_position(end_position());
+    scope()->set_end_position(end_position());
 
-  bool allow_duplicate_parameters = false;
+    if (parameters.is_simple) {
+      DCHECK_EQ(inner_scope, function_scope);
+      if (is_sloppy(function_scope->language_mode())) {
+        impl()->InsertSloppyBlockFunctionVarBindings(function_scope);
+      }
+      allow_duplicate_parameters = is_sloppy(function_scope->language_mode()) &&
+                                   !IsConciseMethod(kind) &&
+                                   !IsArrowFunction(kind);
+    } else {
+      DCHECK_NOT_NULL(inner_scope);
+      DCHECK_EQ(function_scope, scope());
+      DCHECK_EQ(function_scope, inner_scope->outer_scope());
+      impl()->SetLanguageMode(function_scope, inner_scope->language_mode());
 
-  if (V8_LIKELY(parameters.is_simple)) {
-    DCHECK_EQ(inner_scope, function_scope);
-    if (is_sloppy(function_scope->language_mode())) {
-      impl()->InsertSloppyBlockFunctionVarBindings(function_scope);
-    }
-    allow_duplicate_parameters = is_sloppy(function_scope->language_mode()) &&
-                                 !IsConciseMethod(kind) &&
-                                 !IsArrowFunction(kind);
-  } else {
-    DCHECK_NOT_NULL(inner_scope);
-    DCHECK_EQ(function_scope, scope());
-    DCHECK_EQ(function_scope, inner_scope->outer_scope());
-    impl()->SetLanguageMode(function_scope, inner_scope->language_mode());
-
-    if (is_sloppy(inner_scope->language_mode())) {
-      impl()->InsertSloppyBlockFunctionVarBindings(inner_scope);
-    }
-
-    inner_scope->set_end_position(end_position());
-    if (inner_scope->FinalizeBlockScope() != nullptr) {
-      BlockT inner_block = factory()->NewBlock(true, inner_body);
-      inner_body.Rewind();
-      inner_body.Add(inner_block);
-      inner_block->set_scope(inner_scope);
-      const AstRawString* conflict = inner_scope->FindVariableDeclaredIn(
-          function_scope, VariableMode::kLastLexicalVariableMode);
-      if (conflict != nullptr) {
-        impl()->ReportVarRedeclarationIn(conflict, inner_scope);
+      if (is_sloppy(inner_scope->language_mode())) {
+        impl()->InsertSloppyBlockFunctionVarBindings(inner_scope);
+      }
+
+      inner_scope->set_end_position(end_position());
+      if (inner_scope->FinalizeBlockScope() != nullptr) {
+        inner_block = factory()->NewBlock(true, inner_body);
+        inner_body.Rewind();
+        inner_block->set_scope(inner_scope);
+        const AstRawString* conflict = inner_scope->FindVariableDeclaredIn(
+            function_scope, VariableMode::kLastLexicalVariableMode);
+        if (conflict != nullptr) {
+          impl()->ReportVarRedeclarationIn(conflict, inner_scope);
+        }
+        impl()->CheckConflictingVarDeclarations(inner_scope);
+        impl()->InsertShadowingVarBindingInitializers(inner_block);
       }
-      impl()->CheckConflictingVarDeclarations(inner_scope);
-      impl()->InsertShadowingVarBindingInitializers(inner_block);
     }
+    inner_body.MergeInto(body);
   }
 
+  if (!impl()->IsNull(inner_block)) body->Add(inner_block);
+
   ValidateFormalParameters(language_mode(), parameters,
                            allow_duplicate_parameters);
 
@@ -3919,8 +3923,6 @@ void ParserBase<Impl>::ParseFunctionBody(
   }
 
   impl()->DeclareFunctionNameVar(function_name, function_type, function_scope);
-
-  inner_body.MergeInto(body);
 }
 
 template <typename Impl>