[parser] Refactor some CHECK_OK calls

src/parsing/preparser.cc

 // Copyright 2011 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.
 
 #include <cmath>
 
 #include "src/allocation.h"
 #include "src/base/logging.h"
 #include "src/conversions-inl.h"
 #include "src/conversions.h"
 #include "src/globals.h"
 #include "src/list.h"
 #include "src/parsing/parser-base.h"
 #include "src/parsing/preparse-data-format.h"
 #include "src/parsing/preparse-data.h"
 #include "src/parsing/preparser.h"
 #include "src/unicode.h"
 #include "src/utils.h"
 
 namespace v8 {
 namespace internal {
 
+// ----------------------------------------------------------------------------
+// The CHECK_OK macro is a convenient macro to enforce error
+// handling for functions that may fail (by returning !*ok).
+//
+// CAUTION: This macro appends extra statements after a call,
+// thus it must never be used where only a single statement
+// is correct (e.g. an if statement branch w/o braces)!
+
+#define CHECK_OK  ok);                   \
+  if (!*ok) return Statement::Default(); \
+  ((void)0
+#define DUMMY )  // to make indentation work
+#undef DUMMY
+
+// Used in functions where the return type is not ExpressionT.
+#define CHECK_OK_CUSTOM(x) ok); \
+  if (!*ok) return this->x();   \
+  ((void)0
+#define DUMMY )  // to make indentation work
+#undef DUMMY
+
 void PreParserTraits::ReportMessageAt(Scanner::Location location,
                                       MessageTemplate::Template message,
                                       const char* arg,
                                       ParseErrorType error_type) {
   ReportMessageAt(location.beg_pos, location.end_pos, message, arg, error_type);
 }
 
 
 void PreParserTraits::ReportMessageAt(int start_pos, int end_pos,
                                       MessageTemplate::Template message,
@@ skipping 186 matching lines @@
   bool maybe_reset = bookmark != nullptr;
   int count_statements = 0;
 
   bool directive_prologue = true;
   while (peek() != end_token) {
     if (directive_prologue && peek() != Token::STRING) {
       directive_prologue = false;
     }
     bool starts_with_identifier = peek() == Token::IDENTIFIER;
     Scanner::Location token_loc = scanner()->peek_location();
-    Statement statement = ParseStatementListItem(ok);
-    if (!*ok) return;
+    Statement statement = ParseStatementListItem(CHECK_OK_CUSTOM(Void));
 
     if (directive_prologue) {
       bool use_strict_found = statement.IsUseStrictLiteral();
 
       if (use_strict_found) {
         scope_->SetLanguageMode(
             static_cast<LanguageMode>(scope_->language_mode() | STRICT));
       } else if (!statement.IsStringLiteral()) {
         directive_prologue = false;
       }
@@ skipping 20 matching lines @@
       if (count_statements > kLazyParseTrialLimit) {
         bookmark->Reset();
         return;
       }
       maybe_reset = false;
     }
   }
 }
 
 
-#define CHECK_OK  ok);                   \
-  if (!*ok) return Statement::Default();  \
-  ((void)0
-#define DUMMY )  // to make indentation work
-#undef DUMMY
-
 PreParser::Statement PreParser::ParseStatement(
     AllowLabelledFunctionStatement allow_function, bool* ok) {
   // Statement ::
   //   EmptyStatement
   //   ...
 
   if (peek() == Token::SEMICOLON) {
     Next();
     return Statement::Default();
   }
@@ skipping 624 matching lines @@
                                         ReturnExprContext::kInsideForInOfBody);
           ParseScopedStatement(true, CHECK_OK);
         }
         return Statement::Default();
       }
     } else {
       int lhs_beg_pos = peek_position();
       ExpressionClassifier classifier(this);
       Expression lhs = ParseExpression(false, &classifier, CHECK_OK);
       int lhs_end_pos = scanner()->location().end_pos;
-      bool is_for_each = CheckInOrOf(&mode, ok);
-      if (!*ok) return Statement::Default();
+      bool is_for_each = CheckInOrOf(&mode, CHECK_OK);
       bool is_destructuring = is_for_each &&
                               (lhs->IsArrayLiteral() || lhs->IsObjectLiteral());
 
       if (is_destructuring) {
         ValidateAssignmentPattern(&classifier, CHECK_OK);
       } else {
         ValidateExpression(&classifier, CHECK_OK);
       }
 
       if (is_for_each) {
@@ skipping 138 matching lines @@
   // break point is present.
   // DebuggerStatement ::
   //   'debugger' ';'
 
   Expect(Token::DEBUGGER, CHECK_OK);
   ExpectSemicolon(ok);
   return Statement::Default();
 }
 
 
+// Redefinition of CHECK_OK for parsing expressions.
 #undef CHECK_OK
 #define CHECK_OK  ok);                     \
   if (!*ok) return Expression::Default();  \
   ((void)0
 #define DUMMY )  // to make indentation work
 #undef DUMMY
 
 
 PreParser::Expression PreParser::ParseFunctionLiteral(
     Identifier function_name, Scanner::Location function_name_location,
@@ skipping 203 matching lines @@
   Expect(Token::RBRACE, CHECK_OK);
   return PreParserExpression::Default();
 }
 
 void PreParserTraits::ParseAsyncArrowSingleExpressionBody(
     PreParserStatementList body, bool accept_IN,
     Type::ExpressionClassifier* classifier, int pos, bool* ok) {
   Scope* scope = pre_parser_->scope_;
   scope->ForceContextAllocation();
 
-  PreParserExpression return_value =
-      pre_parser_->ParseAssignmentExpression(accept_IN, classifier, ok);
-  if (!*ok) return;
+  PreParserExpression return_value = pre_parser_->ParseAssignmentExpression(
+      accept_IN, classifier, CHECK_OK_CUSTOM(Void));
 
   body->Add(PreParserStatement::ExpressionStatement(return_value), zone());
 }
 
 #undef CHECK_OK
+#undef CHECK_OK_CUSTOM
 
 
 }  // namespace internal
 }  // namespace v8