[parser] disallow language mode directive in body of function with non-simple parameters

test/mjsunit/harmony/rest-params.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-rest-parameters
 
 (function testRestIndex() {
   assertEquals(5, (function(...args) { return args.length; })(1,2,3,4,5));
   assertEquals(4, (function(a, ...args) { return args.length; })(1,2,3,4,5));
   assertEquals(3, (function(a, b, ...args) { return args.length; })(1,2,3,4,5));
   assertEquals(2, (function(a, b, c, ...args) {
                       return args.length; })(1,2,3,4,5));
   assertEquals(1, (function(a, b, c, d, ...args) {
                       return args.length; })(1,2,3,4,5));
   assertEquals(0, (function(a, b, c, d, e, ...args) {
                     return args.length; })(1,2,3,4,5));
 })();
 
-function strictTest(a, b, ...c) {
+var strictTest = (function() {
   "use strict";
-  assertEquals(Array, c.constructor);
-  assertTrue(Array.isArray(c));
+  return function strictTest(a, b, ...c) {
+    assertEquals(Array, c.constructor);
+    assertTrue(Array.isArray(c));
 
-  var expectedLength = arguments.length >= 3 ? arguments.length - 2 : 0;
-  assertEquals(expectedLength, c.length);
+    var expectedLength = arguments.length >= 3 ? arguments.length - 2 : 0;
+    assertEquals(expectedLength, c.length);
 
-  for (var i = 2, j = 0; i < arguments.length; ++i) {
-    assertEquals(c[j++], arguments[i]);
-  }
-}
+    for (var i = 2, j = 0; i < arguments.length; ++i) {
+      assertEquals(c[j++], arguments[i]);
+    }
+  };
+})();
 
 function sloppyTest(a, b, ...c) {
   assertEquals(Array, c.constructor);
   assertTrue(Array.isArray(c));
 
   var expectedLength = arguments.length >= 3 ? arguments.length - 2 : 0;
   assertEquals(expectedLength, c.length);
 
   for (var i = 2, j = 0; i < arguments.length; ++i) {
     assertEquals(c[j++], arguments[i]);
@@ skipping 96 matching lines @@
   assertThrows(function(...rest) { return arguments.caller; }, TypeError);
   assertThrows(function(...rest) { return arguments.callee; }, TypeError);
   // TODO(caitp): figure out why this doesn't throw sometimes, even though the
   //              getter always does =)
   // assertThrows(function(...rest) { arguments.caller = 1; }, TypeError);
   // assertThrows(function(...rest) { arguments.callee = 1; }, TypeError);
 })();
 
 
 (function testNoAliasArgumentsStrict() {
-  function strictF(a, ...rest) {
+  ((function() {
     "use strict";
-    arguments[0] = 1;
-    assertEquals(3, a);
-    arguments[1] = 2;
-    assertArrayEquals([4, 5], rest);
-  }
-  strictF(3, 4, 5);
+    return (function strictF(a, ...rest) {
+              arguments[0] = 1;
+              assertEquals(3, a);
+              arguments[1] = 2;
+              assertArrayEquals([4, 5], rest);
+            });
+  })())(3, 4, 5);
 })();
 
 
 (function testNoAliasArgumentsSloppy() {
   function sloppyF(a, ...rest) {
     arguments[0] = 1;
     assertEquals(3, a);
     arguments[1] = 2;
     assertArrayEquals([4, 5], rest);
   }
@@ skipping 40 matching lines @@
         args.push(arguments[i]);
       }
       assertEquals(args, b);
     }
   }
 
   var c = new Child(1, 2, 3);
   assertEquals([1, 2, 3], c.child);
   assertEquals([1, 2, 3], c.base);
 })();
+
+(function TestDirectiveThrows() {
+  "use strict";
+
+  assertThrows(
+    function(){ eval("function(...rest){'use strict';}") }, SyntaxError);
+  assertThrows(function(){ eval("(...rest) => {'use strict';}") }, SyntaxError);
+  assertThrows(
+    function(){ eval("(class{foo(...rest) {'use strict';}});") }, SyntaxError);
+
+  assertThrows(
+    function(){ eval("function(a, ...rest){'use strict';}") }, SyntaxError);
+  assertThrows(
+    function(){ eval("(a, ...rest) => {'use strict';}") }, SyntaxError);
+  assertThrows(
+    function(){ eval("(class{foo(a, ...rest) {'use strict';}});") },
+    SyntaxError);
+})();