Implicitly pass 'scope()' as parent scope for function scopes

src/parsing/parser.cc

 // 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.
 
 #include "src/parsing/parser.h"
 
 #include "src/api.h"
 #include "src/ast/ast.h"
 #include "src/ast/ast-expression-rewriter.h"
 #include "src/ast/ast-expression-visitor.h"
@@ skipping 182 matching lines @@
     cached_parse_data_ = NULL;
   } else {
     DCHECK(info->cached_data() != NULL);
     if (compile_options_ == ScriptCompiler::kConsumeParserCache) {
       cached_parse_data_ = ParseData::FromCachedData(*info->cached_data());
     }
   }
 }
 
 FunctionLiteral* Parser::DefaultConstructor(const AstRawString* name,
-                                            bool call_super, Scope* scope,
-                                            int pos, int end_pos,
+                                            bool call_super, int pos,
+                                            int end_pos,
                                             LanguageMode language_mode) {
   int materialized_literal_count = -1;
   int expected_property_count = -1;
   int parameter_count = 0;
   if (name == nullptr) name = ast_value_factory()->empty_string();
 
   FunctionKind kind = call_super ? FunctionKind::kDefaultSubclassConstructor
                                  : FunctionKind::kDefaultBaseConstructor;
-  Scope* function_scope = NewFunctionScope(scope, kind);
+  Scope* function_scope = NewFunctionScope(kind);
   SetLanguageMode(function_scope,
                   static_cast<LanguageMode>(language_mode | STRICT));
   // Set start and end position to the same value
   function_scope->set_start_position(pos);
   function_scope->set_end_position(pos);
   ZoneList<Statement*>* body = NULL;
 
   {
     AstNodeFactory function_factory(ast_value_factory());
     FunctionState function_state(&function_state_, &scope_state_,
@@ skipping 907 matching lines @@
           CHECK(stack_overflow());
           return nullptr;
         }
         if (!(peek_any_identifier() || peek() == Token::LPAREN)) {
           CHECK(stack_overflow());
           return nullptr;
         }
       }
 
       // TODO(adamk): We should construct this scope from the ScopeInfo.
-      Scope* scope =
-          NewFunctionScope(this->scope(), FunctionKind::kArrowFunction);
+      Scope* scope = NewFunctionScope(FunctionKind::kArrowFunction);
 
       // These two bits only need to be explicitly set because we're
       // not passing the ScopeInfo to the Scope constructor.
       // TODO(adamk): Remove these calls once the above NewScope call
       // passes the ScopeInfo.
       if (shared_info->scope_info()->CallsEval()) {
         scope->RecordEvalCall();
       }
       SetLanguageMode(scope, shared_info->language_mode());
 
@@ skipping 37 matching lines @@
             // The pre-parser saw an arrow function here, so the full parser
             // must produce a FunctionLiteral.
             DCHECK(expression->IsFunctionLiteral());
             result = expression->AsFunctionLiteral();
           } else {
             ok = false;
           }
         }
       }
     } else if (shared_info->is_default_constructor()) {
+      DCHECK_EQ(this->scope(), scope);
       result = DefaultConstructor(
-          raw_name, IsSubclassConstructor(shared_info->kind()), scope,
+          raw_name, IsSubclassConstructor(shared_info->kind()),
           shared_info->start_position(), shared_info->end_position(),
           shared_info->language_mode());
     } else {
       result = ParseFunctionLiteral(raw_name, Scanner::Location::invalid(),
                                     kSkipFunctionNameCheck, shared_info->kind(),
                                     kNoSourcePosition, function_type,
                                     shared_info->language_mode(), &ok);
     }
     // Make sure the results agree.
     DCHECK(ok == (result != nullptr));
@@ skipping 3075 matching lines @@
   // Anonymous functions were passed either the empty symbol or a null
   // handle as the function name.  Remember if we were passed a non-empty
   // handle to decide whether to invoke function name inference.
   bool should_infer_name = function_name == NULL;
 
   // We want a non-null handle as the function name.
   if (should_infer_name) {
     function_name = ast_value_factory()->empty_string();
   }
 
-  Scope* scope = NewFunctionScope(this->scope(), kind);
+  Scope* scope = NewFunctionScope(kind);
   SetLanguageMode(scope, language_mode);
   ZoneList<Statement*>* body = NULL;
   int arity = -1;
   int materialized_literal_count = -1;
   int expected_property_count = -1;
   DuplicateFinder duplicate_finder(scanner()->unicode_cache());
   bool should_be_used_once_hint = false;
   bool has_duplicate_parameters;
   FunctionLiteral::EagerCompileHint eager_compile_hint;
 
@@ skipping 776 matching lines @@
 
     if (property_name != ast_value_factory()->constructor_string()) {
       SetFunctionNameFromPropertyName(property, property_name);
     }
   }
 
   Expect(Token::RBRACE, CHECK_OK);
   int end_pos = scanner()->location().end_pos;
 
   if (constructor == NULL) {
-    constructor = DefaultConstructor(name, has_extends, block_scope, pos,
-                                     end_pos, block_scope->language_mode());
+    DCHECK_EQ(this->scope(), block_scope);
+    constructor = DefaultConstructor(name, has_extends, pos, end_pos,
+                                     block_scope->language_mode());
   }
 
   // Note that we do not finalize this block scope because it is
   // used as a sentinel value indicating an anonymous class.
   block_scope->set_end_position(end_pos);
 
   if (name != NULL) {
     DCHECK_NOT_NULL(proxy);
     proxy->var()->set_initializer_position(end_pos);
   }
@@ skipping 1968 matching lines @@
   node->Print(Isolate::Current());
 }
 #endif  // DEBUG
 
 #undef CHECK_OK
 #undef CHECK_OK_VOID
 #undef CHECK_FAILED
 
 }  // namespace internal
 }  // namespace v8