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),
+        outer_most_receivers_function_kind_(kNormalFunction),
+        outer_most_receivers_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();

[marja, 2016/09/12 07:50:32]

Style nit: != nullptr (in several places)

+    return outer_most_receivers_function_kind_;
+  }
+  void RecordSuperPropertyUsage() {
+    DeclarationScope* receiver_scope = scope()->GetReceiverScope();
+    if (receiver_scope->outer_scope()) {

[marja, 2016/09/12 07:50:33]

Why is this correct? If there's no outer scope, then we just don't record
anything anywhere...? (The answer can be a comment:)

[jochen (gone - plz use gerrit), 2016/09/12 08:18:18]

done

+      return receiver_scope->RecordSuperPropertyUsage();

[marja, 2016/09/12 07:50:32]

Nit: "return" is unnecessary here.

[jochen (gone - plz use gerrit), 2016/09/12 08:18:18]

done

+    }
+  }
+  ScopeType GetReceiverScopeType() const {
+    Scope* receiver_scope = scope()->GetReceiverScope();
+    if (receiver_scope->outer_scope()) return receiver_scope->scope_type();
+    return outer_most_receivers_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 outer_most_receivers_function_kind_;

[marja, 2016/09/12 07:50:32]

Naming nit: "outermost" is one word, so outermost_receiver_scope_function_kind_
etc.

(Or why "receivers"?)

[jochen (gone - plz use gerrit), 2016/09/12 08:18:18]

done

+  ScopeType outer_most_receivers_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