Declare 'this' as DYNAMIC_GLOBAL on the script_scope

src/ast/scopes.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_AST_SCOPES_H_
 #define V8_AST_SCOPES_H_
 
 #include "src/ast/ast.h"
 #include "src/base/hashmap.h"
 #include "src/globals.h"
@@ skipping 424 matching lines @@
 
   // Check that the scope has positions assigned.
   void CheckScopePositions();
 
   // Check that all Scopes in the scope tree use the same Zone.
   void CheckZones();
 #endif
 
   // Retrieve `IsSimpleParameterList` of current or outer function.
   bool HasSimpleParameters();
+  void set_is_debug_evaluate_scope() { is_debug_evaluate_scope_ = true; }
 
  private:
   Zone* zone_;
 
   // Scope tree.
   Scope* outer_scope_;  // the immediately enclosing outer scope, or NULL
   Scope* inner_scope_;  // an inner scope of this scope
   Scope* sibling_;  // a sibling inner scope of the outer scope of this scope.
 
   // The variables declared in this scope:
@@ skipping 43 matching lines @@
   bool scope_uses_super_property_ : 1;
   // This scope has a parameter called "arguments".
   bool has_arguments_parameter_ : 1;
   // This scope contains an "use asm" annotation.
   bool asm_module_ : 1;
   // This scope's outer context is an asm module.
   bool asm_function_ : 1;
   // This scope's declarations might not be executed in order (e.g., switch).
   bool scope_nonlinear_ : 1;
   bool is_hidden_ : 1;
+  // Temporary workaround that allows masking of 'this' in debug-evalute scopes.
+  bool is_debug_evaluate_scope_ : 1;
 
   // Computed via PropagateScopeInfo.
   bool outer_scope_calls_sloppy_eval_ : 1;
   bool inner_scope_calls_eval_ : 1;
   bool force_eager_compilation_ : 1;
   bool force_context_allocation_ : 1;
 
   // True if it doesn't need scope resolution (e.g., if the scope was
   // constructed based on a serialized scope info or a catch context).
   bool already_resolved_ : 1;
   bool already_resolved() { return already_resolved_; }
 
   // True if it holds 'var' declarations.
   bool is_declaration_scope_ : 1;
 
   // Create a non-local variable with a given name.
   // These variables are looked up dynamically at runtime.
-  Variable* NonLocal(const AstRawString* name, VariableMode mode,
-                     Variable::Kind variable_kind);
+  Variable* NonLocal(const AstRawString* name, VariableMode mode);
 
   // Variable resolution.
   // Possible results of a recursive variable lookup telling if and how a
   // variable is bound. These are returned in the output parameter *binding_kind
   // of the LookupRecursive function.
   enum BindingKind {
     // The variable reference could be statically resolved to a variable binding
     // which is returned. There is no 'with' statement between the reference and
     // the binding and no scope between the reference scope (inclusive) and
     // binding scope (exclusive) makes a sloppy 'eval' call.
@@ skipping 355 matching lines @@
   // Convenience variable; Subclass constructor only
   Variable* this_function_;
   // Module descriptor; module scopes only.
   ModuleDescriptor* module_descriptor_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_SCOPES_H_