[parser] Refactor of Parse*Statement*, part 7

src/parsing/preparser.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_PREPARSER_H
 #define V8_PARSING_PREPARSER_H
 
 #include "src/ast/scopes.h"
 #include "src/parsing/parser-base.h"
 
@@ skipping 807 matching lines @@
   // which is set to false if parsing failed; it is unchanged otherwise.
   // By making the 'exception handling' explicit, we are forced to check
   // for failure at the call sites.
   Statement ParseFunctionDeclaration(bool* ok);
   Statement ParseAsyncFunctionDeclaration(ZoneList<const AstRawString*>* names,
                                           bool default_export, bool* ok);
   Expression ParseAsyncFunctionExpression(bool* ok);
   Statement ParseClassDeclaration(ZoneList<const AstRawString*>* names,
                                   bool default_export, bool* ok);
   Statement ParseForStatement(ZoneList<const AstRawString*>* labels, bool* ok);
-  Statement ParseTryStatement(bool* ok);
   Expression ParseConditionalExpression(bool accept_IN, bool* ok);
   Expression ParseObjectLiteral(bool* ok);
 
   V8_INLINE PreParserStatementList ParseEagerFunctionBody(
       PreParserIdentifier function_name, int pos,
       const PreParserFormalParameters& parameters, FunctionKind kind,
       FunctionLiteral::FunctionType function_type, bool* ok);
 
   V8_INLINE LazyParsingResult
   SkipLazyFunctionBody(int* materialized_literal_count,
@@ skipping 100 matching lines @@
 
   V8_INLINE PreParserExpression RewriteReturn(PreParserExpression return_value,
                                               int pos) {
     return return_value;
   }
   V8_INLINE PreParserStatement RewriteSwitchStatement(
       PreParserExpression tag, PreParserStatement switch_statement,
       PreParserStatementList cases, Scope* scope) {
     return PreParserStatement::Default();
   }
+  V8_INLINE void RewriteCatchPattern(CatchInfo* catch_info, bool* ok) {}
+  V8_INLINE void ValidateCatchBlock(const CatchInfo& catch_info, bool* ok) {}
+  V8_INLINE PreParserStatement RewriteTryStatement(
+      PreParserStatement try_block, PreParserStatement catch_block,
+      PreParserStatement finally_block, const CatchInfo& catch_info, int pos,
+      bool* ok) {

[marja, 2016/09/14 10:06:59]

Now this code is in both Parser and PreParser; what's the reason for not writing
it in a unified manner?

[nickie, 2016/09/14 10:19:09]

Well, for some weird reason, in the two implementations this code is guarded by
different conditions.  It won't be easy to keep the same behavior and make the
code look handsome.  If it comes to changing the behavior, I'm not sure what
exactly this does.

[marja, 2016/09/14 11:00:27]

I think that should get figured out before landing this...

If it turns out that there was really a behavioral difference, i.e., Parser was
producing an error where PreParser wasn't, or the other way around, I think that
should be fixed as a side product of this unification. That would also be a good
opportunity to add the corresponding test-parsing unification test.

So let's see:

In PreParser:

if (FLAG_harmony_explicit_tailcalls && catch_block_exists &&
    tail_call_expressions_in_catch_block.has_explicit_tail_calls()) {

...

In Parser:

if (FLAG_harmony_explicit_tailcalls &&
    tail_call_expressions_in_catch_block.has_explicit_tail_calls()) {


I think they are the same; there's no way that
tail_call_expressions_in_catch_block has something and  catch_block_exists
wouldn't be set to true.

[nickie, 2016/09/14 11:43:08]

Done.  (As discussed offline.)

+    if (FLAG_harmony_explicit_tailcalls && !catch_block.IsNullStatement() &&
+        catch_info.tail_call_expressions.has_explicit_tail_calls()) {
+      // TODO(ishell): update chapter number.
+      // ES8 XX.YY.ZZ
+      ReportMessageAt(catch_info.tail_call_expressions.location(),
+                      MessageTemplate::kUnexpectedTailCallInCatchBlock);
+      *ok = false;
+    }
+    return PreParserStatement::Default();
+  }
 
   V8_INLINE PreParserExpression RewriteDoExpression(PreParserStatement body,
                                                     int pos, bool* ok) {
     return PreParserExpression::Default();
   }
 
   // TODO(nikolaos): The preparser currently does not keep track of labels
   // and targets.
   V8_INLINE PreParserStatement LookupBreakTarget(PreParserIdentifier label,
                                                  bool* ok) {
@@ skipping 214 matching lines @@
 
   V8_INLINE static PreParserStatementList NullStatementList() {
     return PreParserStatementList::Null();
   }
 
   V8_INLINE static bool IsNullStatementList(PreParserStatementList stmts) {
     return stmts.IsNull();
   }
 
   V8_INLINE static PreParserStatement NullStatement() {
-    return PreParserStatement::Default();
+    return PreParserStatement::Null();
   }
 
   V8_INLINE bool IsNullStatement(PreParserStatement stmt) {
     return stmt.IsNullStatement();
   }
 
   V8_INLINE bool IsEmptyStatement(PreParserStatement stmt) {
     return stmt.IsEmptyStatement();
   }
 
   V8_INLINE static PreParserStatement NullBlock() {
-    return PreParserStatement::Default();
+    return PreParserStatement::Null();
   }
 
   V8_INLINE PreParserIdentifier EmptyIdentifierString() const {
     return PreParserIdentifier::Default();
   }
 
   // Odd-ball literal creators.
   V8_INLINE PreParserExpression GetLiteralTheHole(int position) {
     return PreParserExpression::Default();
   }
@@ skipping 200 matching lines @@
     function_state_->NextMaterializedLiteralIndex();
     function_state_->NextMaterializedLiteralIndex();
   }
   return EmptyExpression();
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PREPARSER_H