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

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"
 
 namespace v8 {
 namespace internal {
 
 // Whereas the Parser generates AST during the recursive descent,
 // the PreParser doesn't create a tree. Instead, it passes around minimal
 // data objects (PreParserExpression, PreParserIdentifier etc.) which contain
 // just enough data for the upper layer functions. PreParserFactory is
 // responsible for creating these dummy objects. It provides a similar kind of
 // interface as AstNodeFactory, so ParserBase doesn't need to care which one is
 // used.
 
 class PreParserIdentifier {
  public:
   PreParserIdentifier() : type_(kUnknownIdentifier) {}
   static PreParserIdentifier Default() {
     return PreParserIdentifier(kUnknownIdentifier);
   }
+  static PreParserIdentifier Empty() {
+    return PreParserIdentifier(kEmptyIdentifier);
+  }
   static PreParserIdentifier Eval() {
     return PreParserIdentifier(kEvalIdentifier);
   }
   static PreParserIdentifier Arguments() {
     return PreParserIdentifier(kArgumentsIdentifier);
   }
   static PreParserIdentifier Undefined() {
     return PreParserIdentifier(kUndefinedIdentifier);
   }
   static PreParserIdentifier FutureReserved() {
@@ skipping 19 matching lines @@
   }
   static PreParserIdentifier Enum() {
     return PreParserIdentifier(kEnumIdentifier);
   }
   static PreParserIdentifier Await() {
     return PreParserIdentifier(kAwaitIdentifier);
   }
   static PreParserIdentifier Async() {
     return PreParserIdentifier(kAsyncIdentifier);
   }
+  bool IsEmpty() const { return type_ == kEmptyIdentifier; }
   bool IsEval() const { return type_ == kEvalIdentifier; }
   bool IsArguments() const { return type_ == kArgumentsIdentifier; }
   bool IsEvalOrArguments() const { return IsEval() || IsArguments(); }
   bool IsUndefined() const { return type_ == kUndefinedIdentifier; }
   bool IsLet() const { return type_ == kLetIdentifier; }
   bool IsStatic() const { return type_ == kStaticIdentifier; }
   bool IsYield() const { return type_ == kYieldIdentifier; }
   bool IsPrototype() const { return type_ == kPrototypeIdentifier; }
   bool IsConstructor() const { return type_ == kConstructorIdentifier; }
   bool IsEnum() const { return type_ == kEnumIdentifier; }
   bool IsAwait() const { return type_ == kAwaitIdentifier; }
   bool IsFutureStrictReserved() const {
     return type_ == kFutureStrictReservedIdentifier ||
            type_ == kLetIdentifier || type_ == kStaticIdentifier ||
            type_ == kYieldIdentifier;
   }
 
   // Allow identifier->name()[->length()] to work. The preparser
   // does not need the actual positions/lengths of the identifiers.
   const PreParserIdentifier* operator->() const { return this; }
   const PreParserIdentifier raw_name() const { return *this; }
 
   int position() const { return 0; }
   int length() const { return 0; }
 
  private:
   enum Type {
+    kEmptyIdentifier,
     kUnknownIdentifier,
     kFutureReservedIdentifier,
     kFutureStrictReservedIdentifier,
     kLetIdentifier,
     kStaticIdentifier,
     kYieldIdentifier,
     kEvalIdentifier,
     kArgumentsIdentifier,
     kUndefinedIdentifier,
     kPrototypeIdentifier,
@@ skipping 278 matching lines @@
 
 class PreParserStatement;
 typedef PreParserList<PreParserStatement> PreParserStatementList;
 
 class PreParserStatement {
  public:
   static PreParserStatement Default() {
     return PreParserStatement(kUnknownStatement);
   }
 
+  static PreParserStatement Null() {
+    return PreParserStatement(kNullStatement);
+  }
+
+  static PreParserStatement Empty() {
+    return PreParserStatement(kEmptyStatement);
+  }
+
   static PreParserStatement Jump() {
     return PreParserStatement(kJumpStatement);
   }
 
   static PreParserStatement FunctionDeclaration() {
     return PreParserStatement(kFunctionDeclaration);
   }
 
   // Creates expression statement from expression.
   // Preserves being an unparenthesized string literal, possibly
@@ skipping 24 matching lines @@
   bool IsUseAsmLiteral() { return code_ == kUseAsmExpressionStatement; }
 
   bool IsFunctionDeclaration() {
     return code_ == kFunctionDeclaration;
   }
 
   bool IsJumpStatement() {
     return code_ == kJumpStatement;
   }
 
+  bool IsNullStatement() { return code_ == kNullStatement; }
+
+  bool IsEmptyStatement() { return code_ == kEmptyStatement; }

[adamk, 2016/09/08 18:33:19]

Is this only called by IsNullOrEmptyStatement()? The two callers of that both
look suspicious to me, when could they return NULL? Having both Null and Empty
in the preparser seems possibly confusing so if we could get away without it I'd
be happier.

[nickie, 2016/09/09 09:42:27]

I think the confusion was originally created by "EmptyExpression", which the
parser implements as a nullptr.  This should rather be a "NullExpression" as
there's no such thing as an empty expression.

On the other hand, there's need for a "NullStatement" (which the parser
implements as a nullptr); this is returned, e.g., for *ok == false, or in other
exceptional cases.  And there's "EmptyStatement", which is a valid empty
statement (just the semicolon).

IsNullOrEmptyStatement() is used when checking the directive prologue.  I
thought it was not necessary there, but if you remove it some tests fail.  It
could be replaced there by "IsNullStatement() || IsEmptyStatement()", if you
prefer.

+
   // Dummy implementation for making statement->somefunc() work in both Parser
   // and PreParser.
   PreParserStatement* operator->() { return this; }
 
   PreParserStatementList statements() { return PreParserStatementList(); }
   void set_scope(Scope* scope) {}
 
  private:
   enum Type {
+    kNullStatement,
+    kEmptyStatement,
     kUnknownStatement,
     kJumpStatement,
     kStringLiteralExpressionStatement,
     kUseStrictExpressionStatement,
     kUseAsmExpressionStatement,
     kFunctionDeclaration
   };
 
   explicit PreParserStatement(Type code) : code_(code) {}
   Type code_;
@@ skipping 111 matching lines @@
     }
     return PreParserExpression::Call();
   }
   PreParserExpression NewCallNew(PreParserExpression expression,
                                  PreParserExpressionList arguments,
                                  int pos) {
     return PreParserExpression::Default();
   }
   PreParserStatement NewReturnStatement(PreParserExpression expression,
                                         int pos) {
-    return PreParserStatement::Default();
+    return PreParserStatement::Jump();
   }
   PreParserExpression NewFunctionLiteral(
       PreParserIdentifier name, Scope* scope, PreParserStatementList body,
       int materialized_literal_count, int expected_property_count,
       int parameter_count,
       FunctionLiteral::ParameterFlag has_duplicate_parameters,
       FunctionLiteral::FunctionType function_type,
       FunctionLiteral::EagerCompileHint eager_compile_hint, FunctionKind kind,
       int position) {
     return PreParserExpression::Default();
@@ skipping 15 matching lines @@
   PreParserStatement NewBlock(ZoneList<const AstRawString*>* labels,
                               int capacity, bool ignore_completion_value,
                               int pos) {
     return PreParserStatement::Default();
   }
 
   PreParserStatement NewDebuggerStatement(int pos) {
     return PreParserStatement::Default();
   }
 
+  PreParserStatement NewExpressionStatement(PreParserExpression expr, int pos) {
+    return PreParserStatement::ExpressionStatement(expr);
+  }
+
+  PreParserStatement NewIfStatement(PreParserExpression condition,
+                                    PreParserStatement then_statement,
+                                    PreParserStatement else_statement,
+                                    int pos) {
+    // This must return a jump statement iff both clauses are jump statements.
+    return else_statement.IsJumpStatement() ? then_statement : else_statement;
+  }
+
+  PreParserStatement NewBreakStatement(PreParserStatement target, int pos) {
+    return PreParserStatement::Jump();
+  }
+
+  PreParserStatement NewContinueStatement(PreParserStatement target, int pos) {
+    return PreParserStatement::Jump();
+  }
+
+  PreParserStatement NewWithStatement(Scope* scope,
+                                      PreParserExpression expression,
+                                      PreParserStatement statement, int pos) {
+    return PreParserStatement::Default();
+  }
+
   // Return the object itself as AstVisitor and implement the needed
   // dummy method right in this class.
   PreParserFactory* visitor() { return this; }
   int* ast_properties() {
     static int dummy = 42;
     return &dummy;
   }
 };
 
 
@@ skipping 33 matching lines @@
   typedef PreParserExpression Expression;
   typedef PreParserExpression FunctionLiteral;
   typedef PreParserExpression ObjectLiteralProperty;
   typedef PreParserExpression ClassLiteralProperty;
   typedef PreParserExpressionList ExpressionList;
   typedef PreParserExpressionList PropertyList;
   typedef PreParserFormalParameters FormalParameters;
   typedef PreParserStatement Statement;
   typedef PreParserStatementList StatementList;
   typedef PreParserStatement Block;
+  typedef PreParserStatement BreakableStatementT;
+  typedef PreParserStatement IterationStatementT;
 
   // For constructing objects returned by the traversing functions.
   typedef PreParserFactory Factory;
 
   typedef PreParserTarget Target;
   typedef PreParserTargetScope TargetScope;
 };
 
 
 // Preparsing checks a JavaScript program and emits preparse-data that helps
@@ skipping 93 matching lines @@
                                       bool default_export, bool* ok);
   Statement ParseHoistableDeclaration(int pos, ParseFunctionFlags flags,
                                       ZoneList<const AstRawString*>* names,
                                       bool default_export, bool* ok);
   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 ParseExpressionOrLabelledStatement(
-      ZoneList<const AstRawString*>* names,
-      AllowLabelledFunctionStatement allow_function, bool* ok);
-  Statement ParseIfStatement(ZoneList<const AstRawString*>* labels, bool* ok);
-  Statement ParseContinueStatement(bool* ok);
-  Statement ParseBreakStatement(ZoneList<const AstRawString*>* labels,
-                                bool* ok);
-  Statement ParseReturnStatement(bool* ok);
-  Statement ParseWithStatement(ZoneList<const AstRawString*>* labels, bool* ok);
   Statement ParseSwitchStatement(ZoneList<const AstRawString*>* labels,
                                  bool* ok);
   Statement ParseDoWhileStatement(ZoneList<const AstRawString*>* labels,
                                   bool* ok);
   Statement ParseWhileStatement(ZoneList<const AstRawString*>* labels,
                                 bool* ok);
   Statement ParseForStatement(ZoneList<const AstRawString*>* labels, bool* ok);
   Statement ParseThrowStatement(bool* ok);
   Statement ParseTryStatement(bool* ok);
   Expression ParseConditionalExpression(bool accept_IN, bool* ok);
