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

test/mjsunit/strong/function-arity.js

 // Copyright 2015 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: --strong-mode --harmony-arrow-functions --harmony-reflect
 // Flags: --harmony-spreadcalls --harmony-rest-parameters --allow-natives-syntax
 
 'use strict';
 
 
 function generateArguments(n, prefix) {
   let a = [];
   if (prefix) {
     a.push(prefix);
   }
   for (let i = 0; i < n; i++) {
     a.push(String(i));
   }
 
   return a.join(', ');
 }
 
 
-function generateParams(n) {
+function generateParams(n, directive_in_body) {
   let a = [];
   for (let i = 0; i < n; i++) {
     a[i] = `p${i}`;
   }
   return a.join(', ');
 }
 
-function generateParamsWithRest(n) {
+function generateParamsWithRest(n, directive_in_body) {
   let a = [];
   let i = 0;
   for (; i < n; i++) {
     a[i] = `p${i}`;
   }
-  a.push(`...p${i}`)
+  if (!directive_in_body) {
+    // If language mode directive occurs in body, rest parameters will trigger
+    // an early error regardless of language mode.
+    a.push(`...p${i}`);
+  }
   return a.join(', ');
 }
 
 
 function generateSpread(n) {
   return `...[${generateArguments(n)}]`;
 }
 
 
 (function FunctionCall() {
@@ skipping 20 matching lines @@
           `%_CallFunction(${generateArguments(argumentCount, 'undefined')},
                           f)`,
           `%Call(${generateArguments(argumentCount, 'undefined')}, f)`,
           `%Apply(f, undefined, [${generateArguments(argumentCount)}], 0,
                   ${argumentCount})`,
         ];
 
         for (let call of calls) {
           let code = `'use strict'; ${def}; ${call};`;
           if (argumentCount < parameterCount) {
+            print(code);
             assertThrows(code, TypeError);
           } else {
             assertDoesNotThrow(code);
           }
         }
       }
 
       let calls = [
         `f.call()`,
         `f.apply()`,
@@ skipping 10 matching lines @@
     }
   }
 })();
 
 
 (function MethodCall() {
   for (let genParams of [generateParams, generateParamsWithRest]) {
     for (let parameterCount = 0; parameterCount < 3; parameterCount++) {
       let defs = [
         `let o = new class {
-          m(${genParams(parameterCount)}) { 'use strong'; }
+          m(${genParams(parameterCount, true)}) { 'use strong'; }
         }`,
         `let o = new class {
-          *m(${genParams(parameterCount)}) { 'use strong'; }
+          *m(${genParams(parameterCount, true)}) { 'use strong'; }
         }`,
-        `let o = { m(${genParams(parameterCount)}) { 'use strong'; } }`,
-        `let o = { *m(${genParams(parameterCount)}) { 'use strong'; } }`,
+        `let o = { m(${genParams(parameterCount, true)}) { 'use strong'; } }`,
+        `let o = { *m(${genParams(parameterCount, true)}) { 'use strong'; } }`,
         `'use strong';
         let o = new class { m(${genParams(parameterCount)}) {} }`,
         `'use strong';
         let o = new class { *m(${genParams(parameterCount)}) {} }`,
         `'use strong'; let o = { m(${genParams(parameterCount)}) {} }`,
         `'use strong'; let o = { *m(${genParams(parameterCount)}) {} }`,
       ];
       for (let def of defs) {
         for (let argumentCount = 0; argumentCount < 3; argumentCount++) {
           let calls = [
@@ skipping 40 matching lines @@
 
 (function Constructor() {
   for (let genParams of [generateParams, generateParamsWithRest]) {
     for (let argumentCount = 0; argumentCount < 3; argumentCount++) {
       for (let parameterCount = 0; parameterCount < 3; parameterCount++) {
         let defs = [
           `'use strong';
           class C { constructor(${genParams(parameterCount)}) {} }`,
           `'use strict';
           class C {
-            constructor(${genParams(parameterCount)}) { 'use strong'; }
+            constructor(${genParams(parameterCount, true)}) { 'use strong'; }
           }`,
         ];
         for (let def of defs) {
           let calls = [
             `new C(${generateArguments(argumentCount)})`,
             `new C(${generateSpread(argumentCount)})`,
             `Reflect.construct(C, [${generateArguments(argumentCount)}])`,
           ];
           for (let call of calls) {
             let code = `${def}; ${call};`;
@@ skipping 20 matching lines @@
             class B {
               constructor(${genParams(parameterCount)}) {}
             }
             class C extends B {
               constructor() {
                 super(${genArgs(argumentCount)});
               }
             }`,
             `'use strict';
             class B {
-              constructor(${genParams(parameterCount)}) { 'use strong'; }
+              constructor(${genParams(parameterCount, true)}) { 'use strong'; }
             }
             class C extends B {
               constructor() {
                 super(${genArgs(argumentCount)});
               }
             }`,
           ];
           for (let def of defs) {
             let code = `${def}; new C();`;
             if (argumentCount < parameterCount) {
@@ skipping 15 matching lines @@
       for (let argumentCount = 0; argumentCount < 3; argumentCount++) {
         for (let parameterCount = 0; parameterCount < 3; parameterCount++) {
           let defs = [
             `'use strong';
             class B {
               constructor(${genParams(parameterCount)}) {}
             }
             class C extends B {}`,
             `'use strict';
             class B {
-              constructor(${genParams(parameterCount)}) { 'use strong'; }
+              constructor(${genParams(parameterCount, true)}) { 'use strong'; }
             }
             class C extends B {}`,
           ];
           for (let def of defs) {
             let code = `${def}; new C(${genArgs(argumentCount)})`;
             if (argumentCount < parameterCount) {
               assertThrows(code, TypeError);
             } else {
               assertDoesNotThrow(code);
             }
@@ skipping 82 matching lines @@
           if (argumentCount < parameterCount) {
             assertThrows(code, TypeError);
           } else {
             assertDoesNotThrow(code);
           }
         }
       }
     }
   }
 })();