Implement proper scoping for "this" in arrow functions

test/cctest/test-parsing.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 902 matching lines @@
       if (!bad) {
         i += input_offset;
         character_length -= output_adjust;
       }
     }
   }
   return character_length;
 }
 
 
-TEST(ScopeUsesArgumentsSuperThis) {
+TEST(ScopeUsesArgumentsSuper) {
   static const struct {
     const char* prefix;
     const char* suffix;
   } surroundings[] = {
     { "function f() {", "}" },
     { "var f = () => {", "}" },
   };
 
   enum Expected {
     NONE = 0,
     ARGUMENTS = 1,
     SUPER_PROPERTY = 2,
     SUPER_CONSTRUCTOR_CALL = 4,
-    THIS = 8,
-    INNER_ARGUMENTS = 16,
-    INNER_SUPER_PROPERTY = 32,
-    INNER_SUPER_CONSTRUCTOR_CALL = 64,
-    INNER_THIS = 128
+    INNER_ARGUMENTS = 8,
+    INNER_SUPER_PROPERTY = 16,
+    INNER_SUPER_CONSTRUCTOR_CALL = 32,
   };
 
   static const struct {
     const char* body;
     int expected;
   } source_data[] = {
         {"", NONE},
-        {"return this", THIS},
         {"return arguments", ARGUMENTS},
         {"return super()", SUPER_CONSTRUCTOR_CALL},
         {"return super.x", SUPER_PROPERTY},
         {"return arguments[0]", ARGUMENTS},
-        {"return this + arguments[0]", ARGUMENTS | THIS},
+        {"return this + arguments[0]", ARGUMENTS },
         {"return this + arguments[0] + super.x",
-         ARGUMENTS | SUPER_PROPERTY | THIS},
-        {"return x => this + x", INNER_THIS},
+         ARGUMENTS | SUPER_PROPERTY },
+        {"return x => this + x", NONE},
         {"return x => super() + x", INNER_SUPER_CONSTRUCTOR_CALL},
-        {"this.foo = 42;", THIS},
-        {"this.foo();", THIS},
-        {"if (foo()) { this.f() }", THIS},
+        {"this.foo = 42;", NONE},
+        {"this.foo();", NONE},
+        {"if (foo()) { this.f() }", NONE},
         {"if (foo()) { super.f() }", SUPER_PROPERTY},
-        {"if (arguments.length) { this.f() }", ARGUMENTS | THIS},
-        {"while (true) { this.f() }", THIS},
+        {"if (arguments.length) { this.f() }", ARGUMENTS},
+        {"while (true) { this.f() }", NONE},
         {"while (true) { super.f() }", SUPER_PROPERTY},
-        {"if (true) { while (true) this.foo(arguments) }", ARGUMENTS | THIS},
+        {"if (true) { while (true) this.foo(arguments) }", ARGUMENTS},
         // Multiple nesting levels must work as well.
-        {"while (true) { while (true) { while (true) return this } }", THIS},
+        {"while (true) { while (true) { while (true) return this } }", NONE},
         {"while (true) { while (true) { while (true) return super() } }",
          SUPER_CONSTRUCTOR_CALL},
-        {"if (1) { return () => { while (true) new this() } }", INNER_THIS},
+        {"if (1) { return () => { while (true) new this() } }", NONE},
         {"if (1) { return () => { while (true) new super() } }", NONE},
         {"if (1) { return () => { while (true) new new super() } }", NONE},
-        // Note that propagation of the inner_uses_this() value does not
-        // cross boundaries of normal functions onto parent scopes.
         {"return function (x) { return this + x }", NONE},
         {"return function (x) { return super() + x }", NONE},
         {"var x = function () { this.foo = 42 };", NONE},
         {"var x = function () { super.foo = 42 };", NONE},
         {"if (1) { return function () { while (true) new this() } }", NONE},
         {"if (1) { return function () { while (true) new super() } }", NONE},
         {"return function (x) { return () => this }", NONE},
         {"return function (x) { return () => super() }", NONE},
         // Flags must be correctly set when using block scoping.
         {"\"use strict\"; while (true) { let x; this, arguments; }",
-         INNER_ARGUMENTS | INNER_THIS},
+         INNER_ARGUMENTS},
         {"\"use strict\"; while (true) { let x; this, super(), arguments; }",
-         INNER_ARGUMENTS | INNER_SUPER_CONSTRUCTOR_CALL | INNER_THIS},
-        {"\"use strict\"; if (foo()) { let x; this.f() }", INNER_THIS},
+         INNER_ARGUMENTS | INNER_SUPER_CONSTRUCTOR_CALL},
+        {"\"use strict\"; if (foo()) { let x; this.f() }", NONE},
         {"\"use strict\"; if (foo()) { let x; super.f() }",
          INNER_SUPER_PROPERTY},
         {"\"use strict\"; if (1) {"
          "  let x; return function () { return this + super() + arguments }"
          "}",
          NONE},
     };
 
   i::Isolate* isolate = CcTest::i_isolate();
   i::Factory* factory = isolate->factory();
@@ skipping 35 matching lines @@
       CHECK(script_scope->is_script_scope());
       CHECK_EQ(1, script_scope->inner_scopes()->length());
 
       i::Scope* scope = script_scope->inner_scopes()->at(0);
       CHECK_EQ((source_data[i].expected & ARGUMENTS) != 0,
                scope->uses_arguments());
       CHECK_EQ((source_data[i].expected & SUPER_PROPERTY) != 0,
                scope->uses_super_property());
       CHECK_EQ((source_data[i].expected & SUPER_CONSTRUCTOR_CALL) != 0,
                scope->uses_super_constructor_call());
-      CHECK_EQ((source_data[i].expected & THIS) != 0, scope->uses_this());
       CHECK_EQ((source_data[i].expected & INNER_ARGUMENTS) != 0,
                scope->inner_uses_arguments());
       CHECK_EQ((source_data[i].expected & INNER_SUPER_PROPERTY) != 0,
                scope->inner_uses_super_property());
       CHECK_EQ((source_data[i].expected & INNER_SUPER_CONSTRUCTOR_CALL) != 0,
                scope->inner_uses_super_constructor_call());
-      CHECK_EQ((source_data[i].expected & INNER_THIS) != 0,
-               scope->inner_uses_this());
     }
   }
 }
 
 
 TEST(ScopePositions) {
   v8::internal::FLAG_harmony_scoping = true;
 
   // Test the parser for correctly setting the start and end positions
   // of a scope. We check the scope positions of exactly one scope
@@ skipping 3913 matching lines @@
     "const x = 1;",
     "class C {}",
     NULL};
 
   static const ParserFlag always_flags[] = {
     kAllowHarmonyClasses, kAllowHarmonyScoping
   };
   RunParserSyncTest(context_data, statement_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }