Declare 'this' as DYNAMIC_GLOBAL on the script_scope

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.h"
@@ skipping 980 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_;
+    // If there's a chance that there's a reference to global 'this', predeclare

[adamk, 2016/08/11 18:27:17]

What does the "If there's a chance" add to this comment?

[Toon Verwaest, 2016/08/12 04:49:40]

How would you reformulate? I'm just trying to indicate that there's no guarantee
that there's a reference, but that we don't insert it if there can't be a
reference.

[adamk, 2016/08/15 17:39:43]

Makes sense, I missed the fact that the GetReceiverScope() is doing exactly the
"if there's a chance" thing. This is fine on a second reading.

+    // 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()) {
       outer = NewModuleScope(outer);
     }
 
@@ skipping 144 matching lines @@
 
   ParsingModeScope parsing_mode(this, PARSE_EAGERLY);
 
   // Place holder for the result.
   FunctionLiteral* result = nullptr;
 
   {
     // Parse the function literal.
     Scope* scope = original_scope_;
     DCHECK(scope);
+    // 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()) {
+      info->script_scope()->DeclareDynamicGlobal(
+          ast_value_factory()->this_string(), Variable::THIS);
+    }
     FunctionState function_state(&function_state_, &scope_state_, scope,
                                  info->function_kind());
     DCHECK(is_sloppy(scope->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) {
@@ skipping 5919 matching lines @@
   node->Print(Isolate::Current());
 }
 #endif  // DEBUG
 
 #undef CHECK_OK
 #undef CHECK_OK_VOID
 #undef CHECK_FAILED
 
 }  // namespace internal
 }  // namespace v8