[parser] Only track parsing-mode (and possibly switch to the preparser) in the parser

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 180 matching lines @@
   const Impl* impl() const { return static_cast<const Impl*>(this); }
 
   ParserBase(Zone* zone, Scanner* scanner, uintptr_t stack_limit,
              v8::Extension* extension, AstValueFactory* ast_value_factory)
       : scope_state_(nullptr),
         function_state_(nullptr),
         extension_(extension),
         fni_(nullptr),
         ast_value_factory_(ast_value_factory),
         ast_node_factory_(ast_value_factory),
-        mode_(PARSE_EAGERLY),  // Lazy mode must be set explicitly.
         parsing_module_(false),
         stack_limit_(stack_limit),
         zone_(zone),
         classifier_(nullptr),
         scanner_(scanner),
         stack_overflow_(false),
         default_eager_compile_hint_(FunctionLiteral::kShouldLazyCompile),
         allow_lazy_(false),
         allow_natives_(false),
         allow_tailcalls_(false),
@@ skipping 372 matching lines @@
           next_materialized_literal_index_;
       function_state_->expected_property_count_ = expected_property_count_;
     }
 
    private:
     FunctionState* function_state_;
     int next_materialized_literal_index_;
     int expected_property_count_;
   };
 
-  class ParsingModeScope BASE_EMBEDDED {
-   public:
-    ParsingModeScope(ParserBase* parser, Mode mode)
-        : parser_(parser),
-          old_mode_(parser->mode()) {
-      parser_->mode_ = mode;
-    }
-    ~ParsingModeScope() {
-      parser_->mode_ = old_mode_;
-    }
-
-   private:
-    ParserBase* parser_;
-    Mode old_mode_;
-  };
-
   struct DeclarationDescriptor {
     enum Kind { NORMAL, PARAMETER };
     Scope* scope;
     Scope* hoist_scope;
     VariableMode mode;
     int declaration_pos;
     int initialization_pos;
     Kind declaration_kind;
   };
 
@@ skipping 126 matching lines @@
   V8_INLINE DeclarationScope* GetClosureScope() const {
     return scope()->GetClosureScope();
   }
 
   Scanner* scanner() const { return scanner_; }
   AstValueFactory* ast_value_factory() const { return ast_value_factory_; }
   int position() const { return scanner_->location().beg_pos; }
   int peek_position() const { return scanner_->peek_location().beg_pos; }
   bool stack_overflow() const { return stack_overflow_; }
   void set_stack_overflow() { stack_overflow_ = true; }
-  Mode mode() const { return mode_; }
 
   INLINE(Token::Value peek()) {
     if (stack_overflow_) return Token::ILLEGAL;
     return scanner()->peek();
   }
 
   INLINE(Token::Value PeekAhead()) {
     if (stack_overflow_) return Token::ILLEGAL;
     return scanner()->PeekAhead();
   }
@@ skipping 666 matching lines @@
   }
 
   // Parser base's protected field members.
 
   ScopeState* scope_state_;        // Scope stack.
   FunctionState* function_state_;  // Function state stack.
   v8::Extension* extension_;
   FuncNameInferrer* fni_;
   AstValueFactory* ast_value_factory_;  // Not owned.
   typename Types::Factory ast_node_factory_;
-  Mode mode_;
   bool parsing_module_;
   uintptr_t stack_limit_;
 
   // Parser base's private field members.
 
  private:
   Zone* zone_;
   ExpressionClassifier* classifier_;
 
   Scanner* scanner_;
@@ skipping 2463 matching lines @@
     return impl()->EmptyExpression();
   }
 
   StatementListT body = impl()->NullStatementList();
   int materialized_literal_count = -1;
   int expected_property_count = -1;
 
   FunctionKind kind = formal_parameters.scope->function_kind();
   FunctionLiteral::EagerCompileHint eager_compile_hint =
       default_eager_compile_hint_;
-  bool can_preparse = mode() == PARSE_LAZILY &&
+  bool can_preparse = impl()->mode() == PARSE_LAZILY &&
                       eager_compile_hint == FunctionLiteral::kShouldLazyCompile;
   // TODO(marja): consider lazy-parsing inner arrow functions too. is_this
   // handling in Scope::ResolveVariable needs to change.
   bool is_lazy_top_level_function =
       can_preparse && impl()->AllowsLazyParsingWithoutUnresolvedVariables();
   bool should_be_used_once_hint = false;
   {
     FunctionState function_state(&function_state_, &scope_state_,
                                  formal_parameters.scope);
 
@@ skipping 460 matching lines @@
         if (!scope()->HasSimpleParameters()) {
           // TC39 deemed "use strict" directives to be an error when occurring
           // in the body of a function with non-simple parameter list, on
           // 29/7/2015. https://goo.gl/ueA7Ln
           impl()->ReportMessageAt(
               token_loc, MessageTemplate::kIllegalLanguageModeDirective,
               "use strict");
           *ok = false;
           return kLazyParsingComplete;
         }
-        // Because declarations in strict eval code don't leak into the scope
-        // of the eval call, it is likely that functions declared in strict
-        // eval code will be used within the eval code, so lazy parsing is
-        // probably not a win.
-        if (scope()->is_eval_scope()) mode_ = PARSE_EAGERLY;

[Toon Verwaest, 2016/11/07 14:38:13]

There is no equivalent in the new version. We're trying to drop all such special
heuristics and always preparse instead. It's not because declarations don't leak
outside that you couldn't use strict eval to for example eval an entire program.
And programs don't necessarily use all code, which is why preparsing makes sense
in the first place.

[vogelheim, 2016/11/07 14:56:17]

Thanks for the comment; I wouldn't have understood this without... :)

       } else if (impl()->IsUseAsmDirective(stat) &&
                  token_loc.end_pos - token_loc.beg_pos ==
                      sizeof("use asm") + 1) {
         // Directive "use asm".
         impl()->SetAsmModule();
       } else if (impl()->IsStringLiteral(stat)) {
         // Possibly an unknown directive.
         // Should not change mode, but will increment usage counters
         // as appropriate. Ditto usages below.
         RaiseLanguageMode(SLOPPY);
@@ skipping 1039 matching lines @@
     has_seen_constructor_ = true;
     return;
   }
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_BASE_H