@@ skipping 80 matching lines @@
                                                  int pos) {
     return PreParserExpression::Default();
   }
   V8_INLINE void RewriteNonPattern(bool* ok) { ValidateExpression(ok); }
 
   V8_INLINE void DeclareAndInitializeVariables(
       PreParserStatement block,
       const DeclarationDescriptor* declaration_descriptor,
       const DeclarationParsingResult::Declaration* declaration,
       ZoneList<const AstRawString*>* names, bool* ok) {}
+  V8_INLINE ZoneList<const AstRawString*>* DeclareLabel(
+      ZoneList<const AstRawString*>* labels, PreParserExpression expr,
+      bool* ok) {
+    DCHECK(!expr.AsIdentifier().IsEnum());
+    DCHECK(!parsing_module_ || !expr.AsIdentifier().IsAwait());
+    DCHECK(is_sloppy(language_mode()) ||
+           !IsFutureStrictReserved(expr.AsIdentifier()));
+    return labels;
+  }
+
+  V8_INLINE PreParserStatement ParseNativeDeclaration(bool* ok) {
+    UNREACHABLE();
+    return PreParserStatement::Default();
+  }
+
+  // TODO(nikolaos): The preparser currently does not keep track of labels.
+  V8_INLINE bool ContainsLabel(ZoneList<const AstRawString*>* labels,
+                               PreParserIdentifier label) {
+    return false;
+  }
+
+  V8_INLINE PreParserExpression RewriteReturn(PreParserExpression return_value,
+                                              int pos) {
+    return return_value;
+  }
+
+  // TODO(nikolaos): The preparser currently does not keep track of labels
+  // and targets.
+  V8_INLINE PreParserStatement LookupBreakTarget(PreParserIdentifier label,
+                                                 bool* ok) {
+    return PreParserStatement::Default();
+  }
+  V8_INLINE PreParserStatement LookupContinueTarget(PreParserIdentifier label,
+                                                    bool* ok) {
+    return PreParserStatement::Default();
+  }
 
   V8_INLINE void QueueDestructuringAssignmentForRewriting(
       PreParserExpression assignment) {}
   V8_INLINE void QueueNonPatternForRewriting(PreParserExpression expr,
                                              bool* ok) {}
 
   // Helper functions for recursive descent.
   V8_INLINE bool IsEval(PreParserIdentifier identifier) const {
     return identifier.IsEval();
   }
