diff --git a/src/dflt-params/abrupt.case b/src/dflt-params/abrupt.case
new file mode 100644
index 0000000000000000000000000000000000000000..7c52350567988bc70430bf1a23c2295ec3dff282
--- /dev/null
+++ b/src/dflt-params/abrupt.case
@@ -0,0 +1,21 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+desc: Abrupt completion returned by evaluation of initializer
+template: error
+info: |
+ 14.1.19 Runtime Semantics: IteratorBindingInitialization
+
+ FormalsList : FormalsList , FormalParameter
+
+ 1. Let status be the result of performing IteratorBindingInitialization for
+ FormalsList using iteratorRecord and environment as the arguments.
+ 2. ReturnIfAbrupt(status).
+ 3. Return the result of performing IteratorBindingInitialization for
+ FormalParameter using iteratorRecord and environment as the arguments.
+---*/
+
+//- params
+_ = (function() { throw new Test262Error(); }())
+//- error
+Test262Error
diff --git a/src/dflt-params/arg-val-not-undefined.case b/src/dflt-params/arg-val-not-undefined.case
new file mode 100644
index 0000000000000000000000000000000000000000..20082b1ae9caea004543fb8ecefe0e0471c12a16
--- /dev/null
+++ b/src/dflt-params/arg-val-not-undefined.case
@@ -0,0 +1,47 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+desc: Use of intializer when argument value is not `undefined`
+template: default
+info: |
+ 14.1.19 Runtime Semantics: IteratorBindingInitialization
+
+ FormalsList : FormalsList , FormalParameter
+
+ [...]
+ 23. Let iteratorRecord be Record {[[Iterator]]:
+ CreateListIterator(argumentsList), [[Done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ a. Perform ? IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+//- setup
+var obj = {};
+var falseCount = 0;
+var stringCount = 0;
+var nanCount = 0;
+var zeroCount = 0;
+var nullCount = 0;
+var objCount = 0;
+//- params
+aFalse = falseCount +=1, aString = stringCount += 1, aNaN = nanCount += 1, a0 = zeroCount += 1, aNull = nullCount += 1, aObj = objCount +=1
+//- args
+false, '', NaN, 0, null, obj
+//- body
+assert.sameValue(aFalse, false);
+assert.sameValue(aString, '');
+assert.sameValue(aNaN, NaN);
+assert.sameValue(a0, 0);
+assert.sameValue(aNull, null);
+assert.sameValue(aObj, obj);
+//- teardown
+assert.sameValue(falseCount, 0, 'initializer not evaluated: false');
+assert.sameValue(stringCount, 0, 'initializer not evaluated: string');
+assert.sameValue(nanCount, 0, 'initializer not evaluated: NaN');
+assert.sameValue(zeroCount, 0, 'initializer not evaluated: 0');
+assert.sameValue(nullCount, 0, 'initializer not evaluated: null');
+assert.sameValue(objCount, 0, 'initializer not evaluated: object');
diff --git a/src/dflt-params/arg-val-undefined.case b/src/dflt-params/arg-val-undefined.case
new file mode 100644
index 0000000000000000000000000000000000000000..3d4797b26e275da0d44a2181635aef71c9c5ccab
--- /dev/null
+++ b/src/dflt-params/arg-val-undefined.case
@@ -0,0 +1,29 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+desc: Use of intializer when argument value is `undefined`
+template: default
+info: |
+ 14.1.19 Runtime Semantics: IteratorBindingInitialization
+
+ FormalsList : FormalsList , FormalParameter
+
+ [...]
+ 23. Let iteratorRecord be Record {[[Iterator]]:
+ CreateListIterator(argumentsList), [[Done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ a. Perform ? IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+//- params
+fromLiteral = 23, fromExpr = 45, fromHole = 99
+//- args
+undefined, void 0
+//- body
+assert.sameValue(fromLiteral, 23);
+assert.sameValue(fromExpr, 45);
+assert.sameValue(fromHole, 99);
diff --git a/src/dflt-params/default/arrow-function.template b/src/dflt-params/default/arrow-function.template
new file mode 100644
index 0000000000000000000000000000000000000000..d6b94de60aef06b116c98336dab2d01f91626af5
--- /dev/null
+++ b/src/dflt-params/default/arrow-function.template
@@ -0,0 +1,48 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/expressions/arrow-function/params-dflt-
+name: arrow function expression
+esid: sec-arrow-function-definitions-runtime-semantics-evaluation
+es6id: 14.2.16
+features: [default-parameters]
+info: |
+ ArrowFunction : ArrowParameters => ConciseBody
+
+ [...]
+ 4. Let closure be FunctionCreate(Arrow, parameters, ConciseBody, scope, strict).
+ [...]
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+var callCount = 0;
+var f;
+f = (/*{ params }*/) => {
+ /*{ body }*/
+ callCount = callCount + 1;
+};
+
+f(/*{ args }*/);
+assert.sameValue(callCount, 1, 'arrow function invoked exactly once');
diff --git a/src/dflt-params/default/cls-decl-gen-meth-static.template b/src/dflt-params/default/cls-decl-gen-meth-static.template
new file mode 100644
index 0000000000000000000000000000000000000000..a617fc6d6f5bb3a82bb694eff106d0ab609326c0
--- /dev/null
+++ b/src/dflt-params/default/cls-decl-gen-meth-static.template
@@ -0,0 +1,72 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/statements/class/params-dflt-gen-meth-static-
+name: static class expression generator method
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+es6id: 14.5.15
+features: [default-parameters]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation
+
+ GeneratorMethod : * PropertyName ( StrictFormalParameters ) { GeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this GeneratorMethod is strict mode code,
+ let strict be true. Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be GeneratorFunctionCreate(Method,
+ StrictFormalParameters, GeneratorBody, scope, strict).
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+var callCount = 0;
+class C {
+ static *method(/*{ params }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+ }
+}
+
+C.method(/*{ args }*/).next();
+
+assert.sameValue(callCount, 1, 'method invoked exactly once');
diff --git a/src/dflt-params/default/cls-decl-gen-meth.template b/src/dflt-params/default/cls-decl-gen-meth.template
new file mode 100644
index 0000000000000000000000000000000000000000..ba80c6ecd2caa7f5580688ed177820ecadc5ecc0
--- /dev/null
+++ b/src/dflt-params/default/cls-decl-gen-meth.template
@@ -0,0 +1,72 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/statements/class/params-dflt-gen-meth-
+name: class expression method
+esid: sec-class-definitions-runtime-semantics-evaluation
+es6id: 14.5.16
+features: [default-parameters]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation
+
+ GeneratorMethod : * PropertyName ( StrictFormalParameters ) { GeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this GeneratorMethod is strict mode code,
+ let strict be true. Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be GeneratorFunctionCreate(Method,
+ StrictFormalParameters, GeneratorBody, scope, strict).
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+var callCount = 0;
+class C {
+ *method(/*{ params }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+ }
+}
+
+C.prototype.method(/*{ args }*/).next();
+
+assert.sameValue(callCount, 1, 'method invoked exactly once');
diff --git a/src/dflt-params/default/cls-decl-meth-static.template b/src/dflt-params/default/cls-decl-meth-static.template
new file mode 100644
index 0000000000000000000000000000000000000000..637db4ac8d4b584602eeef1163f8df735e25fd7e
--- /dev/null
+++ b/src/dflt-params/default/cls-decl-meth-static.template
@@ -0,0 +1,70 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/statements/class/params-dflt-meth-static-
+name: static class expression method
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+es6id: 14.5.15
+features: [default-parameters]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ 14.3.8 Runtime Semantics: DefineMethod
+
+ MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody }
+
+ [...]
+ 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody,
+ scope, strict). If functionPrototype was passed as a parameter then pass its
+ value as the functionPrototype optional argument of FunctionCreate.
+ [...]
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+var callCount = 0;
+class C {
+ static method(/*{ params }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+ }
+}
+
+C.method(/*{ args }*/);
+
+assert.sameValue(callCount, 1, 'method invoked exactly once');
diff --git a/src/dflt-params/default/cls-decl-meth.template b/src/dflt-params/default/cls-decl-meth.template
new file mode 100644
index 0000000000000000000000000000000000000000..9c5eabaa95ea0812dce2104c4a3289122d0f56c4
--- /dev/null
+++ b/src/dflt-params/default/cls-decl-meth.template
@@ -0,0 +1,70 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/statements/class/params-dflt-meth-
+name: class expression method
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+es6id: 14.5.15
+features: [default-parameters]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ 14.3.8 Runtime Semantics: DefineMethod
+
+ MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody }
+
+ [...]
+ 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody,
+ scope, strict). If functionPrototype was passed as a parameter then pass its
+ value as the functionPrototype optional argument of FunctionCreate.
+ [...]
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+var callCount = 0;
+class C {
+ method(/*{ params }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+ }
+}
+
+C.prototype.method(/*{ args }*/);
+
+assert.sameValue(callCount, 1, 'method invoked exactly once');
diff --git a/src/dflt-params/default/cls-expr-gen-meth-static.template b/src/dflt-params/default/cls-expr-gen-meth-static.template
new file mode 100644
index 0000000000000000000000000000000000000000..1964116f891d0a77a281b761489c4646e0e3a4d3
--- /dev/null
+++ b/src/dflt-params/default/cls-expr-gen-meth-static.template
@@ -0,0 +1,74 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/expressions/class/params-dflt-gen-meth-static-
+name: static class expression generator method
+esid: sec-class-definitions-runtime-semantics-evaluation
+es6id: 14.5.16
+features: [default-parameters]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation
+
+ GeneratorMethod :
+ * PropertyName ( StrictFormalParameters ) { GeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this GeneratorMethod is strict mode code,
+ let strict be true. Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be GeneratorFunctionCreate(Method,
+ StrictFormalParameters, GeneratorBody, scope, strict).
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+var callCount = 0;
+var C = class {
+ static *method(/*{ params }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+ }
+};
+
+C.method(/*{ args }*/).next();
+
+assert.sameValue(callCount, 1, 'method invoked exactly once');
diff --git a/src/dflt-params/default/cls-expr-gen-meth.template b/src/dflt-params/default/cls-expr-gen-meth.template
new file mode 100644
index 0000000000000000000000000000000000000000..a02781a19d501dce452e4defb7d570a71c39d88c
--- /dev/null
+++ b/src/dflt-params/default/cls-expr-gen-meth.template
@@ -0,0 +1,74 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/expressions/class/params-dflt-gen-meth-
+name: class expression method
+esid: sec-class-definitions-runtime-semantics-evaluation
+es6id: 14.5.16
+features: [default-parameters]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation
+
+ GeneratorMethod :
+ * PropertyName ( StrictFormalParameters ) { GeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this GeneratorMethod is strict mode code,
+ let strict be true. Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be GeneratorFunctionCreate(Method,
+ StrictFormalParameters, GeneratorBody, scope, strict).
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+var callCount = 0;
+var C = class {
+ *method(/*{ params }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+ }
+};
+
+C.prototype.method(/*{ args }*/).next();
+
+assert.sameValue(callCount, 1, 'method invoked exactly once');
diff --git a/src/dflt-params/default/cls-expr-meth-static.template b/src/dflt-params/default/cls-expr-meth-static.template
new file mode 100644
index 0000000000000000000000000000000000000000..1906dc9d1fac3e9457239803badcdddfb19a85e8
--- /dev/null
+++ b/src/dflt-params/default/cls-expr-meth-static.template
@@ -0,0 +1,71 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/expressions/class/params-dflt-meth-static-
+name: static class expression method
+esid: sec-class-definitions-runtime-semantics-evaluation
+es6id: 14.5.16
+features: [default-parameters]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ 14.3.8 Runtime Semantics: DefineMethod
+
+ MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody }
+
+ [...]
+ 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody,
+ scope, strict). If functionPrototype was passed as a parameter then pass its
+ value as the functionPrototype optional argument of FunctionCreate.
+ [...]
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+var callCount = 0;
+var C = class {
+ static method(/*{ params }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+ }
+};
+
+C.method(/*{ args }*/);
+
+assert.sameValue(callCount, 1, 'method invoked exactly once');
diff --git a/src/dflt-params/default/cls-expr-meth.template b/src/dflt-params/default/cls-expr-meth.template
new file mode 100644
index 0000000000000000000000000000000000000000..0220880d470283fbe0e430559adaf90997af573e
--- /dev/null
+++ b/src/dflt-params/default/cls-expr-meth.template
@@ -0,0 +1,71 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/expressions/class/params-dflt-meth-
+name: class expression method
+esid: sec-class-definitions-runtime-semantics-evaluation
+es6id: 14.5.16
+features: [default-parameters]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ 14.3.8 Runtime Semantics: DefineMethod
+
+ MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody }
+
+ [...]
+ 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody,
+ scope, strict). If functionPrototype was passed as a parameter then pass its
+ value as the functionPrototype optional argument of FunctionCreate.
+ [...]
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+var callCount = 0;
+var C = class {
+ method(/*{ params }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+ }
+};
+
+C.prototype.method(/*{ args }*/);
+
+assert.sameValue(callCount, 1, 'method invoked exactly once');
diff --git a/src/dflt-params/default/func-decl.template b/src/dflt-params/default/func-decl.template
new file mode 100644
index 0000000000000000000000000000000000000000..d6cdb614b6f199635c2c878e51fa5e78276e5261
--- /dev/null
+++ b/src/dflt-params/default/func-decl.template
@@ -0,0 +1,50 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/statements/function/params-dflt-
+name: function declaration
+esid: sec-function-definitions-runtime-semantics-instantiatefunctionobject
+es6id: 14.1.19
+features: [default-parameters]
+info: |
+ FunctionDeclaration :
+ function BindingIdentifier ( FormalParameters ) { FunctionBody }
+
+ [...]
+ 3. Let F be FunctionCreate(Normal, FormalParameters, FunctionBody,
+ scope, strict).
+ [...]
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+var callCount = 0;
+function f(/*{ params }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+}
+
+f(/*{ args }*/);
+
+assert.sameValue(callCount, 1, 'function invoked exactly once');
diff --git a/src/dflt-params/default/func-expr.template b/src/dflt-params/default/func-expr.template
new file mode 100644
index 0000000000000000000000000000000000000000..75cbfecf45e7dd0e28e43796c460ef865770bb0a
--- /dev/null
+++ b/src/dflt-params/default/func-expr.template
@@ -0,0 +1,50 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/expressions/function/params-dflt-
+name: function expression
+esid: sec-function-definitions-runtime-semantics-evaluation
+es6id: 14.1.20
+features: [default-parameters]
+info: |
+ FunctionExpression : function ( FormalParameters ) { FunctionBody }
+
+ [...]
+ 3. Let closure be FunctionCreate(Normal, FormalParameters, FunctionBody,
+ scope, strict).
+ [...]
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+var callCount = 0;
+var f;
+f = function(/*{ params }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+};
+
+f(/*{ args }*/);
+
+assert.sameValue(callCount, 1, 'function invoked exactly once');
diff --git a/src/dflt-params/default/gen-func-decl.template b/src/dflt-params/default/gen-func-decl.template
new file mode 100644
index 0000000000000000000000000000000000000000..c3d38a37617e49324e107b5cfb511714dd69016f
--- /dev/null
+++ b/src/dflt-params/default/gen-func-decl.template
@@ -0,0 +1,49 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/statements/generators/params-dflt-
+name: generator function declaration
+esid: sec-generator-function-definitions-runtime-semantics-instantiatefunctionobject
+es6id: 14.4.12
+features: [default-parameters]
+info: |
+ GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody }
+
+ [...]
+ 2. Let F be GeneratorFunctionCreate(Normal, FormalParameters,
+ GeneratorBody, scope, strict).
+ [...]
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+var callCount = 0;
+function* f(/*{ params }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+}
+
+f(/*{ args }*/).next();
+
+assert.sameValue(callCount, 1, 'generator function invoked exactly once');
diff --git a/src/dflt-params/default/gen-func-expr.template b/src/dflt-params/default/gen-func-expr.template
new file mode 100644
index 0000000000000000000000000000000000000000..c95d116be60cdc1330920468d7f545235ec3fdca
--- /dev/null
+++ b/src/dflt-params/default/gen-func-expr.template
@@ -0,0 +1,50 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/expressions/generators/params-dflt-
+name: generator function expression
+esid: sec-generator-function-definitions-runtime-semantics-evaluation
+es6id: 14.4.14
+features: [default-parameters]
+info: |
+ GeneratorExpression : function * ( FormalParameters ) { GeneratorBody }
+
+ [...]
+ 3. Let closure be GeneratorFunctionCreate(Normal, FormalParameters,
+ GeneratorBody, scope, strict).
+ [...]
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+var callCount = 0;
+var f;
+f = function*(/*{ params }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+};
+
+f(/*{ args }*/).next();
+
+assert.sameValue(callCount, 1, 'generator function invoked exactly once');
diff --git a/src/dflt-params/default/gen-meth.template b/src/dflt-params/default/gen-meth.template
new file mode 100644
index 0000000000000000000000000000000000000000..a302e616015d251591ac7c601a7f4fc91f66ada7
--- /dev/null
+++ b/src/dflt-params/default/gen-meth.template
@@ -0,0 +1,56 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/expressions/object/method-definition/params-dflt-gen-meth-
+name: generator method
+esid: sec-generator-function-definitions-runtime-semantics-propertydefinitionevaluation
+es6id: 14.4.13
+features: [default-parameters]
+info: |
+ GeneratorMethod :
+ * PropertyName ( StrictFormalParameters ) { GeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this GeneratorMethod is strict mode code,
+ let strict be true. Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be GeneratorFunctionCreate(Method,
+ StrictFormalParameters, GeneratorBody, scope, strict).
+ [...]
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+var callCount = 0;
+var obj = {
+ *method(/*{ params }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+ }
+};
+
+obj.method(/*{ args }*/).next();
+
+assert.sameValue(callCount, 1, 'generator method invoked exactly once');
diff --git a/src/dflt-params/default/meth.template b/src/dflt-params/default/meth.template
new file mode 100644
index 0000000000000000000000000000000000000000..48f25bdfd0c8995a0bf4e2ff2628cc3a3dde241f
--- /dev/null
+++ b/src/dflt-params/default/meth.template
@@ -0,0 +1,53 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/expressions/object/method-definition/params-dflt-meth-
+name: method
+esid: sec-runtime-semantics-definemethod
+es6id: 14.3.8
+features: [default-parameters]
+info: |
+ MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody }
+
+ [...]
+ 6. Let closure be FunctionCreate(kind, StrictFormalParameters,
+ FunctionBody, scope, strict). If functionPrototype was passed as a
+ parameter then pass its value as the functionPrototype optional argument
+ of FunctionCreate.
+ [...]
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+var callCount = 0;
+var obj = {
+ method(/*{ params }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+ }
+};
+
+obj.method(/*{ args }*/);
+
+assert.sameValue(callCount, 1, 'method invoked exactly once');
diff --git a/src/dflt-params/duplicates.case b/src/dflt-params/duplicates.case
new file mode 100644
index 0000000000000000000000000000000000000000..e2a6e424d0be4895a6e11df989002defd7eb9b1d
--- /dev/null
+++ b/src/dflt-params/duplicates.case
@@ -0,0 +1,25 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+desc: >
+ It is a Syntax Error if BoundNames of FormalParameters contains any duplicate
+ elements.
+template: syntax
+negative: SyntaxError
+info: |
+ 14.1.2 Static Semantics: Early Errors
+
+ StrictFormalParameters : FormalParameters
+
+ - It is a Syntax Error if BoundNames of FormalParameters contains any
+ duplicate elements.
+
+ FormalParameters : FormalParameterList
+
+ - It is a Syntax Error if IsSimpleParameterList of FormalParameterList is
+ false and BoundNames of FormalParameterList contains any duplicate
+ elements.
+---*/
+
+//- params
+x = 0, x
diff --git a/src/dflt-params/error/arrow-function.template b/src/dflt-params/error/arrow-function.template
new file mode 100644
index 0000000000000000000000000000000000000000..80e76e09b30bf11e9033048771fe13f55df85276
--- /dev/null
+++ b/src/dflt-params/error/arrow-function.template
@@ -0,0 +1,50 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/expressions/arrow-function/params-dflt-
+name: arrow function expression
+esid: sec-arrow-function-definitions-runtime-semantics-evaluation
+es6id: 14.2.16
+features: [default-parameters]
+info: |
+ ArrowFunction : ArrowParameters => ConciseBody
+
+ [...]
+ 4. Let closure be FunctionCreate(Arrow, parameters, ConciseBody, scope, strict).
+ [...]
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+var callCount = 0;
+var f;
+f = (/*{ params }*/) => {
+ /*{ body }*/
+ callCount = callCount + 1;
+};
+
+assert.throws(/*{ error }*/, function() {
+ f(/*{ args }*/);
+});
+assert.sameValue(callCount, 0, 'arrow function body not evaluated');
diff --git a/src/dflt-params/error/cls-decl-gen-meth-static.template b/src/dflt-params/error/cls-decl-gen-meth-static.template
new file mode 100644
index 0000000000000000000000000000000000000000..91132c062ea9fbfa58faa6964a2c72075197de5d
--- /dev/null
+++ b/src/dflt-params/error/cls-decl-gen-meth-static.template
@@ -0,0 +1,74 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/statements/class/params-dflt-gen-meth-static-
+name: static class expression generator method
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+es6id: 14.5.15
+features: [default-parameters]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation
+
+ GeneratorMethod : * PropertyName ( StrictFormalParameters ) { GeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this GeneratorMethod is strict mode code,
+ let strict be true. Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be GeneratorFunctionCreate(Method,
+ StrictFormalParameters, GeneratorBody, scope, strict).
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+var callCount = 0;
+class C {
+ static *method(/*{ params }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+ }
+}
+
+assert.throws(/*{ error }*/, function() {
+ C.method(/*{ args }*/);
+});
+
+assert.sameValue(callCount, 0, 'method body not evaluated');
diff --git a/src/dflt-params/error/cls-decl-gen-meth.template b/src/dflt-params/error/cls-decl-gen-meth.template
new file mode 100644
index 0000000000000000000000000000000000000000..a27716832bfeba8a93861f2c11669af2dd8984ba
--- /dev/null
+++ b/src/dflt-params/error/cls-decl-gen-meth.template
@@ -0,0 +1,73 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/statements/class/params-dflt-gen-meth-
+name: class expression method
+esid: sec-class-definitions-runtime-semantics-evaluation
+es6id: 14.5.16
+features: [default-parameters]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation
+
+ GeneratorMethod : * PropertyName ( StrictFormalParameters ) { GeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this GeneratorMethod is strict mode code,
+ let strict be true. Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be GeneratorFunctionCreate(Method,
+ StrictFormalParameters, GeneratorBody, scope, strict).
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+var callCount = 0;
+class C {
+ *method(/*{ params }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+ }
+}
+
+assert.throws(/*{ error }*/, function() {
+ C.prototype.method(/*{ args }*/);
+});
+assert.sameValue(callCount, 0, 'method body not evaluated');
diff --git a/src/dflt-params/error/cls-decl-meth-static.template b/src/dflt-params/error/cls-decl-meth-static.template
new file mode 100644
index 0000000000000000000000000000000000000000..204380ef3602183d0d5aa10c6dee0b0c14f054d6
--- /dev/null
+++ b/src/dflt-params/error/cls-decl-meth-static.template
@@ -0,0 +1,71 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/statements/class/params-dflt-meth-static-
+name: static class expression method
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+es6id: 14.5.15
+features: [default-parameters]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ 14.3.8 Runtime Semantics: DefineMethod
+
+ MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody }
+
+ [...]
+ 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody,
+ scope, strict). If functionPrototype was passed as a parameter then pass its
+ value as the functionPrototype optional argument of FunctionCreate.
+ [...]
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+var callCount = 0;
+class C {
+ static method(/*{ params }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+ }
+}
+
+assert.throws(/*{ error }*/, function() {
+ C.method(/*{ args }*/);
+});
+assert.sameValue(callCount, 0, 'method body not evaluated');
diff --git a/src/dflt-params/error/cls-decl-meth.template b/src/dflt-params/error/cls-decl-meth.template
new file mode 100644
index 0000000000000000000000000000000000000000..3242269590f1ce4b342d5dec44399d2e32a052e9
--- /dev/null
+++ b/src/dflt-params/error/cls-decl-meth.template
@@ -0,0 +1,71 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/statements/class/params-dflt-meth-
+name: class expression method
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+es6id: 14.5.15
+features: [default-parameters]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ 14.3.8 Runtime Semantics: DefineMethod
+
+ MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody }
+
+ [...]
+ 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody,
+ scope, strict). If functionPrototype was passed as a parameter then pass its
+ value as the functionPrototype optional argument of FunctionCreate.
+ [...]
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+var callCount = 0;
+class C {
+ method(/*{ params }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+ }
+}
+
+assert.throws(/*{ error }*/, function() {
+ C.prototype.method(/*{ args }*/);
+});
+assert.sameValue(callCount, 0, 'method body not evaluated');
diff --git a/src/dflt-params/error/cls-expr-gen-meth-static.template b/src/dflt-params/error/cls-expr-gen-meth-static.template
new file mode 100644
index 0000000000000000000000000000000000000000..9c43e710f6ce2a2fb235c202e47965a6f937d386
--- /dev/null
+++ b/src/dflt-params/error/cls-expr-gen-meth-static.template
@@ -0,0 +1,75 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/expressions/class/params-dflt-gen-meth-static-
+name: static class expression generator method
+esid: sec-class-definitions-runtime-semantics-evaluation
+es6id: 14.5.16
+features: [default-parameters]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation
+
+ GeneratorMethod :
+ * PropertyName ( StrictFormalParameters ) { GeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this GeneratorMethod is strict mode code,
+ let strict be true. Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be GeneratorFunctionCreate(Method,
+ StrictFormalParameters, GeneratorBody, scope, strict).
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+var callCount = 0;
+var C = class {
+ static *method(/*{ params }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+ }
+};
+
+assert.throws(/*{ error }*/, function() {
+ C.method(/*{ args }*/);
+});
+assert.sameValue(callCount, 0, 'method body not evaluated');
diff --git a/src/dflt-params/error/cls-expr-gen-meth.template b/src/dflt-params/error/cls-expr-gen-meth.template
new file mode 100644
index 0000000000000000000000000000000000000000..f1603cf651d8f3860d3be238060b5f4a33207d82
--- /dev/null
+++ b/src/dflt-params/error/cls-expr-gen-meth.template
@@ -0,0 +1,75 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/expressions/class/params-dflt-gen-meth-
+name: class expression method
+esid: sec-class-definitions-runtime-semantics-evaluation
+es6id: 14.5.16
+features: [default-parameters]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation
+
+ GeneratorMethod :
+ * PropertyName ( StrictFormalParameters ) { GeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this GeneratorMethod is strict mode code,
+ let strict be true. Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be GeneratorFunctionCreate(Method,
+ StrictFormalParameters, GeneratorBody, scope, strict).
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+var callCount = 0;
+var C = class {
+ *method(/*{ params }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+ }
+};
+
+assert.throws(/*{ error }*/, function() {
+ C.prototype.method(/*{ args }*/);
+});
+assert.sameValue(callCount, 0, 'method body not evaluated');
diff --git a/src/dflt-params/error/cls-expr-meth-static.template b/src/dflt-params/error/cls-expr-meth-static.template
new file mode 100644
index 0000000000000000000000000000000000000000..05bed0933b0f5e28f3e794aed0ea045bb8f85642
--- /dev/null
+++ b/src/dflt-params/error/cls-expr-meth-static.template
@@ -0,0 +1,72 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/expressions/class/params-dflt-meth-static-
+name: static class expression method
+esid: sec-class-definitions-runtime-semantics-evaluation
+es6id: 14.5.16
+features: [default-parameters]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ 14.3.8 Runtime Semantics: DefineMethod
+
+ MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody }
+
+ [...]
+ 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody,
+ scope, strict). If functionPrototype was passed as a parameter then pass its
+ value as the functionPrototype optional argument of FunctionCreate.
+ [...]
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+var callCount = 0;
+var C = class {
+ static method(/*{ params }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+ }
+};
+
+assert.throws(/*{ error }*/, function() {
+ C.method(/*{ args }*/);
+});
+assert.sameValue(callCount, 0, 'method body not evaluated');
diff --git a/src/dflt-params/error/cls-expr-meth.template b/src/dflt-params/error/cls-expr-meth.template
new file mode 100644
index 0000000000000000000000000000000000000000..b89ff9944f717fc8fd5924117725c2d73944532c
--- /dev/null
+++ b/src/dflt-params/error/cls-expr-meth.template
@@ -0,0 +1,72 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/expressions/class/params-dflt-meth-
+name: class expression method
+esid: sec-class-definitions-runtime-semantics-evaluation
+es6id: 14.5.16
+features: [default-parameters]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ 14.3.8 Runtime Semantics: DefineMethod
+
+ MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody }
+
+ [...]
+ 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody,
+ scope, strict). If functionPrototype was passed as a parameter then pass its
+ value as the functionPrototype optional argument of FunctionCreate.
+ [...]
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+var callCount = 0;
+var C = class {
+ method(/*{ params }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+ }
+};
+
+assert.throws(/*{ error }*/, function() {
+ C.prototype.method(/*{ args }*/);
+});
+assert.sameValue(callCount, 0, 'method body not evaluated');
diff --git a/src/dflt-params/error/func-decl.template b/src/dflt-params/error/func-decl.template
new file mode 100644
index 0000000000000000000000000000000000000000..81e5da3712cb361fb435fc17e485a190b4726cf4
--- /dev/null
+++ b/src/dflt-params/error/func-decl.template
@@ -0,0 +1,50 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/statements/function/params-dflt-
+name: function declaration
+esid: sec-function-definitions-runtime-semantics-instantiatefunctionobject
+es6id: 14.1.19
+features: [default-parameters]
+info: |
+ FunctionDeclaration :
+ function BindingIdentifier ( FormalParameters ) { FunctionBody }
+
+ [...]
+ 3. Let F be FunctionCreate(Normal, FormalParameters, FunctionBody,
+ scope, strict).
+ [...]
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+var callCount = 0;
+function f(/*{ params }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+}
+assert.throws(/*{ error }*/, function() {
+ f(/*{ args }*/);
+});
+assert.sameValue(callCount, 0, 'function body not evaluated');
diff --git a/src/dflt-params/error/func-expr.template b/src/dflt-params/error/func-expr.template
new file mode 100644
index 0000000000000000000000000000000000000000..2d38723ca11b28385440de2ff4f4cde18e25a1b3
--- /dev/null
+++ b/src/dflt-params/error/func-expr.template
@@ -0,0 +1,51 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/expressions/function/params-dflt-
+name: function expression
+esid: sec-function-definitions-runtime-semantics-evaluation
+es6id: 14.1.20
+features: [default-parameters]
+info: |
+ FunctionExpression : function ( FormalParameters ) { FunctionBody }
+
+ [...]
+ 3. Let closure be FunctionCreate(Normal, FormalParameters, FunctionBody,
+ scope, strict).
+ [...]
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+var callCount = 0;
+var f;
+f = function(/*{ params }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+};
+
+assert.throws(/*{ error }*/, function() {
+ f(/*{ args }*/);
+});
+assert.sameValue(callCount, 0, 'function body not evaluated');
diff --git a/src/dflt-params/error/gen-func-decl.template b/src/dflt-params/error/gen-func-decl.template
new file mode 100644
index 0000000000000000000000000000000000000000..74d7e3e33b74677b1f603ece56e105ff3054363f
--- /dev/null
+++ b/src/dflt-params/error/gen-func-decl.template
@@ -0,0 +1,51 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/statements/generators/params-dflt-
+name: generator function declaration
+esid: sec-generator-function-definitions-runtime-semantics-instantiatefunctionobject
+es6id: 14.4.12
+features: [default-parameters]
+info: |
+ GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody }
+
+ [...]
+ 2. Let F be GeneratorFunctionCreate(Normal, FormalParameters,
+ GeneratorBody, scope, strict).
+ [...]
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+var callCount = 0;
+function* f(/*{ params }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+}
+
+assert.throws(/*{ error }*/, function() {
+ f(/*{ args }*/);
+});
+
+assert.sameValue(callCount, 0, 'generator function body not evaluated');
diff --git a/src/dflt-params/error/gen-func-expr.template b/src/dflt-params/error/gen-func-expr.template
new file mode 100644
index 0000000000000000000000000000000000000000..950d3e132bd49f5d304c7727d53abf0a32910d37
--- /dev/null
+++ b/src/dflt-params/error/gen-func-expr.template
@@ -0,0 +1,51 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/expressions/generators/params-dflt-
+name: generator function expression
+esid: sec-generator-function-definitions-runtime-semantics-evaluation
+es6id: 14.4.14
+features: [default-parameters]
+info: |
+ GeneratorExpression : function * ( FormalParameters ) { GeneratorBody }
+
+ [...]
+ 3. Let closure be GeneratorFunctionCreate(Normal, FormalParameters,
+ GeneratorBody, scope, strict).
+ [...]
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+var callCount = 0;
+var f;
+f = function*(/*{ params }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+};
+
+assert.throws(/*{ error }*/, function() {
+ f(/*{ args }*/);
+});
+assert.sameValue(callCount, 0, 'generator function body not evaluated');
diff --git a/src/dflt-params/error/gen-meth.template b/src/dflt-params/error/gen-meth.template
new file mode 100644
index 0000000000000000000000000000000000000000..3862e08507c2efab5644447ffa5a8e2028aa5d49
--- /dev/null
+++ b/src/dflt-params/error/gen-meth.template
@@ -0,0 +1,57 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/expressions/object/method-definition/params-dflt-gen-meth-
+name: generator method
+esid: sec-generator-function-definitions-runtime-semantics-propertydefinitionevaluation
+es6id: 14.4.13
+features: [default-parameters]
+info: |
+ GeneratorMethod :
+ * PropertyName ( StrictFormalParameters ) { GeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this GeneratorMethod is strict mode code,
+ let strict be true. Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be GeneratorFunctionCreate(Method,
+ StrictFormalParameters, GeneratorBody, scope, strict).
+ [...]
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+var callCount = 0;
+var obj = {
+ *method(/*{ params }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+ }
+};
+
+assert.throws(/*{ error }*/, function() {
+ obj.method(/*{ args }*/);
+});
+assert.sameValue(callCount, 0, 'generator method body not evaluated');
diff --git a/src/dflt-params/error/meth.template b/src/dflt-params/error/meth.template
new file mode 100644
index 0000000000000000000000000000000000000000..3683dbbedf0fae2d8176d5949aa16cc6e488d1bd
--- /dev/null
+++ b/src/dflt-params/error/meth.template
@@ -0,0 +1,54 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/expressions/object/method-definition/params-dflt-meth-
+name: method
+esid: sec-runtime-semantics-definemethod
+es6id: 14.3.8
+features: [default-parameters]
+info: |
+ MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody }
+
+ [...]
+ 6. Let closure be FunctionCreate(kind, StrictFormalParameters,
+ FunctionBody, scope, strict). If functionPrototype was passed as a
+ parameter then pass its value as the functionPrototype optional argument
+ of FunctionCreate.
+ [...]
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+var callCount = 0;
+var obj = {
+ method(/*{ params }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+ }
+};
+
+assert.throws(/*{ error }*/, function() {
+ obj.method(/*{ args }*/);
+});
+assert.sameValue(callCount, 0, 'method body not evaluated');
diff --git a/src/dflt-params/ref-later.case b/src/dflt-params/ref-later.case
new file mode 100644
index 0000000000000000000000000000000000000000..3087a10f32d41bae37578f7e28a11b96118da5e9
--- /dev/null
+++ b/src/dflt-params/ref-later.case
@@ -0,0 +1,23 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+desc: Referencing a parameter that occurs later in the ParameterList
+template: error
+info: |
+ 14.1.19 Runtime Semantics: IteratorBindingInitialization
+
+ FormalsList : FormalsList , FormalParameter
+
+ 1. Let status be the result of performing IteratorBindingInitialization for
+ FormalsList using iteratorRecord and environment as the arguments.
+ 2. ReturnIfAbrupt(status).
+ 3. Return the result of performing IteratorBindingInitialization for
+ FormalParameter using iteratorRecord and environment as the arguments.
+---*/
+
+//- setup
+var x = 0;
+//- params
+x = y, y
+//- error
+ReferenceError
diff --git a/src/dflt-params/ref-prior.case b/src/dflt-params/ref-prior.case
new file mode 100644
index 0000000000000000000000000000000000000000..5e28248bb0df6f5cbd240d1c7f774f6fffcfa678
--- /dev/null
+++ b/src/dflt-params/ref-prior.case
@@ -0,0 +1,27 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+desc: Referencing a parameter that occurs earlier in the ParameterList
+template: default
+info: |
+ 14.1.19 Runtime Semantics: IteratorBindingInitialization
+
+ FormalsList : FormalsList , FormalParameter
+
+ 1. Let status be the result of performing IteratorBindingInitialization for
+ FormalsList using iteratorRecord and environment as the arguments.
+ 2. ReturnIfAbrupt(status).
+ 3. Return the result of performing IteratorBindingInitialization for
+ FormalParameter using iteratorRecord and environment as the arguments.
+---*/
+
+//- setup
+var x = 0;
+//- params
+x, y = x, z = y
+//- args
+3
+//- body
+assert.sameValue(x, 3, 'first argument value');
+assert.sameValue(y, 3, 'second argument value');
+assert.sameValue(z, 3, 'third argument value');
diff --git a/src/dflt-params/ref-self.case b/src/dflt-params/ref-self.case
new file mode 100644
index 0000000000000000000000000000000000000000..41b92f46e509be99fccf9abcaa4c51630932e35b
--- /dev/null
+++ b/src/dflt-params/ref-self.case
@@ -0,0 +1,23 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+desc: Referencing a parameter from within its own initializer
+template: error
+info: |
+ 14.1.19 Runtime Semantics: IteratorBindingInitialization
+
+ FormalsList : FormalsList , FormalParameter
+
+ 1. Let status be the result of performing IteratorBindingInitialization for
+ FormalsList using iteratorRecord and environment as the arguments.
+ 2. ReturnIfAbrupt(status).
+ 3. Return the result of performing IteratorBindingInitialization for
+ FormalParameter using iteratorRecord and environment as the arguments.
+---*/
+
+//- setup
+var x = 0;
+//- params
+x = x
+//- error
+ReferenceError
diff --git a/src/dflt-params/rest.case b/src/dflt-params/rest.case
new file mode 100644
index 0000000000000000000000000000000000000000..e8b7f03e35c7a4395c6c2ac98c3808948299300b
--- /dev/null
+++ b/src/dflt-params/rest.case
@@ -0,0 +1,27 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+desc: RestParameter does not support an initializer
+template: syntax
+info: |
+ 14.1 Function Definitions
+
+ Syntax
+
+ FunctionRestParameter[Yield] :
+
+ BindingRestElement[?Yield]
+
+ 13.3.3 Destructuring Binding Patterns
+
+ Syntax
+
+ BindingRestElement[Yield] :
+
+ ...BindingIdentifier[?Yield]
+ ...BindingPattern[?Yield]
+negative: SyntaxError
+---*/
+
+//- params
+...x = []
diff --git a/src/dflt-params/syntax/arrow-function.template b/src/dflt-params/syntax/arrow-function.template
new file mode 100644
index 0000000000000000000000000000000000000000..46f6eabab0c30b48e216b3cf096a53b108676d53
--- /dev/null
+++ b/src/dflt-params/syntax/arrow-function.template
@@ -0,0 +1,42 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/expressions/arrow-function/params-dflt-
+name: arrow function expression
+esid: sec-arrow-function-definitions-runtime-semantics-evaluation
+es6id: 14.2.16
+features: [default-parameters]
+info: |
+ ArrowFunction : ArrowParameters => ConciseBody
+
+ [...]
+ 4. Let closure be FunctionCreate(Arrow, parameters, ConciseBody, scope, strict).
+ [...]
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+0, (/*{ params }*/) => {
+ /*{ body }*/
+};
diff --git a/src/dflt-params/syntax/cls-decl-gen-meth-static.template b/src/dflt-params/syntax/cls-decl-gen-meth-static.template
new file mode 100644
index 0000000000000000000000000000000000000000..50414c1ada5c8c616b2c490061f82699fc247f93
--- /dev/null
+++ b/src/dflt-params/syntax/cls-decl-gen-meth-static.template
@@ -0,0 +1,66 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/statements/class/params-dflt-gen-meth-static-
+name: static class expression generator method
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+es6id: 14.5.15
+features: [default-parameters]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation
+
+ GeneratorMethod : * PropertyName ( StrictFormalParameters ) { GeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this GeneratorMethod is strict mode code,
+ let strict be true. Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be GeneratorFunctionCreate(Method,
+ StrictFormalParameters, GeneratorBody, scope, strict).
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+class C {
+ static *method(/*{ params }*/) {
+ /*{ body }*/
+ }
+}
diff --git a/src/dflt-params/syntax/cls-decl-gen-meth.template b/src/dflt-params/syntax/cls-decl-gen-meth.template
new file mode 100644
index 0000000000000000000000000000000000000000..fe6c08640341c83f6a4c087bde20c74f4b50102b
--- /dev/null
+++ b/src/dflt-params/syntax/cls-decl-gen-meth.template
@@ -0,0 +1,66 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/statements/class/params-dflt-gen-meth-
+name: class expression method
+esid: sec-class-definitions-runtime-semantics-evaluation
+es6id: 14.5.16
+features: [default-parameters]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation
+
+ GeneratorMethod : * PropertyName ( StrictFormalParameters ) { GeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this GeneratorMethod is strict mode code,
+ let strict be true. Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be GeneratorFunctionCreate(Method,
+ StrictFormalParameters, GeneratorBody, scope, strict).
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+class C {
+ *method(/*{ params }*/) {
+ /*{ body }*/
+ }
+}
diff --git a/src/dflt-params/syntax/cls-decl-meth-static.template b/src/dflt-params/syntax/cls-decl-meth-static.template
new file mode 100644
index 0000000000000000000000000000000000000000..b3c8b8709d19a082b8fbb138570dcbac29b298bc
--- /dev/null
+++ b/src/dflt-params/syntax/cls-decl-meth-static.template
@@ -0,0 +1,64 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/statements/class/params-dflt-meth-static-
+name: static class expression method
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+es6id: 14.5.15
+features: [default-parameters]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ 14.3.8 Runtime Semantics: DefineMethod
+
+ MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody }
+
+ [...]
+ 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody,
+ scope, strict). If functionPrototype was passed as a parameter then pass its
+ value as the functionPrototype optional argument of FunctionCreate.
+ [...]
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+class C {
+ static method(/*{ params }*/) {
+ /*{ body }*/
+ }
+}
diff --git a/src/dflt-params/syntax/cls-decl-meth.template b/src/dflt-params/syntax/cls-decl-meth.template
new file mode 100644
index 0000000000000000000000000000000000000000..f6cdd67e5d4dfede29cc85f12992d0a9cc8c7fef
--- /dev/null
+++ b/src/dflt-params/syntax/cls-decl-meth.template
@@ -0,0 +1,64 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/statements/class/params-dflt-meth-
+name: class expression method
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+es6id: 14.5.15
+features: [default-parameters]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ 14.3.8 Runtime Semantics: DefineMethod
+
+ MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody }
+
+ [...]
+ 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody,
+ scope, strict). If functionPrototype was passed as a parameter then pass its
+ value as the functionPrototype optional argument of FunctionCreate.
+ [...]
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+class C {
+ method(/*{ params }*/) {
+ /*{ body }*/
+ }
+}
diff --git a/src/dflt-params/syntax/cls-expr-gen-meth-static.template b/src/dflt-params/syntax/cls-expr-gen-meth-static.template
new file mode 100644
index 0000000000000000000000000000000000000000..dad86689916260cdc55ef3310997dabbc73a9037
--- /dev/null
+++ b/src/dflt-params/syntax/cls-expr-gen-meth-static.template
@@ -0,0 +1,68 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/expressions/class/params-dflt-gen-meth-static-
+name: static class expression generator method
+esid: sec-class-definitions-runtime-semantics-evaluation
+es6id: 14.5.16
+features: [default-parameters]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation
+
+ GeneratorMethod :
+ * PropertyName ( StrictFormalParameters ) { GeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this GeneratorMethod is strict mode code,
+ let strict be true. Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be GeneratorFunctionCreate(Method,
+ StrictFormalParameters, GeneratorBody, scope, strict).
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+0, class {
+ static *method(/*{ params }*/) {
+ /*{ body }*/
+ }
+};
diff --git a/src/dflt-params/syntax/cls-expr-gen-meth.template b/src/dflt-params/syntax/cls-expr-gen-meth.template
new file mode 100644
index 0000000000000000000000000000000000000000..65572962268170a6755ca156e13af7e796e9615c
--- /dev/null
+++ b/src/dflt-params/syntax/cls-expr-gen-meth.template
@@ -0,0 +1,68 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/expressions/class/params-dflt-gen-meth-
+name: class expression method
+esid: sec-class-definitions-runtime-semantics-evaluation
+es6id: 14.5.16
+features: [default-parameters]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation
+
+ GeneratorMethod :
+ * PropertyName ( StrictFormalParameters ) { GeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this GeneratorMethod is strict mode code,
+ let strict be true. Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be GeneratorFunctionCreate(Method,
+ StrictFormalParameters, GeneratorBody, scope, strict).
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+0, class {
+ *method(/*{ params }*/) {
+ /*{ body }*/
+ }
+};
diff --git a/src/dflt-params/syntax/cls-expr-meth-static.template b/src/dflt-params/syntax/cls-expr-meth-static.template
new file mode 100644
index 0000000000000000000000000000000000000000..f90fa8dccb8340bcc0ffd4dad93cde1740c95029
--- /dev/null
+++ b/src/dflt-params/syntax/cls-expr-meth-static.template
@@ -0,0 +1,65 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/expressions/class/params-dflt-meth-static-
+name: static class expression method
+esid: sec-class-definitions-runtime-semantics-evaluation
+es6id: 14.5.16
+features: [default-parameters]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ 14.3.8 Runtime Semantics: DefineMethod
+
+ MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody }
+
+ [...]
+ 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody,
+ scope, strict). If functionPrototype was passed as a parameter then pass its
+ value as the functionPrototype optional argument of FunctionCreate.
+ [...]
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+0, class {
+ static method(/*{ params }*/) {
+ /*{ body }*/
+ }
+};
diff --git a/src/dflt-params/syntax/cls-expr-meth.template b/src/dflt-params/syntax/cls-expr-meth.template
new file mode 100644
index 0000000000000000000000000000000000000000..88f862d083636a1cb1a79690d12ea2d7c090d8cd
--- /dev/null
+++ b/src/dflt-params/syntax/cls-expr-meth.template
@@ -0,0 +1,65 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/expressions/class/params-dflt-meth-
+name: class expression method
+esid: sec-class-definitions-runtime-semantics-evaluation
+es6id: 14.5.16
+features: [default-parameters]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ 14.3.8 Runtime Semantics: DefineMethod
+
+ MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody }
+
+ [...]
+ 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody,
+ scope, strict). If functionPrototype was passed as a parameter then pass its
+ value as the functionPrototype optional argument of FunctionCreate.
+ [...]
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+0, class {
+ method(/*{ params }*/) {
+ /*{ body }*/
+ }
+};
diff --git a/src/dflt-params/syntax/func-decl.template b/src/dflt-params/syntax/func-decl.template
new file mode 100644
index 0000000000000000000000000000000000000000..601a9826b25652ccb61ebc930481c423e6bfc6fc
--- /dev/null
+++ b/src/dflt-params/syntax/func-decl.template
@@ -0,0 +1,44 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/statements/function/params-dflt-
+name: function declaration
+esid: sec-function-definitions-runtime-semantics-instantiatefunctionobject
+es6id: 14.1.19
+features: [default-parameters]
+info: |
+ FunctionDeclaration :
+ function BindingIdentifier ( FormalParameters ) { FunctionBody }
+
+ [...]
+ 3. Let F be FunctionCreate(Normal, FormalParameters, FunctionBody,
+ scope, strict).
+ [...]
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+function f(/*{ params }*/) {
+ /*{ body }*/
+}
diff --git a/src/dflt-params/syntax/func-expr.template b/src/dflt-params/syntax/func-expr.template
new file mode 100644
index 0000000000000000000000000000000000000000..8407f2df2aaec3f189d5b4152ba7bb0f901c31e8
--- /dev/null
+++ b/src/dflt-params/syntax/func-expr.template
@@ -0,0 +1,43 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/expressions/function/params-dflt-
+name: function expression
+esid: sec-function-definitions-runtime-semantics-evaluation
+es6id: 14.1.20
+features: [default-parameters]
+info: |
+ FunctionExpression : function ( FormalParameters ) { FunctionBody }
+
+ [...]
+ 3. Let closure be FunctionCreate(Normal, FormalParameters, FunctionBody,
+ scope, strict).
+ [...]
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+0, function(/*{ params }*/) {
+ /*{ body }*/
+};
diff --git a/src/dflt-params/syntax/gen-func-decl.template b/src/dflt-params/syntax/gen-func-decl.template
new file mode 100644
index 0000000000000000000000000000000000000000..79b7683c9641c060068a86cab1fbcc0017ffc29e
--- /dev/null
+++ b/src/dflt-params/syntax/gen-func-decl.template
@@ -0,0 +1,43 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/statements/generators/params-dflt-
+name: generator function declaration
+esid: sec-generator-function-definitions-runtime-semantics-instantiatefunctionobject
+es6id: 14.4.12
+features: [default-parameters]
+info: |
+ GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody }
+
+ [...]
+ 2. Let F be GeneratorFunctionCreate(Normal, FormalParameters,
+ GeneratorBody, scope, strict).
+ [...]
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+function* f(/*{ params }*/) {
+ /*{ body }*/
+}
diff --git a/src/dflt-params/syntax/gen-func-expr.template b/src/dflt-params/syntax/gen-func-expr.template
new file mode 100644
index 0000000000000000000000000000000000000000..0ef6dbe35af70f0e1e09bd6a39a97f2190eb675e
--- /dev/null
+++ b/src/dflt-params/syntax/gen-func-expr.template
@@ -0,0 +1,43 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/expressions/generators/params-dflt-
+name: generator function expression
+esid: sec-generator-function-definitions-runtime-semantics-evaluation
+es6id: 14.4.14
+features: [default-parameters]
+info: |
+ GeneratorExpression : function * ( FormalParameters ) { GeneratorBody }
+
+ [...]
+ 3. Let closure be GeneratorFunctionCreate(Normal, FormalParameters,
+ GeneratorBody, scope, strict).
+ [...]
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+0, function*(/*{ params }*/) {
+ /*{ body }*/
+};
diff --git a/src/dflt-params/syntax/gen-meth.template b/src/dflt-params/syntax/gen-meth.template
new file mode 100644
index 0000000000000000000000000000000000000000..f9125cff5933bb5c9adc06f818c3f1c654f06257
--- /dev/null
+++ b/src/dflt-params/syntax/gen-meth.template
@@ -0,0 +1,50 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/expressions/object/method-definition/params-dflt-gen-meth-
+name: generator method
+esid: sec-generator-function-definitions-runtime-semantics-propertydefinitionevaluation
+es6id: 14.4.13
+features: [default-parameters]
+info: |
+ GeneratorMethod :
+ * PropertyName ( StrictFormalParameters ) { GeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this GeneratorMethod is strict mode code,
+ let strict be true. Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be GeneratorFunctionCreate(Method,
+ StrictFormalParameters, GeneratorBody, scope, strict).
+ [...]
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+0, {
+ *method(/*{ params }*/) {
+ /*{ body }*/
+ }
+};
diff --git a/src/dflt-params/syntax/meth.template b/src/dflt-params/syntax/meth.template
new file mode 100644
index 0000000000000000000000000000000000000000..b9f3c8310983d177896007b61ea7ce99601a3373
--- /dev/null
+++ b/src/dflt-params/syntax/meth.template
@@ -0,0 +1,47 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/expressions/object/method-definition/params-dflt-meth-
+name: method
+esid: sec-runtime-semantics-definemethod
+es6id: 14.3.8
+features: [default-parameters]
+info: |
+ MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody }
+
+ [...]
+ 6. Let closure be FunctionCreate(kind, StrictFormalParameters,
+ FunctionBody, scope, strict). If functionPrototype was passed as a
+ parameter then pass its value as the functionPrototype optional argument
+ of FunctionCreate.
+ [...]
+
+ 9.2.1 [[Call]] ( thisArgument, argumentsList)
+
+ [...]
+ 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
+ [...]
+
+ 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList )
+
+ 1. Let status be FunctionDeclarationInstantiation(F, argumentsList).
+ [...]
+
+ 9.2.12 FunctionDeclarationInstantiation(func, argumentsList)
+
+ [...]
+ 23. Let iteratorRecord be Record {[[iterator]]:
+ CreateListIterator(argumentsList), [[done]]: false}.
+ 24. If hasDuplicates is true, then
+ [...]
+ 25. Else,
+ b. Let formalStatus be IteratorBindingInitialization for formals with
+ iteratorRecord and env as arguments.
+ [...]
+---*/
+
+0, {
+ method(/*{ params }*/) {
+ /*{ body }*/
+ }
+};