[es6] Fix function context check for super and new.target

test/mjsunit/harmony/super.js

 // Copyright 2014 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.
 
 // Flags: --harmony-arrow-functions --allow-natives-syntax
-// Flags: --harmony-spreadcalls
+// Flags: --harmony-spreadcalls --harmony-destructuring
+// Flags: --harmony-rest-parameters --harmony-sloppy
 
 (function TestSuperNamedLoads() {
   function Base() { }
   function fBase() { }
   Base.prototype = {
     f() {
       return "Base " + this.toString();
     },
     x: 15,
     toString() {
@@ skipping 2098 matching lines @@
       assertSame(super.x, (() => super.x)());
       assertSame(super.m(), (() => super.m())());
       return (() => super.m())();
     }
   }
   let d = new Derived();
   assertSame(1, d.arrow());
 })();
 
 
+(function TestSuperInOtherScopes() {
+  var p = {x: 99};
+  var o0 = {__proto__: p, f() { return eval("'use strict'; super.x") }};
+  assertEquals(p.x, o0.f());
+  var o1 = {__proto__: p, f() { with ({}) return super.x }};
+  assertEquals(p.x, o1.f());
+  var o2 = {__proto__: p, f({a}) { return super.x }};
+  assertEquals(p.x, o2.f({}));
+  var o3 = {__proto__: p, f(...a) { return super.x }};
+  assertEquals(p.x, o3.f());
+  var o4 = {__proto__: p, f() { 'use strict'; { let x; return super.x } }};
+  assertEquals(p.x, o4.f());
+})();
+
+
+(function TestSuperCallInOtherScopes() {
+  class C {constructor() { this.x = 99 }}
+  class D0 extends C {constructor() { eval("'use strict'; super()") }}
+  assertEquals(99, (new D0).x);
+  class D2 extends C {constructor({a}) { super() }}
+  assertEquals(99, (new D2({})).x);
+  class D3 extends C {constructor(...a) { super() }}
+  assertEquals(99, (new D3()).x);
+  class D4 extends C {constructor() { { let x; super() } }}
+  assertEquals(99, (new D4).x);
+})();
+
+
 (function TestSuperCallInEval() {
   'use strict';
   class Base {
     constructor(x) {
       this.x = x;
     }
   }
   class Derived extends Base {
     constructor(x) {
       let r = eval('super(x)');
@@ skipping 119 matching lines @@
   }
   class Derived extends Base {
     constructor(x) {
       let r = (() => super(...[x]))();
       assertEquals(this, r);
     }
   }
   let d = new Derived(42);
   assertSame(42, d.x);
 })();