@@ skipping 42 matching lines @@
 
   V8_INLINE bool IsDirectEvalCall(PreParserExpression expression) const {
     return expression.IsDirectEvalCall();
   }
 
   V8_INLINE static bool IsBoilerplateProperty(PreParserExpression property) {
     // PreParser doesn't count boilerplate properties.
     return false;
   }
 
+  V8_INLINE bool IsNative(PreParserExpression expr) const {
+    // Preparsing is disabled for extensions (because the extension
+    // details aren't passed to lazily compiled functions), so we
+    // don't accept "native function" in the preparser and there is
+    // no need to keep track of "native".
+    return false;
+  }
+
   V8_INLINE static bool IsArrayIndex(PreParserIdentifier string,
                                      uint32_t* index) {
     return false;
   }
 
   V8_INLINE bool IsUseStrictDirective(PreParserStatement statement) const {
     return statement.IsUseStrictLiteral();
   }
 
   V8_INLINE bool IsUseAsmDirective(PreParserStatement statement) const {
@@ skipping 62 matching lines @@
   V8_INLINE void ReportMessageAt(Scanner::Location source_location,
                                  MessageTemplate::Template message,
                                  const char* arg = NULL,
                                  ParseErrorType error_type = kSyntaxError) {
     log_->LogMessage(source_location.beg_pos, source_location.end_pos, message,
                      arg, error_type);
   }
 
   V8_INLINE void ReportMessageAt(Scanner::Location source_location,
                                  MessageTemplate::Template message,
-                                 const AstRawString* arg,
+                                 PreParserIdentifier arg,
                                  ParseErrorType error_type = kSyntaxError) {
     UNREACHABLE();
   }
 
   // "null" return type creators.
   V8_INLINE static PreParserIdentifier EmptyIdentifier() {
-    return PreParserIdentifier::Default();
+    return PreParserIdentifier::Empty();
+  }
+  V8_INLINE static bool IsEmptyIdentifier(PreParserIdentifier name) {
+    return name.IsEmpty();
   }
   V8_INLINE static PreParserExpression EmptyExpression() {
     return PreParserExpression::Empty();
   }
   V8_INLINE static PreParserExpression EmptyLiteral() {
     return PreParserExpression::Default();
   }
   V8_INLINE static PreParserExpression EmptyObjectLiteralProperty() {
     return PreParserExpression::Default();
   }
@@ skipping 21 matching lines @@
   }
 
   V8_INLINE static bool IsNullStatementList(PreParserStatementList stmts) {
     return stmts.IsNull();
   }
 
   V8_INLINE static PreParserStatement NullStatement() {
     return PreParserStatement::Default();
   }
 
+  V8_INLINE bool IsNullStatement(PreParserStatement stmt) {
+    return stmt.IsNullStatement();
+  }
+
   V8_INLINE bool IsNullOrEmptyStatement(PreParserStatement stmt) {
-    // TODO(nikolaos): See if this needs to be consistent for the preparser.
-    return false;
+    return stmt.IsNullStatement() || stmt.IsEmptyStatement();
   }
 
   V8_INLINE static PreParserStatement NullBlock() {
     return PreParserStatement::Default();
   }
 
   V8_INLINE PreParserIdentifier EmptyIdentifierString() const {
     return PreParserIdentifier::Default();
   }
 
@@ skipping 195 matching lines @@
     function_state_->NextMaterializedLiteralIndex();
     function_state_->NextMaterializedLiteralIndex();
   }
   return EmptyExpression();
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PREPARSER_H