Fully deserialize the scope chain after parsing, not before

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 166 matching lines @@
       : scope_state_(nullptr),
         function_state_(nullptr),
         extension_(extension),
         fni_(nullptr),
         ast_value_factory_(ast_value_factory),
         ast_node_factory_(ast_value_factory),
         log_(log),
         mode_(PARSE_EAGERLY),  // Lazy mode must be set explicitly.
         parsing_module_(false),
         stack_limit_(stack_limit),
+        outermost_receiver_function_kind_(kNormalFunction),
+        outermost_receiver_scope_type_(SCRIPT_SCOPE),
         zone_(zone),
         classifier_(nullptr),
         scanner_(scanner),
         stack_overflow_(false),
         allow_lazy_(false),
         allow_natives_(false),
         allow_tailcalls_(false),
         allow_harmony_restrictive_declarations_(false),
         allow_harmony_do_expressions_(false),
         allow_harmony_for_in_(false),
@@ skipping 662 matching lines @@
 
   // Determine precedence of given token.
   static int Precedence(Token::Value token, bool accept_IN) {
     if (token == Token::IN && !accept_IN)
       return 0;  // 0 precedence will terminate binary expression parsing
     return Token::Precedence(token);
   }
 
   typename Types::Factory* factory() { return &ast_node_factory_; }
 
-  DeclarationScope* GetReceiverScope() const {
-    return scope()->GetReceiverScope();
+  FunctionKind GetReceiverScopeFunctionKind() const {
+    DeclarationScope* receiver_scope = scope()->GetReceiverScope();
+    if (receiver_scope->outer_scope()) return receiver_scope->function_kind();
+    return outermost_receiver_function_kind_;
+  }
+  void RecordSuperPropertyUsage() {
+    DeclarationScope* receiver_scope = scope()->GetReceiverScope();
+    // If the receiver scope is the outermost script scope, a) it might not be

[adamk, 2016/09/12 16:57:47]

This comment points to some weirdness in this CL. The parser now has to think
about two different states, one where it has outer scopes and one where it
doesn't. And for every bit of outer-scope handling it does, some consideration
must be made as to what the right handling is.

This means that code which naively does something with
scope()->GetReceiverScope() is now wrong.

[jochen (gone - plz use gerrit), 2016/09/12 19:00:43]

it's a bit easier - the parser just never has an correct outer scope. Of course,
this still means that using GetReceiverScope() will result in an incorrect scope
if we parse an arrow function or eval.

[adamk, 2016/09/12 21:35:11]

The two modes I'm talking about are:

- Deep inside some inner scope, in which case the "outer scope chain" _is_
available (since we're in the middle of parsing it)
- Near the outer scope, in which case we have to have special logic

Previously if I was parsing an expression I didn't have to care where in the
scope chain I was; no I do.

+    // the correct receiver scope as the correct one might first get
+    // deserialized later, and b) recording is pointless anyways, as we won't
+    // create a scope infos for deserialized scopes.
+    if (receiver_scope->outer_scope()) {
+      receiver_scope->RecordSuperPropertyUsage();
+    }
+  }
+  ScopeType GetReceiverScopeType() const {
+    Scope* receiver_scope = scope()->GetReceiverScope();
+    if (receiver_scope->outer_scope()) return receiver_scope->scope_type();
+    return outermost_receiver_scope_type_;
   }
   LanguageMode language_mode() { return scope()->language_mode(); }
   void RaiseLanguageMode(LanguageMode mode) {
     LanguageMode old = scope()->language_mode();
     impl()->SetLanguageMode(scope(), old > mode ? old : mode);
   }
   bool is_generator() const { return function_state_->is_generator(); }
   bool is_async_function() const {
     return function_state_->is_async_function();
   }
@@ skipping 449 matching lines @@
   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_;
   ParserRecorder* log_;
   Mode mode_;
   bool parsing_module_;
   uintptr_t stack_limit_;
+  FunctionKind outermost_receiver_function_kind_;
+  ScopeType outermost_receiver_scope_type_;
 
   // Parser base's private field members.
 
  private:
   Zone* zone_;
   ExpressionClassifier* classifier_;
 
   Scanner* scanner_;
   bool stack_overflow_;
 
@@ skipping 1888 matching lines @@
   result = ParseMemberExpressionContinuation(result, is_async, CHECK_OK);
   return result;
 }
 
 template <typename Impl>
 typename ParserBase<Impl>::ExpressionT ParserBase<Impl>::ParseSuperExpression(
     bool is_new, bool* ok) {
   Expect(Token::SUPER, CHECK_OK);
   int pos = position();
 
-  DeclarationScope* scope = GetReceiverScope();
-  FunctionKind kind = scope->function_kind();
+  FunctionKind kind = GetReceiverScopeFunctionKind();
   if (IsConciseMethod(kind) || IsAccessorFunction(kind) ||
       IsClassConstructor(kind)) {
     if (peek() == Token::PERIOD || peek() == Token::LBRACK) {
-      scope->RecordSuperPropertyUsage();
+      RecordSuperPropertyUsage();
       return impl()->NewSuperPropertyReference(pos);
     }
     // new super() is never allowed.
     // super() is only allowed in derived constructor
     if (!is_new && peek() == Token::LPAREN && IsSubclassConstructor(kind)) {
       // TODO(rossberg): This might not be the correct FunctionState for the
       // method here.
       return impl()->NewSuperCallReference(pos);
     }
   }
@@ skipping 17 matching lines @@
     *ok = false;
   }
 }
 
 template <typename Impl>
 typename ParserBase<Impl>::ExpressionT
 ParserBase<Impl>::ParseNewTargetExpression(bool* ok) {
   int pos = position();
   ExpectMetaProperty(CStrVector("target"), "new.target", pos, CHECK_OK);
 
-  if (!GetReceiverScope()->is_function_scope()) {
+  if (GetReceiverScopeType() != FUNCTION_SCOPE) {
     impl()->ReportMessageAt(scanner()->location(),
                             MessageTemplate::kUnexpectedNewTarget);
     *ok = false;
     return impl()->EmptyExpression();
   }
 
   return impl()->NewTargetExpression(pos);
 }
 
 template <typename Impl>
@@ skipping 1134 matching lines @@
     has_seen_constructor_ = true;
     return;
   }
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_BASE_H