Don't reuse the name scope for multiple variables in DoParseLazy

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 <memory>
 
 #include "src/api.h"
 #include "src/ast/ast-expression-rewriter.h"
@@ skipping 652 matching lines @@
   // via ParseInfo, and also not pass it forward.
   DCHECK_NULL(scope_state_);
   DCHECK_NULL(target_stack_);
 
   Mode parsing_mode = FLAG_lazy && allow_lazy() ? PARSE_LAZILY : PARSE_EAGERLY;
   if (allow_natives() || extension_ != NULL) parsing_mode = PARSE_EAGERLY;
 
   FunctionLiteral* result = NULL;
   {
     Scope* outer = original_scope_;
+    DCHECK(outer);

[marja, 2016/08/30 11:28:21]

Nit: DCHECK_NOT_NULL

     // If there's a chance that there's a reference to global 'this', predeclare
     // it as a dynamic global on the script scope.
     if (outer->GetReceiverScope()->is_script_scope()) {
       info->script_scope()->DeclareDynamicGlobal(
           ast_value_factory()->this_string(), Variable::THIS);
     }
-    DCHECK(outer);
     if (info->is_eval()) {
       if (!outer->is_script_scope() || is_strict(info->language_mode())) {
         parsing_mode = PARSE_EAGERLY;
       }
       outer = NewEvalScope(outer);
     } else if (info->is_module()) {
       DCHECK_EQ(outer, info->script_scope());
       outer = NewModuleScope(info->script_scope());
     }
 
@@ skipping 142 matching lines @@
   fni_ = new (zone()) FuncNameInferrer(ast_value_factory(), zone());
   fni_->PushEnclosingName(raw_name);
 
   ParsingModeScope parsing_mode(this, PARSE_EAGERLY);
 
   // Place holder for the result.
   FunctionLiteral* result = nullptr;
 
   {
     // Parse the function literal.
-    Scope* scope = original_scope_;
-    DCHECK(scope);
+    Scope* outer = original_scope_;
+    DCHECK(outer);
     // If there's a chance that there's a reference to global 'this', predeclare
     // it as a dynamic global on the script scope.
-    if (info->is_arrow() && scope->GetReceiverScope()->is_script_scope()) {
+    if (info->is_arrow() && outer->GetReceiverScope()->is_script_scope()) {
       info->script_scope()->DeclareDynamicGlobal(
           ast_value_factory()->this_string(), Variable::THIS);
     }
-    FunctionState function_state(&function_state_, &scope_state_, scope,
+    FunctionState function_state(&function_state_, &scope_state_, outer,
                                  info->function_kind());
-    DCHECK(is_sloppy(scope->language_mode()) ||
+    DCHECK(is_sloppy(outer->language_mode()) ||
            is_strict(info->language_mode()));
     FunctionLiteral::FunctionType function_type = ComputeFunctionType(info);
     bool ok = true;
 
     if (info->is_arrow()) {
       bool is_async = allow_harmony_async_await() && info->is_async();
       if (is_async) {
         DCHECK(!scanner()->HasAnyLineTerminatorAfterNext());
         if (!Check(Token::ASYNC)) {
           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.
       DeclarationScope* scope = NewFunctionScope(FunctionKind::kArrowFunction);

[jochen (gone - plz use gerrit), 2016/08/30 11:25:56]

here ^^^ the name is reused, which is confusing

 
       // 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 (info->calls_eval()) {
         scope->RecordEvalCall();
       }
       SetLanguageMode(scope, 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 (info->is_default_constructor()) {
-      DCHECK_EQ(this->scope(), scope);
+      DCHECK_EQ(this->scope(), outer);

[marja, 2016/08/30 11:28:21]

Can this now be scope() instead of this->scope() or is scope still in scope?

       result = DefaultConstructor(
           raw_name, IsSubclassConstructor(info->function_kind()),
           info->start_position(), info->end_position(), info->language_mode());
     } else {
       result = ParseFunctionLiteral(raw_name, Scanner::Location::invalid(),
                                     kSkipFunctionNameCheck,
                                     info->function_kind(), kNoSourcePosition,
                                     function_type, info->language_mode(), &ok);
     }
     // Make sure the results agree.
@@ skipping 5800 matching lines @@
   node->Print(Isolate::Current());
 }
 #endif  // DEBUG
 
 #undef CHECK_OK
 #undef CHECK_OK_VOID
 #undef CHECK_FAILED
 
 }  // namespace internal
 }  // namespace v8