[strong] Function arity check should be based on required 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 --allow-natives-syntax
+// 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) {
   let a = [];
   for (let i = 0; i < n; i++) {
     a[i] = `p${i}`;
   }
   return a.join(', ');
 }
 
+function generateParamsWithRest(n) {
+  let a = [];
+  let i = 0;
+  for (; i < n; i++) {
+    a[i] = `p${i}`;
+  }
+  a.push(`...p${i}`)
+  return a.join(', ');
+}
+
 
 function generateSpread(n) {
   return `...[${generateArguments(n)}]`;
 }
 
 
 (function FunctionCall() {
   for (let parameterCount = 0; parameterCount < 3; parameterCount++) {
     let defs = [
       `'use strong'; function f(${generateParams(parameterCount)}) {}`,
+      `'use strong'; function f(${generateParamsWithRest(parameterCount)}) {}`,
       `'use strong'; function* f(${generateParams(parameterCount)}) {}`,
+      `'use strong'; function* f(${generateParamsWithRest(parameterCount)}) {}`,
       `'use strong'; let f = (${generateParams(parameterCount)}) => {}`,
       `function f(${generateParams(parameterCount)}) { 'use strong'; }`,
       `function* f(${generateParams(parameterCount)}) { 'use strong'; }`,
       `let f = (${generateParams(parameterCount)}) => { 'use strong'; }`,
     ];
     for (let def of defs) {
       for (let argumentCount = 0; argumentCount < 3; argumentCount++) {
         let calls = [
           `f(${generateArguments(argumentCount)})`,
           `f(${generateSpread(argumentCount)})`,
@@ skipping 30 matching lines @@
         } else {
           assertDoesNotThrow(code);
         }
       }
     }
   }
 })();
 
 
 (function MethodCall() {
-  for (let parameterCount = 0; parameterCount < 3; parameterCount++) {
-    let defs = [
-      `let o = new class {
-        m(${generateParams(parameterCount)}) { 'use strong'; }
-      }`,
-      `let o = new class {
-        *m(${generateParams(parameterCount)}) { 'use strong'; }
-      }`,
-      `let o = { m(${generateParams(parameterCount)}) { 'use strong'; } }`,
-      `let o = { *m(${generateParams(parameterCount)}) { 'use strong'; } }`,
-      `'use strong';
-      let o = new class { m(${generateParams(parameterCount)}) {} }`,
-      `'use strong';
-      let o = new class { *m(${generateParams(parameterCount)}) {} }`,
-      `'use strong'; let o = { m(${generateParams(parameterCount)}) {} }`,
-      `'use strong'; let o = { *m(${generateParams(parameterCount)}) {} }`,
-    ];
-    for (let def of defs) {
-      for (let argumentCount = 0; argumentCount < 3; argumentCount++) {
+  for (let genParams of [generateParams, generateParamsWithRest]) {
+    for (let parameterCount = 0; parameterCount < 3; parameterCount++) {
+      let defs = [
+        `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)}) { '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 = [
+            `o.m(${generateArguments(argumentCount)})`,
+            `o.m(${generateSpread(argumentCount)})`,
+            `o.m.call(${generateArguments(argumentCount, 'o')})`,
+            `o.m.call(o, ${generateSpread(argumentCount)})`,
+            `o.m.apply(o, [${generateArguments(argumentCount)}])`,
+            `o.m.bind(o)(${generateArguments(argumentCount)})`,
+            `%_CallFunction(${generateArguments(argumentCount, 'o')}, o.m)`,
+            `%Call(${generateArguments(argumentCount, 'o')}, o.m)`,
+            `%Apply(o.m, o, [${generateArguments(argumentCount)}], 0,
+                    ${argumentCount})`,
+          ];
+
+          for (let call of calls) {
+            let code = `'use strict'; ${def}; ${call};`;
+            if (argumentCount < parameterCount) {
+              assertThrows(code, TypeError);
+            } else {
+              assertDoesNotThrow(code);
+            }
+          }
+        }
+
         let calls = [
-          `o.m(${generateArguments(argumentCount)})`,
-          `o.m(${generateSpread(argumentCount)})`,
-          `o.m.call(${generateArguments(argumentCount, 'o')})`,
-          `o.m.call(o, ${generateSpread(argumentCount)})`,
-          `o.m.apply(o, [${generateArguments(argumentCount)}])`,
-          `o.m.bind(o)(${generateArguments(argumentCount)})`,
-          `%_CallFunction(${generateArguments(argumentCount, 'o')}, o.m)`,
-          `%Call(${generateArguments(argumentCount, 'o')}, o.m)`,
-          `%Apply(o.m, o, [${generateArguments(argumentCount)}], 0,
-                  ${argumentCount})`,
+          `o.m.call()`,
+          `o.m.apply()`,
+          `o.m.apply(o)`,
         ];
-
         for (let call of calls) {
           let code = `'use strict'; ${def}; ${call};`;
-          if (argumentCount < parameterCount) {
+          if (parameterCount > 0) {
             assertThrows(code, TypeError);
           } else {
             assertDoesNotThrow(code);
           }
         }
       }
-
-      let calls = [
-        `o.m.call()`,
-        `o.m.apply()`,
-        `o.m.apply(o)`,
-      ];
-      for (let call of calls) {
-        let code = `'use strict'; ${def}; ${call};`;
-        if (parameterCount > 0) {
-          assertThrows(code, TypeError);
-        } else {
-          assertDoesNotThrow(code);
-        }
-      }
     }
   }
 })();
 
 
 (function Constructor() {
-  for (let argumentCount = 0; argumentCount < 3; argumentCount++) {
-    for (let parameterCount = 0; parameterCount < 3; parameterCount++) {
-      let defs = [
-        `'use strong';
-        class C { constructor(${generateParams(parameterCount)}) {} }`,
-        `'use strict';
-        class C {
-          constructor(${generateParams(parameterCount)}) { 'use strong'; }
-        }`,
-      ];
-      for (let def of defs) {
-        let calls = [
-          `new C(${generateArguments(argumentCount)})`,
-          `new C(${generateSpread(argumentCount)})`,
-          `Reflect.construct(C, [${generateArguments(argumentCount)}])`,
+  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'; }
+          }`,
         ];
-        for (let call of calls) {
-          let code = `${def}; ${call};`;
-          if (argumentCount < parameterCount) {
-            assertThrows(code, TypeError);
-          } else {
-            assertDoesNotThrow(code);
+        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};`;
+            if (argumentCount < parameterCount) {
+              assertThrows(code, TypeError);
+            } else {
+              assertDoesNotThrow(code);
+            }
           }
         }
       }
     }
   }
 })();
 
 
 (function DerivedConstructor() {
-  for (let genArgs of [generateArguments, generateSpread]) {
-    for (let argumentCount = 0; argumentCount < 3; argumentCount++) {
-      for (let parameterCount = 0; parameterCount < 3; parameterCount++) {
-        let defs = [
-          `'use strong';
-          class B {
-            constructor(${generateParams(parameterCount)}) {}
-          }
-          class C extends B {
-            constructor() {
-              super(${genArgs(argumentCount)});
+  for (let genParams of [generateParams, generateParamsWithRest]) {
+    for (let genArgs of [generateArguments, generateSpread]) {
+      for (let argumentCount = 0; argumentCount < 3; argumentCount++) {
+        for (let parameterCount = 0; parameterCount < 3; parameterCount++) {
+          let defs = [
+            `'use strong';
+            class B {
+              constructor(${genParams(parameterCount)}) {}
             }
-          }`,
-          `'use strict';
-          class B {
-            constructor(${generateParams(parameterCount)}) { 'use strong'; }
-          }
-          class C extends B {
-            constructor() {
-              super(${genArgs(argumentCount)});
+            class C extends B {
+              constructor() {
+                super(${genArgs(argumentCount)});
+              }
+            }`,
+            `'use strict';
+            class B {
+              constructor(${genParams(parameterCount)}) { 'use strong'; }
             }
-          }`,
-        ];
-        for (let def of defs) {
-          let code = `${def}; new C();`;
-          if (argumentCount < parameterCount) {
-            assertThrows(code, TypeError);
-          } else {
-            assertDoesNotThrow(code);
+            class C extends B {
+              constructor() {
+                super(${genArgs(argumentCount)});
+              }
+            }`,
+          ];
+          for (let def of defs) {
+            let code = `${def}; new C();`;
+            if (argumentCount < parameterCount) {
+              assertThrows(code, TypeError);
+            } else {
+              assertDoesNotThrow(code);
+            }
           }
         }
       }
     }
   }
 })();
 
 
 (function DerivedConstructorDefaultConstructorInDerivedClass() {
-  for (let genArgs of [generateArguments, generateSpread]) {
-    for (let argumentCount = 0; argumentCount < 3; argumentCount++) {
-      for (let parameterCount = 0; parameterCount < 3; parameterCount++) {
-        let defs = [
-          `'use strong';
-          class B {
-            constructor(${generateParams(parameterCount)}) {}
-          }
-          class C extends B {}`,
-          `'use strict';
-          class B {
-            constructor(${generateParams(parameterCount)}) { '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);
+  for (let genParams of [generateParams, generateParamsWithRest]) {
+    for (let genArgs of [generateArguments, generateSpread]) {
+      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'; }
+            }
+            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);
+            }
           }
         }
       }
     }
   }
 })();
 
 
 (function TestOptimized() {
   function f(x, y) { 'use strong'; }
@@ skipping 72 matching lines @@
           if (argumentCount < parameterCount) {
             assertThrows(code, TypeError);
           } else {
             assertDoesNotThrow(code);
           }
         }
       }
     }
   }
 })();