Annex b skip fib (#704)

* Re-generate tests

The test generation tool has been modified in the time since these tests
were first generated and committed to the project. Re-generate the tests
using the latest version of the tool.

* Add test cases for Annex B hoisting disqualifiers

The "variable-like" function hoisting semantics defined in Annex B
extension B.3.3 is only applied if "[...] replacing the
FunctionDeclaration f with a VariableStatement that has F as a
BindingIdentifier would not produce any Early Errors [...]". Test262
previously included tests for this condition when the disqualifying
early error originated from the ScriptBody and FunctionBody productions.

Add test cases to assert the behavior when it is disqualified by all
other relevant early errors: Block statements, `for` statements,
`for-of` statements, `for-in` statements, and Switch statements.

* Generate tests

* fixup! Add test cases for Annex B hoisting disqualifiers

* fixup! Add test cases for Annex B hoisting disqualifiers

Correct test case "info" meta-data.

* fixup! Add test cases for Annex B hoisting disqualifiers

Improve test bodies

* fixup! Generate tests

src/annex-b-fns/eval-func-no-skip-try.case

@@ -0,0 +1,45 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+desc: >
+  Extension is observed when creation of variable binding would not produce an
+  early error (try statement)
+template: eval-func
+info: |
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+
+    B.3.5 VariableStatements in Catch Blocks
+
+    [...]
+    - It is a Syntax Error if any element of the BoundNames of CatchParameter
+      also occurs in the VarDeclaredNames of Block unless CatchParameter is
+      CatchParameter:BindingIdentifier and that element is only bound by a
+      VariableStatement, the VariableDeclarationList of a for statement, or the
+      ForBinding of a for-in statement.
+---*/
+
+//- before
+assert.sameValue(
+  f, undefined, 'Initialized binding created prior to evaluation'
+);
+
+try {
+  throw null;
+} catch (f) {
+//- body
+return 123;
+//- after
+}
+
+assert.sameValue(
+  typeof f,
+  'function',
+  'binding value is updated following evaluation'
+);
+assert.sameValue(f(), 123);

src/annex-b-fns/eval-func-skip-early-err-block.case

@@ -0,0 +1,40 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+desc: >
+  Extension not observed when creation of variable binding would produce an
+  early error (Block statement)
+template: eval-func
+info: |
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+---*/
+
+//- before
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created prior to evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created prior to evaluation'
+);
+
+{
+let f = 123;
+//- after
+}
+
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created following evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created following evaluation'
+);

src/annex-b-fns/eval-func-skip-early-err-for-in.case

@@ -0,0 +1,39 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+desc: >
+  Extension not observed when creation of variable binding would produce an
+  early error (for-of statement)
+template: eval-func
+info: |
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+---*/
+
+//- before
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created prior to evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created prior to evaluation'
+);
+
+for (let f in { key: 0 }) {
+//- after
+}
+
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created following evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created following evaluation'
+);

src/annex-b-fns/eval-func-skip-early-err-for-of.case

@@ -0,0 +1,39 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+desc: >
+  Extension not observed when creation of variable binding would produce an
+  early error (for-of statement)
+template: eval-func
+info: |
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+---*/
+
+//- before
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created prior to evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created prior to evaluation'
+);
+
+for (let f of [0]) {
+//- after
+}
+
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created following evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created following evaluation'
+);

src/annex-b-fns/eval-func-skip-early-err-for.case

@@ -0,0 +1,40 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+desc: >
+  Extension not observed when creation of variable binding would produce an
+  early error (for statement)
+template: eval-func
+info: |
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+---*/
+
+//- before
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created prior to evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created prior to evaluation'
+);
+
+for (let f; ; ) {
+//- after
+  break;
+}
+
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created following evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created following evaluation'
+);

src/annex-b-fns/eval-func-skip-early-err-switch.case

@@ -0,0 +1,41 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+desc: >
+  Extension not observed when creation of variable binding would produce an
+  early error (switch statement)
+template: eval-func
+info: |
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+---*/
+
+//- before
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created prior to evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created prior to evaluation'
+);
+
+switch (0) {
+  default:
+    let f;
+//- after
+}
+
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created following evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created following evaluation'
+);

src/annex-b-fns/eval-func-skip-early-err-try.case

@@ -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.
+/*---
+desc: >
+  Extension is not observed when creation of variable binding would produce an
+  early error (try statement)
+template: eval-func
+info: |
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+
+    B.3.5 VariableStatements in Catch Blocks
+
+    [...]
+    - It is a Syntax Error if any element of the BoundNames of CatchParameter
+      also occurs in the VarDeclaredNames of Block unless CatchParameter is
+      CatchParameter:BindingIdentifier and that element is only bound by a
+      VariableStatement, the VariableDeclarationList of a for statement, or the
+      ForBinding of a for-in statement.
+---*/
+
+//- before
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created prior to evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created prior to evaluation'
+);
+
+try {
+  throw {};
+} catch ({ f }) {
+//- after
+}
+
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created following evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created following evaluation'
+);

src/annex-b-fns/eval-global-no-skip-try.case

@@ -0,0 +1,45 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+desc: >
+  Extension is observed when creation of variable binding would not produce an
+  early error (try statement)
+template: eval-global
+info: |
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+
+    B.3.5 VariableStatements in Catch Blocks
+
+    [...]
+    - It is a Syntax Error if any element of the BoundNames of CatchParameter
+      also occurs in the VarDeclaredNames of Block unless CatchParameter is
+      CatchParameter:BindingIdentifier and that element is only bound by a
+      VariableStatement, the VariableDeclarationList of a for statement, or the
+      ForBinding of a for-in statement.
+---*/
+
+//- before
+assert.sameValue(
+  f, undefined, 'Initialized binding created prior to evaluation'
+);
+
+try {
+  throw null;
+} catch (f) {
+//- body
+return 123;
+//- after
+}
+
+assert.sameValue(
+  typeof f,
+  'function',
+  'binding value is updated following evaluation'
+);
+assert.sameValue(f(), 123);

src/annex-b-fns/eval-global-skip-early-err-block.case

@@ -0,0 +1,40 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+desc: >
+  Extension not observed when creation of variable binding would produce an
+  early error (Block statement)
+template: eval-global
+info: |
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+---*/
+
+//- setup
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created prior to evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created prior to evaluation'
+);
+//- before
+{
+let f = 123;
+//- after
+}
+//- teardown
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created following evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created following evaluation'
+);

src/annex-b-fns/eval-global-skip-early-err-for-in.case

@@ -0,0 +1,39 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+desc: >
+  Extension not observed when creation of variable binding would produce an
+  early error (for-of statement)
+template: eval-global
+info: |
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+---*/
+
+//- setup
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created prior to evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created prior to evaluation'
+);
+//- before
+for (let f in { key: 0 }) {
+//- after
+}
+//- teardown
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created following evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created following evaluation'
+);

src/annex-b-fns/eval-global-skip-early-err-for-of.case

@@ -0,0 +1,39 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+desc: >
+  Extension not observed when creation of variable binding would produce an
+  early error (for-of statement)
+template: eval-global
+info: |
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+---*/
+
+//- setup
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created prior to evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created prior to evaluation'
+);
+//- before
+for (let f of [0]) {
+//- after
+}
+//- teardown
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created following evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created following evaluation'
+);

src/annex-b-fns/eval-global-skip-early-err-for.case

@@ -0,0 +1,40 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+desc: >
+  Extension not observed when creation of variable binding would produce an
+  early error (for statement)
+template: eval-global
+info: |
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+---*/
+
+//- setup
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created prior to evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created prior to evaluation'
+);
+//- before
+for (let f; ; ) {
+//- after
+  break;
+}
+//- teardown
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created following evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created following evaluation'
+);

src/annex-b-fns/eval-global-skip-early-err-switch.case

@@ -0,0 +1,41 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+desc: >
+  Extension not observed when creation of variable binding would produce an
+  early error (switch statement)
+template: eval-global
+info: |
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+---*/
+
+//- setup
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created prior to evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created prior to evaluation'
+);
+//- before
+switch (0) {
+  default:
+    let f;
+//- after
+}
+//- teardown
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created following evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created following evaluation'
+);

src/annex-b-fns/eval-global-skip-early-err-try.case

@@ -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.
+/*---
+desc: >
+  Extension is not observed when creation of variable binding would produce an
+  early error (try statement)
+template: eval-global
+info: |
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+
+    B.3.5 VariableStatements in Catch Blocks
+
+    [...]
+    - It is a Syntax Error if any element of the BoundNames of CatchParameter
+      also occurs in the VarDeclaredNames of Block unless CatchParameter is
+      CatchParameter:BindingIdentifier and that element is only bound by a
+      VariableStatement, the VariableDeclarationList of a for statement, or the
+      ForBinding of a for-in statement.
+---*/
+
+//- before
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created prior to evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created prior to evaluation'
+);
+
+try {
+  throw {};
+} catch ({ f }) {
+//- after
+}
+
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created following evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created following evaluation'
+);

src/annex-b-fns/func-no-skip-try.case

@@ -0,0 +1,46 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+desc: >
+  Extension is observed when creation of variable binding would not produce an
+  early error (try statement)
+template: func
+info: |
+    B.3.3.1 Changes to FunctionDeclarationInstantiation
+
+    [...]
+    2. If instantiatedVarNames does not contain F, then
+       a. Perform ! varEnvRec.CreateMutableBinding(F, false).
+       b. Perform varEnvRec.InitializeBinding(F, undefined).
+       c. Append F to instantiatedVarNames.
+    [...]
+
+    B.3.5 VariableStatements in Catch Blocks
+
+    [...]
+    - It is a Syntax Error if any element of the BoundNames of CatchParameter
+      also occurs in the VarDeclaredNames of Block unless CatchParameter is
+      CatchParameter:BindingIdentifier and that element is only bound by a
+      VariableStatement, the VariableDeclarationList of a for statement, or the
+      ForBinding of a for-in statement.
+---*/
+
+//- before
+assert.sameValue(
+  f, undefined, 'Initialized binding created prior to evaluation'
+);
+
+try {
+  throw null;
+} catch (f) {
+//- body
+return 123;
+//- after
+}
+
+assert.sameValue(
+  typeof f,
+  'function',
+  'binding value is updated following evaluation'
+);
+assert.sameValue(f(), 123);

src/annex-b-fns/func-skip-early-err-block.case

@@ -0,0 +1,40 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+desc: >
+  Extension not observed when creation of variable binding would produce an
+  early error (Block statement)
+template: func
+info: |
+    B.3.3.1 Changes to FunctionDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        func and F is not an element of BoundNames of argumentsList, then
+    [...]
+---*/
+
+//- before
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created prior to evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created prior to evaluation'
+);
+
+{
+let f = 123;
+//- after
+}
+
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created following evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created following evaluation'
+);

src/annex-b-fns/func-skip-early-err-for-in.case

@@ -0,0 +1,39 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+desc: >
+  Extension not observed when creation of variable binding would produce an
+  early error (for-of statement)
+template: func
+info: |
+    B.3.3.1 Changes to FunctionDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        func and F is not an element of BoundNames of argumentsList, then
+    [...]
+---*/
+
+//- before
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created prior to evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created prior to evaluation'
+);
+
+for (let f in { key: 0 }) {
+//- after
+}
+
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created following evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created following evaluation'
+);

src/annex-b-fns/func-skip-early-err-for-of.case

@@ -0,0 +1,39 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+desc: >
+  Extension not observed when creation of variable binding would produce an
+  early error (for-of statement)
+template: func
+info: |
+    B.3.3.1 Changes to FunctionDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        func and F is not an element of BoundNames of argumentsList, then
+    [...]
+---*/
+
+//- before
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created prior to evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created prior to evaluation'
+);
+
+for (let f of [0]) {
+//- after
+}
+
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created following evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created following evaluation'
+);

src/annex-b-fns/func-skip-early-err-for.case

@@ -0,0 +1,40 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+desc: >
+  Extension not observed when creation of variable binding would produce an
+  early error (for statement)
+template: func
+info: |
+    B.3.3.1 Changes to FunctionDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        func and F is not an element of BoundNames of argumentsList, then
+    [...]
+---*/
+
+//- before
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created prior to evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created prior to evaluation'
+);
+
+for (let f; ; ) {
+//- after
+  break;
+}
+
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created following evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created following evaluation'
+);

src/annex-b-fns/func-skip-early-err-switch.case

@@ -0,0 +1,41 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+desc: >
+  Extension not observed when creation of variable binding would produce an
+  early error (switch statement)
+template: func
+info: |
+    B.3.3.1 Changes to FunctionDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        func and F is not an element of BoundNames of argumentsList, then
+    [...]
+---*/
+
+//- before
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created prior to evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created prior to evaluation'
+);
+
+switch (0) {
+  default:
+    let f;
+//- after
+}
+
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created following evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created following evaluation'
+);

src/annex-b-fns/func-skip-early-err-try.case

@@ -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.
+/*---
+desc: >
+  Extension is observed when creation of variable binding would not produce an
+  early error (try statement)
+template: func
+info: |
+    B.3.3.1 Changes to FunctionDeclarationInstantiation
+
+    [...]
+    2. If instantiatedVarNames does not contain F, then
+       a. Perform ! varEnvRec.CreateMutableBinding(F, false).
+       b. Perform varEnvRec.InitializeBinding(F, undefined).
+       c. Append F to instantiatedVarNames.
+    [...]
+
+    B.3.5 VariableStatements in Catch Blocks
+
+    [...]
+    - It is a Syntax Error if any element of the BoundNames of CatchParameter
+      also occurs in the VarDeclaredNames of Block unless CatchParameter is
+      CatchParameter:BindingIdentifier and that element is only bound by a
+      VariableStatement, the VariableDeclarationList of a for statement, or the
+      ForBinding of a for-in statement.
+---*/
+
+//- before
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created prior to evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created prior to evaluation'
+);
+
+try {
+  throw {};
+} catch ({ f }) {
+//- after
+}
+
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created following evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created following evaluation'
+);

src/annex-b-fns/global-no-skip-try.case

@@ -0,0 +1,45 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+desc: >
+  Extension is observed when creation of variable binding would not produce an
+  early error (try statement)
+template: global
+info: |
+    B.3.3.2 Changes to GlobalDeclarationInstantiation
+
+    [...]
+    b. If replacing the FunctionDeclaration f with a VariableStatement that has
+       F as a BindingIdentifier would not produce any Early Errors for script,
+       then
+    [...]
+
+    B.3.5 VariableStatements in Catch Blocks
+
+    [...]
+    - It is a Syntax Error if any element of the BoundNames of CatchParameter
+      also occurs in the VarDeclaredNames of Block unless CatchParameter is
+      CatchParameter:BindingIdentifier and that element is only bound by a
+      VariableStatement, the VariableDeclarationList of a for statement, or the
+      ForBinding of a for-in statement.
+---*/
+
+//- setup
+assert.sameValue(
+  f, undefined, 'Initialized binding created prior to evaluation'
+);
+
+try {
+  throw null;
+} catch (f) {
+//- body
+return 123;
+//- teardown
+}
+
+assert.sameValue(
+  typeof f,
+  'function',
+  'binding value is updated following evaluation'
+);
+assert.sameValue(f(), 123);

src/annex-b-fns/global-skip-early-err-block.case

@@ -0,0 +1,40 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+desc: >
+  Extension not observed when creation of variable binding would produce an
+  early error (Block statement)
+template: global
+info: |
+    B.3.3.2 Changes to GlobalDeclarationInstantiation
+
+    [...]
+    b. If replacing the FunctionDeclaration f with a VariableStatement that has
+       F as a BindingIdentifier would not produce any Early Errors for script,
+       then
+    [...]
+---*/
+
+//- setup
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created prior to evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created prior to evaluation'
+);
+
+{
+let f = 123;
+//- teardown
+}
+
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created following evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created following evaluation'
+);

src/annex-b-fns/global-skip-early-err-for-in.case

@@ -0,0 +1,39 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+desc: >
+  Extension not observed when creation of variable binding would produce an
+  early error (for-of statement)
+template: global
+info: |
+    B.3.3.2 Changes to GlobalDeclarationInstantiation
+
+    [...]
+    b. If replacing the FunctionDeclaration f with a VariableStatement that has
+       F as a BindingIdentifier would not produce any Early Errors for script,
+       then
+    [...]
+---*/
+
+//- setup
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created prior to evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created prior to evaluation'
+);
+
+for (let f in { key: 0 }) {
+//- teardown
+}
+
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created following evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created following evaluation'
+);

src/annex-b-fns/global-skip-early-err-for-of.case

@@ -0,0 +1,39 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+desc: >
+  Extension not observed when creation of variable binding would produce an
+  early error (for-of statement)
+template: global
+info: |
+    B.3.3.2 Changes to GlobalDeclarationInstantiation
+
+    [...]
+    b. If replacing the FunctionDeclaration f with a VariableStatement that has
+       F as a BindingIdentifier would not produce any Early Errors for script,
+       then
+    [...]
+---*/
+
+//- setup
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created prior to evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created prior to evaluation'
+);
+
+for (let f of [0]) {
+//- teardown
+}
+
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created following evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created following evaluation'
+);

src/annex-b-fns/global-skip-early-err-for.case

@@ -0,0 +1,40 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+desc: >
+  Extension not observed when creation of variable binding would produce an
+  early error (for statement)
+template: global
+info: |
+    B.3.3.2 Changes to GlobalDeclarationInstantiation
+
+    [...]
+    b. If replacing the FunctionDeclaration f with a VariableStatement that has
+       F as a BindingIdentifier would not produce any Early Errors for script,
+       then
+    [...]
+---*/
+
+//- setup
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created prior to evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created prior to evaluation'
+);
+
+for (let f; ; ) {
+//- teardown
+  break;
+}
+
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created following evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created following evaluation'
+);

src/annex-b-fns/global-skip-early-err-switch.case

@@ -0,0 +1,41 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+desc: >
+  Extension not observed when creation of variable binding would produce an
+  early error (switch statement)
+template: global
+info: |
+    B.3.3.2 Changes to GlobalDeclarationInstantiation
+
+    [...]
+    b. If replacing the FunctionDeclaration f with a VariableStatement that has
+       F as a BindingIdentifier would not produce any Early Errors for script,
+       then
+    [...]
+---*/
+
+//- setup
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created prior to evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created prior to evaluation'
+);
+
+switch (0) {
+  default:
+    let f;
+//- teardown
+}
+
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created following evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created following evaluation'
+);

src/annex-b-fns/global-skip-early-err-try.case

@@ -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.
+/*---
+desc: >
+  Extension is observed when creation of variable binding would not produce an
+  early error (try statement)
+template: global
+info: |
+    B.3.3.2 Changes to GlobalDeclarationInstantiation
+
+    [...]
+    b. If replacing the FunctionDeclaration f with a VariableStatement that has
+       F as a BindingIdentifier would not produce any Early Errors for script,
+       then
+    [...]
+
+    B.3.5 VariableStatements in Catch Blocks
+
+    [...]
+    - It is a Syntax Error if any element of the BoundNames of CatchParameter
+      also occurs in the VarDeclaredNames of Block unless CatchParameter is
+      CatchParameter:BindingIdentifier and that element is only bound by a
+      VariableStatement, the VariableDeclarationList of a for statement, or the
+      ForBinding of a for-in statement.
+---*/
+
+//- setup
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created prior to evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created prior to evaluation'
+);
+
+try {
+  throw {};
+} catch ({ f }) {
+//- teardown
+}
+
+assert.throws(ReferenceError, function() {
+  f;
+}, 'An initialized binding is not created following evaluation');
+assert.sameValue(
+  typeof f,
+  'undefined',
+  'An uninitialized binding is not created following evaluation'
+);

test/annexB/language/eval-code/direct/func-block-decl-eval-func-block-scoping.js

@@ -6,9 +6,9 @@ description: A block-scoped binding is created (Block statement in eval code con
 esid: sec-web-compat-evaldeclarationinstantiation
 es6id: B.3.3.3
 flags: [generated, noStrict]
-info: >
+info: |
     13.2.14 Runtime Semantics: BlockDeclarationInstantiation
-    
+
     [...]
     4. For each element d in declarations do
        a. For each element dn of the BoundNames of d do
@@ -16,7 +16,7 @@ info: >
              [...]
           ii. Else,
               2. Perform ! envRec.CreateMutableBinding(dn, false).
-    
+
        b. If d is a GeneratorDeclaration production or a FunctionDeclaration
           production, then
           i. Let fn be the sole element of the BoundNames of d.

test/annexB/language/eval-code/direct/func-block-decl-eval-func-exsting-block-fn-no-init.js

@@ -6,9 +6,9 @@ description: Does not re-initialize binding created by similar forms (Block stat
 esid: sec-web-compat-evaldeclarationinstantiation
 es6id: B.3.3.3
 flags: [generated, noStrict]
-info: >
+info: |
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     a. If declaredFunctionOrVarNames does not contain F, then
     [...]

test/annexB/language/eval-code/direct/func-block-decl-eval-func-exsting-block-fn-update.js

@@ -6,9 +6,9 @@ description: Variable-scoped binding is updated (Block statement in eval code co
 esid: sec-web-compat-evaldeclarationinstantiation
 es6id: B.3.3.3
 flags: [generated, noStrict]
-info: >
+info: |
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     b. When the FunctionDeclaration f is evaluated, perform the following steps
        in place of the FunctionDeclaration Evaluation algorithm provided in

test/annexB/language/eval-code/direct/func-block-decl-eval-func-exsting-fn-no-init.js

@@ -6,9 +6,9 @@ description: Existing variable binding is not modified (Block statement in eval
 esid: sec-web-compat-evaldeclarationinstantiation
 es6id: B.3.3.3
 flags: [generated, noStrict]
-info: >
+info: |
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     b. When the FunctionDeclaration f is evaluated, perform the following steps
        in place of the FunctionDeclaration Evaluation algorithm provided in

test/annexB/language/eval-code/direct/func-block-decl-eval-func-exsting-fn-update.js

@@ -6,9 +6,9 @@ description: Variable-scoped binding is updated following evaluation (Block stat
 esid: sec-web-compat-evaldeclarationinstantiation
 es6id: B.3.3.3
 flags: [generated, noStrict]
-info: >
+info: |
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     b. When the FunctionDeclaration f is evaluated, perform the following steps
        in place of the FunctionDeclaration Evaluation algorithm provided in

test/annexB/language/eval-code/direct/func-block-decl-eval-func-exsting-var-no-init.js

@@ -6,9 +6,9 @@ description: Existing variable binding is not modified (Block statement in eval
 esid: sec-web-compat-evaldeclarationinstantiation
 es6id: B.3.3.3
 flags: [generated, noStrict]
-info: >
+info: |
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     a. If declaredFunctionOrVarNames does not contain F, then
     [...]

test/annexB/language/eval-code/direct/func-block-decl-eval-func-exsting-var-update.js

@@ -6,9 +6,9 @@ description: Variable-scoped binding is updated following evaluation (Block stat
 esid: sec-web-compat-evaldeclarationinstantiation
 es6id: B.3.3.3
 flags: [generated, noStrict]
-info: >
+info: |
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     b. When the FunctionDeclaration f is evaluated, perform the following steps
        in place of the FunctionDeclaration Evaluation algorithm provided in

test/annexB/language/eval-code/direct/func-block-decl-eval-func-init.js

@@ -6,9 +6,9 @@ description: Variable binding is initialized to `undefined` in outer scope (Bloc
 esid: sec-web-compat-evaldeclarationinstantiation
 es6id: B.3.3.3
 flags: [generated, noStrict]
-info: >
+info: |
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     a. If declaredFunctionOrVarNames does not contain F, then
        i. If varEnvRec is a global Environment Record, then

test/annexB/language/eval-code/direct/func-block-decl-eval-func-no-skip-param.js

@@ -6,9 +6,9 @@ description: Extension observed when there is a formal parameter with the same n
 esid: sec-web-compat-evaldeclarationinstantiation
 es6id: B.3.3.3
 flags: [generated, noStrict]
-info: >
+info: |
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     ii. If replacing the FunctionDeclaration f with a VariableStatement that
         has F as a BindingIdentifier would not produce any Early Errors for

test/annexB/language/eval-code/direct/func-block-decl-eval-func-no-skip-try.js

@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/annex-b-fns/eval-func-no-skip-try.case
+// - src/annex-b-fns/eval-func/direct-block.template
+/*---
+description: Extension is observed when creation of variable binding would not produce an early error (try statement) (Block statement in eval code containing a function declaration)
+esid: sec-web-compat-evaldeclarationinstantiation
+es6id: B.3.3.3
+flags: [generated, noStrict]
+info: |
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+
+    B.3.5 VariableStatements in Catch Blocks
+
+    [...]
+    - It is a Syntax Error if any element of the BoundNames of CatchParameter
+      also occurs in the VarDeclaredNames of Block unless CatchParameter is
+      CatchParameter:BindingIdentifier and that element is only bound by a
+      VariableStatement, the VariableDeclarationList of a for statement, or the
+      ForBinding of a for-in statement.
+---*/
+
+(function() {
+  eval(
+    'assert.sameValue(\
+      f, undefined, "Initialized binding created prior to evaluation"\
+    );\
+    \
+    try {\
+      throw null;\
+    } catch (f) {{ function f() { return 123; } }}\
+    \
+    assert.sameValue(\
+      typeof f,\
+      "function",\
+      "binding value is updated following evaluation"\
+    );\
+    assert.sameValue(f(), 123);'
+  );
+}());

test/annexB/language/eval-code/direct/func-block-decl-eval-func-skip-early-err-block.js

@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/annex-b-fns/eval-func-skip-early-err-block.case
+// - src/annex-b-fns/eval-func/direct-block.template
+/*---
+description: Extension not observed when creation of variable binding would produce an early error (Block statement) (Block statement in eval code containing a function declaration)
+esid: sec-web-compat-evaldeclarationinstantiation
+es6id: B.3.3.3
+flags: [generated, noStrict]
+info: |
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+---*/
+
+(function() {
+  eval(
+    'assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created prior to evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created prior to evaluation"\
+    );\
+    \
+    {\
+    let f = 123;{ function f() {  } }}\
+    \
+    assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created following evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created following evaluation"\
+    );'
+  );
+}());

test/annexB/language/eval-code/direct/func-block-decl-eval-func-skip-early-err-for-in.js

@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/annex-b-fns/eval-func-skip-early-err-for-in.case
+// - src/annex-b-fns/eval-func/direct-block.template
+/*---
+description: Extension not observed when creation of variable binding would produce an early error (for-of statement) (Block statement in eval code containing a function declaration)
+esid: sec-web-compat-evaldeclarationinstantiation
+es6id: B.3.3.3
+flags: [generated, noStrict]
+info: |
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+---*/
+
+(function() {
+  eval(
+    'assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created prior to evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created prior to evaluation"\
+    );\
+    \
+    for (let f in { key: 0 }) {{ function f() {  } }}\
+    \
+    assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created following evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created following evaluation"\
+    );'
+  );
+}());

test/annexB/language/eval-code/direct/func-block-decl-eval-func-skip-early-err-for-of.js

@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/annex-b-fns/eval-func-skip-early-err-for-of.case
+// - src/annex-b-fns/eval-func/direct-block.template
+/*---
+description: Extension not observed when creation of variable binding would produce an early error (for-of statement) (Block statement in eval code containing a function declaration)
+esid: sec-web-compat-evaldeclarationinstantiation
+es6id: B.3.3.3
+flags: [generated, noStrict]
+info: |
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+---*/
+
+(function() {
+  eval(
+    'assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created prior to evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created prior to evaluation"\
+    );\
+    \
+    for (let f of [0]) {{ function f() {  } }}\
+    \
+    assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created following evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created following evaluation"\
+    );'
+  );
+}());

test/annexB/language/eval-code/direct/func-block-decl-eval-func-skip-early-err-for.js

@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/annex-b-fns/eval-func-skip-early-err-for.case
+// - src/annex-b-fns/eval-func/direct-block.template
+/*---
+description: Extension not observed when creation of variable binding would produce an early error (for statement) (Block statement in eval code containing a function declaration)
+esid: sec-web-compat-evaldeclarationinstantiation
+es6id: B.3.3.3
+flags: [generated, noStrict]
+info: |
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+---*/
+
+(function() {
+  eval(
+    'assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created prior to evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created prior to evaluation"\
+    );\
+    \
+    for (let f; ; ) {{ function f() {  } }break;\
+    }\
+    \
+    assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created following evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created following evaluation"\
+    );'
+  );
+}());

test/annexB/language/eval-code/direct/func-block-decl-eval-func-skip-early-err-switch.js

@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/annex-b-fns/eval-func-skip-early-err-switch.case
+// - src/annex-b-fns/eval-func/direct-block.template
+/*---
+description: Extension not observed when creation of variable binding would produce an early error (switch statement) (Block statement in eval code containing a function declaration)
+esid: sec-web-compat-evaldeclarationinstantiation
+es6id: B.3.3.3
+flags: [generated, noStrict]
+info: |
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+---*/
+
+(function() {
+  eval(
+    'assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created prior to evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created prior to evaluation"\
+    );\
+    \
+    switch (0) {\
+      default:\
+        let f;{ function f() {  } }}\
+    \
+    assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created following evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created following evaluation"\
+    );'
+  );
+}());

test/annexB/language/eval-code/direct/func-block-decl-eval-func-skip-early-err-try.js

@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/annex-b-fns/eval-func-skip-early-err-try.case
+// - src/annex-b-fns/eval-func/direct-block.template
+/*---
+description: Extension is not observed when creation of variable binding would produce an early error (try statement) (Block statement in eval code containing a function declaration)
+esid: sec-web-compat-evaldeclarationinstantiation
+es6id: B.3.3.3
+flags: [generated, noStrict]
+info: |
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+
+    B.3.5 VariableStatements in Catch Blocks
+
+    [...]
+    - It is a Syntax Error if any element of the BoundNames of CatchParameter
+      also occurs in the VarDeclaredNames of Block unless CatchParameter is
+      CatchParameter:BindingIdentifier and that element is only bound by a
+      VariableStatement, the VariableDeclarationList of a for statement, or the
+      ForBinding of a for-in statement.
+---*/
+
+(function() {
+  eval(
+    'assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created prior to evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created prior to evaluation"\
+    );\
+    \
+    try {\
+      throw {};\
+    } catch ({ f }) {{ function f() {  } }}\
+    \
+    assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created following evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created following evaluation"\
+    );'
+  );
+}());

test/annexB/language/eval-code/direct/func-block-decl-eval-func-skip-early-err.js

@@ -6,9 +6,9 @@ description: Extension not observed when creation of variable binding would prod
 esid: sec-web-compat-evaldeclarationinstantiation
 es6id: B.3.3.3
 flags: [generated, noStrict]
-info: >
+info: |
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     ii. If replacing the FunctionDeclaration f with a VariableStatement that
         has F as a BindingIdentifier would not produce any Early Errors for

test/annexB/language/eval-code/direct/func-block-decl-eval-func-update.js

@@ -6,9 +6,9 @@ description: Variable binding value is updated following evaluation (Block state
 esid: sec-web-compat-evaldeclarationinstantiation
 es6id: B.3.3.3
 flags: [generated, noStrict]
-info: >
+info: |
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     b. When the FunctionDeclaration f is evaluated, perform the following steps
        in place of the FunctionDeclaration Evaluation algorithm provided in

test/annexB/language/eval-code/direct/func-if-decl-else-decl-a-eval-func-block-scoping.js

@@ -6,18 +6,18 @@ description: A block-scoped binding is created (IfStatement with a declaration i
 esid: sec-functiondeclarations-in-ifstatement-statement-clauses
 es6id: B.3.4
 flags: [generated, noStrict]
-info: >
+info: |
     The following rules for IfStatement augment those in 13.6:
-    
+
     IfStatement[Yield, Return]:
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
         if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
-    
+
 
     13.2.14 Runtime Semantics: BlockDeclarationInstantiation
-    
+
     [...]
     4. For each element d in declarations do
        a. For each element dn of the BoundNames of d do
@@ -25,7 +25,7 @@ info: >
              [...]
           ii. Else,
               2. Perform ! envRec.CreateMutableBinding(dn, false).
-    
+
        b. If d is a GeneratorDeclaration production or a FunctionDeclaration
           production, then
           i. Let fn be the sole element of the BoundNames of d.

test/annexB/language/eval-code/direct/func-if-decl-else-decl-a-eval-func-exsting-block-fn-no-init.js

@@ -6,18 +6,18 @@ description: Does not re-initialize binding created by similar forms (IfStatemen
 esid: sec-functiondeclarations-in-ifstatement-statement-clauses
 es6id: B.3.4
 flags: [generated, noStrict]
-info: >
+info: |
     The following rules for IfStatement augment those in 13.6:
-    
+
     IfStatement[Yield, Return]:
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
         if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
-    
+
 
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     a. If declaredFunctionOrVarNames does not contain F, then
     [...]

test/annexB/language/eval-code/direct/func-if-decl-else-decl-a-eval-func-exsting-block-fn-update.js

@@ -6,18 +6,18 @@ description: Variable-scoped binding is updated (IfStatement with a declaration
 esid: sec-functiondeclarations-in-ifstatement-statement-clauses
 es6id: B.3.4
 flags: [generated, noStrict]
-info: >
+info: |
     The following rules for IfStatement augment those in 13.6:
-    
+
     IfStatement[Yield, Return]:
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
         if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
-    
+
 
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     b. When the FunctionDeclaration f is evaluated, perform the following steps
        in place of the FunctionDeclaration Evaluation algorithm provided in

test/annexB/language/eval-code/direct/func-if-decl-else-decl-a-eval-func-exsting-fn-no-init.js

@@ -6,18 +6,18 @@ description: Existing variable binding is not modified (IfStatement with a decla
 esid: sec-functiondeclarations-in-ifstatement-statement-clauses
 es6id: B.3.4
 flags: [generated, noStrict]
-info: >
+info: |
     The following rules for IfStatement augment those in 13.6:
-    
+
     IfStatement[Yield, Return]:
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
         if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
-    
+
 
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     b. When the FunctionDeclaration f is evaluated, perform the following steps
        in place of the FunctionDeclaration Evaluation algorithm provided in

test/annexB/language/eval-code/direct/func-if-decl-else-decl-a-eval-func-exsting-fn-update.js

@@ -6,18 +6,18 @@ description: Variable-scoped binding is updated following evaluation (IfStatemen
 esid: sec-functiondeclarations-in-ifstatement-statement-clauses
 es6id: B.3.4
 flags: [generated, noStrict]
-info: >
+info: |
     The following rules for IfStatement augment those in 13.6:
-    
+
     IfStatement[Yield, Return]:
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
         if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
-    
+
 
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     b. When the FunctionDeclaration f is evaluated, perform the following steps
        in place of the FunctionDeclaration Evaluation algorithm provided in

test/annexB/language/eval-code/direct/func-if-decl-else-decl-a-eval-func-exsting-var-no-init.js

@@ -6,18 +6,18 @@ description: Existing variable binding is not modified (IfStatement with a decla
 esid: sec-functiondeclarations-in-ifstatement-statement-clauses
 es6id: B.3.4
 flags: [generated, noStrict]
-info: >
+info: |
     The following rules for IfStatement augment those in 13.6:
-    
+
     IfStatement[Yield, Return]:
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
         if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
-    
+
 
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     a. If declaredFunctionOrVarNames does not contain F, then
     [...]

test/annexB/language/eval-code/direct/func-if-decl-else-decl-a-eval-func-exsting-var-update.js

@@ -6,18 +6,18 @@ description: Variable-scoped binding is updated following evaluation (IfStatemen
 esid: sec-functiondeclarations-in-ifstatement-statement-clauses
 es6id: B.3.4
 flags: [generated, noStrict]
-info: >
+info: |
     The following rules for IfStatement augment those in 13.6:
-    
+
     IfStatement[Yield, Return]:
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
         if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
-    
+
 
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     b. When the FunctionDeclaration f is evaluated, perform the following steps
        in place of the FunctionDeclaration Evaluation algorithm provided in

test/annexB/language/eval-code/direct/func-if-decl-else-decl-a-eval-func-init.js

@@ -6,18 +6,18 @@ description: Variable binding is initialized to `undefined` in outer scope (IfSt
 esid: sec-functiondeclarations-in-ifstatement-statement-clauses
 es6id: B.3.4
 flags: [generated, noStrict]
-info: >
+info: |
     The following rules for IfStatement augment those in 13.6:
-    
+
     IfStatement[Yield, Return]:
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
         if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
-    
+
 
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     a. If declaredFunctionOrVarNames does not contain F, then
        i. If varEnvRec is a global Environment Record, then

test/annexB/language/eval-code/direct/func-if-decl-else-decl-a-eval-func-no-skip-param.js

@@ -6,18 +6,18 @@ description: Extension observed when there is a formal parameter with the same n
 esid: sec-functiondeclarations-in-ifstatement-statement-clauses
 es6id: B.3.4
 flags: [generated, noStrict]
-info: >
+info: |
     The following rules for IfStatement augment those in 13.6:
-    
+
     IfStatement[Yield, Return]:
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
         if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
-    
+
 
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     ii. If replacing the FunctionDeclaration f with a VariableStatement that
         has F as a BindingIdentifier would not produce any Early Errors for

test/annexB/language/eval-code/direct/func-if-decl-else-decl-a-eval-func-no-skip-try.js

@@ -0,0 +1,54 @@
+// This file was procedurally generated from the following sources:
+// - src/annex-b-fns/eval-func-no-skip-try.case
+// - src/annex-b-fns/eval-func/direct-if-decl-else-decl-a.template
+/*---
+description: Extension is observed when creation of variable binding would not produce an early error (try statement) (IfStatement with a declaration in both statement positions in eval code)
+esid: sec-functiondeclarations-in-ifstatement-statement-clauses
+es6id: B.3.4
+flags: [generated, noStrict]
+info: |
+    The following rules for IfStatement augment those in 13.6:
+
+    IfStatement[Yield, Return]:
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
+        if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
+
+
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+
+    B.3.5 VariableStatements in Catch Blocks
+
+    [...]
+    - It is a Syntax Error if any element of the BoundNames of CatchParameter
+      also occurs in the VarDeclaredNames of Block unless CatchParameter is
+      CatchParameter:BindingIdentifier and that element is only bound by a
+      VariableStatement, the VariableDeclarationList of a for statement, or the
+      ForBinding of a for-in statement.
+---*/
+
+(function() {
+  eval(
+    'assert.sameValue(\
+      f, undefined, "Initialized binding created prior to evaluation"\
+    );\
+    \
+    try {\
+      throw null;\
+    } catch (f) {if (true) function f() { return 123; } else function _f() {}}\
+    \
+    assert.sameValue(\
+      typeof f,\
+      "function",\
+      "binding value is updated following evaluation"\
+    );\
+    assert.sameValue(f(), 123);'
+  );
+}());

test/annexB/language/eval-code/direct/func-if-decl-else-decl-a-eval-func-skip-early-err-block.js

@@ -0,0 +1,51 @@
+// This file was procedurally generated from the following sources:
+// - src/annex-b-fns/eval-func-skip-early-err-block.case
+// - src/annex-b-fns/eval-func/direct-if-decl-else-decl-a.template
+/*---
+description: Extension not observed when creation of variable binding would produce an early error (Block statement) (IfStatement with a declaration in both statement positions in eval code)
+esid: sec-functiondeclarations-in-ifstatement-statement-clauses
+es6id: B.3.4
+flags: [generated, noStrict]
+info: |
+    The following rules for IfStatement augment those in 13.6:
+
+    IfStatement[Yield, Return]:
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
+        if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
+
+
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+---*/
+
+(function() {
+  eval(
+    'assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created prior to evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created prior to evaluation"\
+    );\
+    \
+    {\
+    let f = 123;if (true) function f() {  } else function _f() {}}\
+    \
+    assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created following evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created following evaluation"\
+    );'
+  );
+}());

test/annexB/language/eval-code/direct/func-if-decl-else-decl-a-eval-func-skip-early-err-for-in.js

@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/annex-b-fns/eval-func-skip-early-err-for-in.case
+// - src/annex-b-fns/eval-func/direct-if-decl-else-decl-a.template
+/*---
+description: Extension not observed when creation of variable binding would produce an early error (for-of statement) (IfStatement with a declaration in both statement positions in eval code)
+esid: sec-functiondeclarations-in-ifstatement-statement-clauses
+es6id: B.3.4
+flags: [generated, noStrict]
+info: |
+    The following rules for IfStatement augment those in 13.6:
+
+    IfStatement[Yield, Return]:
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
+        if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
+
+
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+---*/
+
+(function() {
+  eval(
+    'assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created prior to evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created prior to evaluation"\
+    );\
+    \
+    for (let f in { key: 0 }) {if (true) function f() {  } else function _f() {}}\
+    \
+    assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created following evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created following evaluation"\
+    );'
+  );
+}());

test/annexB/language/eval-code/direct/func-if-decl-else-decl-a-eval-func-skip-early-err-for-of.js

@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/annex-b-fns/eval-func-skip-early-err-for-of.case
+// - src/annex-b-fns/eval-func/direct-if-decl-else-decl-a.template
+/*---
+description: Extension not observed when creation of variable binding would produce an early error (for-of statement) (IfStatement with a declaration in both statement positions in eval code)
+esid: sec-functiondeclarations-in-ifstatement-statement-clauses
+es6id: B.3.4
+flags: [generated, noStrict]
+info: |
+    The following rules for IfStatement augment those in 13.6:
+
+    IfStatement[Yield, Return]:
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
+        if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
+
+
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+---*/
+
+(function() {
+  eval(
+    'assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created prior to evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created prior to evaluation"\
+    );\
+    \
+    for (let f of [0]) {if (true) function f() {  } else function _f() {}}\
+    \
+    assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created following evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created following evaluation"\
+    );'
+  );
+}());

test/annexB/language/eval-code/direct/func-if-decl-else-decl-a-eval-func-skip-early-err-for.js

@@ -0,0 +1,51 @@
+// This file was procedurally generated from the following sources:
+// - src/annex-b-fns/eval-func-skip-early-err-for.case
+// - src/annex-b-fns/eval-func/direct-if-decl-else-decl-a.template
+/*---
+description: Extension not observed when creation of variable binding would produce an early error (for statement) (IfStatement with a declaration in both statement positions in eval code)
+esid: sec-functiondeclarations-in-ifstatement-statement-clauses
+es6id: B.3.4
+flags: [generated, noStrict]
+info: |
+    The following rules for IfStatement augment those in 13.6:
+
+    IfStatement[Yield, Return]:
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
+        if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
+
+
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+---*/
+
+(function() {
+  eval(
+    'assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created prior to evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created prior to evaluation"\
+    );\
+    \
+    for (let f; ; ) {if (true) function f() {  } else function _f() {}break;\
+    }\
+    \
+    assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created following evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created following evaluation"\
+    );'
+  );
+}());

test/annexB/language/eval-code/direct/func-if-decl-else-decl-a-eval-func-skip-early-err-switch.js

@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/annex-b-fns/eval-func-skip-early-err-switch.case
+// - src/annex-b-fns/eval-func/direct-if-decl-else-decl-a.template
+/*---
+description: Extension not observed when creation of variable binding would produce an early error (switch statement) (IfStatement with a declaration in both statement positions in eval code)
+esid: sec-functiondeclarations-in-ifstatement-statement-clauses
+es6id: B.3.4
+flags: [generated, noStrict]
+info: |
+    The following rules for IfStatement augment those in 13.6:
+
+    IfStatement[Yield, Return]:
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
+        if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
+
+
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+---*/
+
+(function() {
+  eval(
+    'assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created prior to evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created prior to evaluation"\
+    );\
+    \
+    switch (0) {\
+      default:\
+        let f;if (true) function f() {  } else function _f() {}}\
+    \
+    assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created following evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created following evaluation"\
+    );'
+  );
+}());

test/annexB/language/eval-code/direct/func-if-decl-else-decl-a-eval-func-skip-early-err-try.js

@@ -0,0 +1,61 @@
+// This file was procedurally generated from the following sources:
+// - src/annex-b-fns/eval-func-skip-early-err-try.case
+// - src/annex-b-fns/eval-func/direct-if-decl-else-decl-a.template
+/*---
+description: Extension is not observed when creation of variable binding would produce an early error (try statement) (IfStatement with a declaration in both statement positions in eval code)
+esid: sec-functiondeclarations-in-ifstatement-statement-clauses
+es6id: B.3.4
+flags: [generated, noStrict]
+info: |
+    The following rules for IfStatement augment those in 13.6:
+
+    IfStatement[Yield, Return]:
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
+        if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
+
+
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+
+    B.3.5 VariableStatements in Catch Blocks
+
+    [...]
+    - It is a Syntax Error if any element of the BoundNames of CatchParameter
+      also occurs in the VarDeclaredNames of Block unless CatchParameter is
+      CatchParameter:BindingIdentifier and that element is only bound by a
+      VariableStatement, the VariableDeclarationList of a for statement, or the
+      ForBinding of a for-in statement.
+---*/
+
+(function() {
+  eval(
+    'assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created prior to evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created prior to evaluation"\
+    );\
+    \
+    try {\
+      throw {};\
+    } catch ({ f }) {if (true) function f() {  } else function _f() {}}\
+    \
+    assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created following evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created following evaluation"\
+    );'
+  );
+}());

test/annexB/language/eval-code/direct/func-if-decl-else-decl-a-eval-func-skip-early-err.js

@@ -6,18 +6,18 @@ description: Extension not observed when creation of variable binding would prod
 esid: sec-functiondeclarations-in-ifstatement-statement-clauses
 es6id: B.3.4
 flags: [generated, noStrict]
-info: >
+info: |
     The following rules for IfStatement augment those in 13.6:
-    
+
     IfStatement[Yield, Return]:
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
         if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
-    
+
 
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     ii. If replacing the FunctionDeclaration f with a VariableStatement that
         has F as a BindingIdentifier would not produce any Early Errors for

test/annexB/language/eval-code/direct/func-if-decl-else-decl-a-eval-func-update.js

@@ -6,18 +6,18 @@ description: Variable binding value is updated following evaluation (IfStatement
 esid: sec-functiondeclarations-in-ifstatement-statement-clauses
 es6id: B.3.4
 flags: [generated, noStrict]
-info: >
+info: |
     The following rules for IfStatement augment those in 13.6:
-    
+
     IfStatement[Yield, Return]:
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
         if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
-    
+
 
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     b. When the FunctionDeclaration f is evaluated, perform the following steps
        in place of the FunctionDeclaration Evaluation algorithm provided in

test/annexB/language/eval-code/direct/func-if-decl-else-decl-b-eval-func-block-scoping.js

@@ -6,18 +6,18 @@ description: A block-scoped binding is created (IfStatement with a declaration i
 esid: sec-functiondeclarations-in-ifstatement-statement-clauses
 es6id: B.3.4
 flags: [generated, noStrict]
-info: >
+info: |
     The following rules for IfStatement augment those in 13.6:
-    
+
     IfStatement[Yield, Return]:
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
         if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
-    
+
 
     13.2.14 Runtime Semantics: BlockDeclarationInstantiation
-    
+
     [...]
     4. For each element d in declarations do
        a. For each element dn of the BoundNames of d do
@@ -25,7 +25,7 @@ info: >
              [...]
           ii. Else,
               2. Perform ! envRec.CreateMutableBinding(dn, false).
-    
+
        b. If d is a GeneratorDeclaration production or a FunctionDeclaration
           production, then
           i. Let fn be the sole element of the BoundNames of d.

test/annexB/language/eval-code/direct/func-if-decl-else-decl-b-eval-func-exsting-block-fn-no-init.js

@@ -6,18 +6,18 @@ description: Does not re-initialize binding created by similar forms (IfStatemen
 esid: sec-functiondeclarations-in-ifstatement-statement-clauses
 es6id: B.3.4
 flags: [generated, noStrict]
-info: >
+info: |
     The following rules for IfStatement augment those in 13.6:
-    
+
     IfStatement[Yield, Return]:
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
         if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
-    
+
 
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     a. If declaredFunctionOrVarNames does not contain F, then
     [...]

test/annexB/language/eval-code/direct/func-if-decl-else-decl-b-eval-func-exsting-block-fn-update.js

@@ -6,18 +6,18 @@ description: Variable-scoped binding is updated (IfStatement with a declaration
 esid: sec-functiondeclarations-in-ifstatement-statement-clauses
 es6id: B.3.4
 flags: [generated, noStrict]
-info: >
+info: |
     The following rules for IfStatement augment those in 13.6:
-    
+
     IfStatement[Yield, Return]:
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
         if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
-    
+
 
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     b. When the FunctionDeclaration f is evaluated, perform the following steps
        in place of the FunctionDeclaration Evaluation algorithm provided in

test/annexB/language/eval-code/direct/func-if-decl-else-decl-b-eval-func-exsting-fn-no-init.js

@@ -6,18 +6,18 @@ description: Existing variable binding is not modified (IfStatement with a decla
 esid: sec-functiondeclarations-in-ifstatement-statement-clauses
 es6id: B.3.4
 flags: [generated, noStrict]
-info: >
+info: |
     The following rules for IfStatement augment those in 13.6:
-    
+
     IfStatement[Yield, Return]:
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
         if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
-    
+
 
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     b. When the FunctionDeclaration f is evaluated, perform the following steps
        in place of the FunctionDeclaration Evaluation algorithm provided in

test/annexB/language/eval-code/direct/func-if-decl-else-decl-b-eval-func-exsting-fn-update.js

@@ -6,18 +6,18 @@ description: Variable-scoped binding is updated following evaluation (IfStatemen
 esid: sec-functiondeclarations-in-ifstatement-statement-clauses
 es6id: B.3.4
 flags: [generated, noStrict]
-info: >
+info: |
     The following rules for IfStatement augment those in 13.6:
-    
+
     IfStatement[Yield, Return]:
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
         if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
-    
+
 
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     b. When the FunctionDeclaration f is evaluated, perform the following steps
        in place of the FunctionDeclaration Evaluation algorithm provided in

test/annexB/language/eval-code/direct/func-if-decl-else-decl-b-eval-func-exsting-var-no-init.js

@@ -6,18 +6,18 @@ description: Existing variable binding is not modified (IfStatement with a decla
 esid: sec-functiondeclarations-in-ifstatement-statement-clauses
 es6id: B.3.4
 flags: [generated, noStrict]
-info: >
+info: |
     The following rules for IfStatement augment those in 13.6:
-    
+
     IfStatement[Yield, Return]:
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
         if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
-    
+
 
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     a. If declaredFunctionOrVarNames does not contain F, then
     [...]

test/annexB/language/eval-code/direct/func-if-decl-else-decl-b-eval-func-exsting-var-update.js

@@ -6,18 +6,18 @@ description: Variable-scoped binding is updated following evaluation (IfStatemen
 esid: sec-functiondeclarations-in-ifstatement-statement-clauses
 es6id: B.3.4
 flags: [generated, noStrict]
-info: >
+info: |
     The following rules for IfStatement augment those in 13.6:
-    
+
     IfStatement[Yield, Return]:
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
         if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
-    
+
 
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     b. When the FunctionDeclaration f is evaluated, perform the following steps
        in place of the FunctionDeclaration Evaluation algorithm provided in

test/annexB/language/eval-code/direct/func-if-decl-else-decl-b-eval-func-init.js

@@ -6,18 +6,18 @@ description: Variable binding is initialized to `undefined` in outer scope (IfSt
 esid: sec-functiondeclarations-in-ifstatement-statement-clauses
 es6id: B.3.4
 flags: [generated, noStrict]
-info: >
+info: |
     The following rules for IfStatement augment those in 13.6:
-    
+
     IfStatement[Yield, Return]:
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
         if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
-    
+
 
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     a. If declaredFunctionOrVarNames does not contain F, then
        i. If varEnvRec is a global Environment Record, then

test/annexB/language/eval-code/direct/func-if-decl-else-decl-b-eval-func-no-skip-param.js

@@ -6,18 +6,18 @@ description: Extension observed when there is a formal parameter with the same n
 esid: sec-functiondeclarations-in-ifstatement-statement-clauses
 es6id: B.3.4
 flags: [generated, noStrict]
-info: >
+info: |
     The following rules for IfStatement augment those in 13.6:
-    
+
     IfStatement[Yield, Return]:
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
         if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
-    
+
 
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     ii. If replacing the FunctionDeclaration f with a VariableStatement that
         has F as a BindingIdentifier would not produce any Early Errors for

test/annexB/language/eval-code/direct/func-if-decl-else-decl-b-eval-func-no-skip-try.js

@@ -0,0 +1,54 @@
+// This file was procedurally generated from the following sources:
+// - src/annex-b-fns/eval-func-no-skip-try.case
+// - src/annex-b-fns/eval-func/direct-if-decl-else-decl-b.template
+/*---
+description: Extension is observed when creation of variable binding would not produce an early error (try statement) (IfStatement with a declaration in both statement positions in eval code)
+esid: sec-functiondeclarations-in-ifstatement-statement-clauses
+es6id: B.3.4
+flags: [generated, noStrict]
+info: |
+    The following rules for IfStatement augment those in 13.6:
+
+    IfStatement[Yield, Return]:
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
+        if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
+
+
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+
+    B.3.5 VariableStatements in Catch Blocks
+
+    [...]
+    - It is a Syntax Error if any element of the BoundNames of CatchParameter
+      also occurs in the VarDeclaredNames of Block unless CatchParameter is
+      CatchParameter:BindingIdentifier and that element is only bound by a
+      VariableStatement, the VariableDeclarationList of a for statement, or the
+      ForBinding of a for-in statement.
+---*/
+
+(function() {
+  eval(
+    'assert.sameValue(\
+      f, undefined, "Initialized binding created prior to evaluation"\
+    );\
+    \
+    try {\
+      throw null;\
+    } catch (f) {if (false) function _f() {} else function f() { return 123; }}\
+    \
+    assert.sameValue(\
+      typeof f,\
+      "function",\
+      "binding value is updated following evaluation"\
+    );\
+    assert.sameValue(f(), 123);'
+  );
+}());

test/annexB/language/eval-code/direct/func-if-decl-else-decl-b-eval-func-skip-early-err-block.js

@@ -0,0 +1,51 @@
+// This file was procedurally generated from the following sources:
+// - src/annex-b-fns/eval-func-skip-early-err-block.case
+// - src/annex-b-fns/eval-func/direct-if-decl-else-decl-b.template
+/*---
+description: Extension not observed when creation of variable binding would produce an early error (Block statement) (IfStatement with a declaration in both statement positions in eval code)
+esid: sec-functiondeclarations-in-ifstatement-statement-clauses
+es6id: B.3.4
+flags: [generated, noStrict]
+info: |
+    The following rules for IfStatement augment those in 13.6:
+
+    IfStatement[Yield, Return]:
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
+        if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
+
+
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+---*/
+
+(function() {
+  eval(
+    'assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created prior to evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created prior to evaluation"\
+    );\
+    \
+    {\
+    let f = 123;if (false) function _f() {} else function f() {  }}\
+    \
+    assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created following evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created following evaluation"\
+    );'
+  );
+}());

test/annexB/language/eval-code/direct/func-if-decl-else-decl-b-eval-func-skip-early-err-for-in.js

@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/annex-b-fns/eval-func-skip-early-err-for-in.case
+// - src/annex-b-fns/eval-func/direct-if-decl-else-decl-b.template
+/*---
+description: Extension not observed when creation of variable binding would produce an early error (for-of statement) (IfStatement with a declaration in both statement positions in eval code)
+esid: sec-functiondeclarations-in-ifstatement-statement-clauses
+es6id: B.3.4
+flags: [generated, noStrict]
+info: |
+    The following rules for IfStatement augment those in 13.6:
+
+    IfStatement[Yield, Return]:
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
+        if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
+
+
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+---*/
+
+(function() {
+  eval(
+    'assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created prior to evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created prior to evaluation"\
+    );\
+    \
+    for (let f in { key: 0 }) {if (false) function _f() {} else function f() {  }}\
+    \
+    assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created following evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created following evaluation"\
+    );'
+  );
+}());

test/annexB/language/eval-code/direct/func-if-decl-else-decl-b-eval-func-skip-early-err-for-of.js

@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/annex-b-fns/eval-func-skip-early-err-for-of.case
+// - src/annex-b-fns/eval-func/direct-if-decl-else-decl-b.template
+/*---
+description: Extension not observed when creation of variable binding would produce an early error (for-of statement) (IfStatement with a declaration in both statement positions in eval code)
+esid: sec-functiondeclarations-in-ifstatement-statement-clauses
+es6id: B.3.4
+flags: [generated, noStrict]
+info: |
+    The following rules for IfStatement augment those in 13.6:
+
+    IfStatement[Yield, Return]:
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
+        if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
+
+
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+---*/
+
+(function() {
+  eval(
+    'assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created prior to evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created prior to evaluation"\
+    );\
+    \
+    for (let f of [0]) {if (false) function _f() {} else function f() {  }}\
+    \
+    assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created following evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created following evaluation"\
+    );'
+  );
+}());

test/annexB/language/eval-code/direct/func-if-decl-else-decl-b-eval-func-skip-early-err-for.js

@@ -0,0 +1,51 @@
+// This file was procedurally generated from the following sources:
+// - src/annex-b-fns/eval-func-skip-early-err-for.case
+// - src/annex-b-fns/eval-func/direct-if-decl-else-decl-b.template
+/*---
+description: Extension not observed when creation of variable binding would produce an early error (for statement) (IfStatement with a declaration in both statement positions in eval code)
+esid: sec-functiondeclarations-in-ifstatement-statement-clauses
+es6id: B.3.4
+flags: [generated, noStrict]
+info: |
+    The following rules for IfStatement augment those in 13.6:
+
+    IfStatement[Yield, Return]:
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
+        if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
+
+
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+---*/
+
+(function() {
+  eval(
+    'assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created prior to evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created prior to evaluation"\
+    );\
+    \
+    for (let f; ; ) {if (false) function _f() {} else function f() {  }break;\
+    }\
+    \
+    assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created following evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created following evaluation"\
+    );'
+  );
+}());

test/annexB/language/eval-code/direct/func-if-decl-else-decl-b-eval-func-skip-early-err-switch.js

@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/annex-b-fns/eval-func-skip-early-err-switch.case
+// - src/annex-b-fns/eval-func/direct-if-decl-else-decl-b.template
+/*---
+description: Extension not observed when creation of variable binding would produce an early error (switch statement) (IfStatement with a declaration in both statement positions in eval code)
+esid: sec-functiondeclarations-in-ifstatement-statement-clauses
+es6id: B.3.4
+flags: [generated, noStrict]
+info: |
+    The following rules for IfStatement augment those in 13.6:
+
+    IfStatement[Yield, Return]:
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
+        if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
+
+
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+---*/
+
+(function() {
+  eval(
+    'assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created prior to evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created prior to evaluation"\
+    );\
+    \
+    switch (0) {\
+      default:\
+        let f;if (false) function _f() {} else function f() {  }}\
+    \
+    assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created following evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created following evaluation"\
+    );'
+  );
+}());

test/annexB/language/eval-code/direct/func-if-decl-else-decl-b-eval-func-skip-early-err-try.js

@@ -0,0 +1,61 @@
+// This file was procedurally generated from the following sources:
+// - src/annex-b-fns/eval-func-skip-early-err-try.case
+// - src/annex-b-fns/eval-func/direct-if-decl-else-decl-b.template
+/*---
+description: Extension is not observed when creation of variable binding would produce an early error (try statement) (IfStatement with a declaration in both statement positions in eval code)
+esid: sec-functiondeclarations-in-ifstatement-statement-clauses
+es6id: B.3.4
+flags: [generated, noStrict]
+info: |
+    The following rules for IfStatement augment those in 13.6:
+
+    IfStatement[Yield, Return]:
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
+        if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
+
+
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+
+    B.3.5 VariableStatements in Catch Blocks
+
+    [...]
+    - It is a Syntax Error if any element of the BoundNames of CatchParameter
+      also occurs in the VarDeclaredNames of Block unless CatchParameter is
+      CatchParameter:BindingIdentifier and that element is only bound by a
+      VariableStatement, the VariableDeclarationList of a for statement, or the
+      ForBinding of a for-in statement.
+---*/
+
+(function() {
+  eval(
+    'assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created prior to evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created prior to evaluation"\
+    );\
+    \
+    try {\
+      throw {};\
+    } catch ({ f }) {if (false) function _f() {} else function f() {  }}\
+    \
+    assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created following evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created following evaluation"\
+    );'
+  );
+}());

test/annexB/language/eval-code/direct/func-if-decl-else-decl-b-eval-func-skip-early-err.js

@@ -6,18 +6,18 @@ description: Extension not observed when creation of variable binding would prod
 esid: sec-functiondeclarations-in-ifstatement-statement-clauses
 es6id: B.3.4
 flags: [generated, noStrict]
-info: >
+info: |
     The following rules for IfStatement augment those in 13.6:
-    
+
     IfStatement[Yield, Return]:
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
         if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
-    
+
 
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     ii. If replacing the FunctionDeclaration f with a VariableStatement that
         has F as a BindingIdentifier would not produce any Early Errors for

test/annexB/language/eval-code/direct/func-if-decl-else-decl-b-eval-func-update.js

@@ -6,18 +6,18 @@ description: Variable binding value is updated following evaluation (IfStatement
 esid: sec-functiondeclarations-in-ifstatement-statement-clauses
 es6id: B.3.4
 flags: [generated, noStrict]
-info: >
+info: |
     The following rules for IfStatement augment those in 13.6:
-    
+
     IfStatement[Yield, Return]:
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
         if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
-    
+
 
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     b. When the FunctionDeclaration f is evaluated, perform the following steps
        in place of the FunctionDeclaration Evaluation algorithm provided in

test/annexB/language/eval-code/direct/func-if-decl-else-stmt-eval-func-block-scoping.js

@@ -6,18 +6,18 @@ description: A block-scoped binding is created (IfStatement with a declaration i
 esid: sec-functiondeclarations-in-ifstatement-statement-clauses
 es6id: B.3.4
 flags: [generated, noStrict]
-info: >
+info: |
     The following rules for IfStatement augment those in 13.6:
-    
+
     IfStatement[Yield, Return]:
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
         if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
-    
+
 
     13.2.14 Runtime Semantics: BlockDeclarationInstantiation
-    
+
     [...]
     4. For each element d in declarations do
        a. For each element dn of the BoundNames of d do
@@ -25,7 +25,7 @@ info: >
              [...]
           ii. Else,
               2. Perform ! envRec.CreateMutableBinding(dn, false).
-    
+
        b. If d is a GeneratorDeclaration production or a FunctionDeclaration
           production, then
           i. Let fn be the sole element of the BoundNames of d.

test/annexB/language/eval-code/direct/func-if-decl-else-stmt-eval-func-exsting-block-fn-no-init.js

@@ -6,18 +6,18 @@ description: Does not re-initialize binding created by similar forms (IfStatemen
 esid: sec-functiondeclarations-in-ifstatement-statement-clauses
 es6id: B.3.4
 flags: [generated, noStrict]
-info: >
+info: |
     The following rules for IfStatement augment those in 13.6:
-    
+
     IfStatement[Yield, Return]:
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
         if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
-    
+
 
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     a. If declaredFunctionOrVarNames does not contain F, then
     [...]

test/annexB/language/eval-code/direct/func-if-decl-else-stmt-eval-func-exsting-block-fn-update.js

@@ -6,18 +6,18 @@ description: Variable-scoped binding is updated (IfStatement with a declaration
 esid: sec-functiondeclarations-in-ifstatement-statement-clauses
 es6id: B.3.4
 flags: [generated, noStrict]
-info: >
+info: |
     The following rules for IfStatement augment those in 13.6:
-    
+
     IfStatement[Yield, Return]:
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
         if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
-    
+
 
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     b. When the FunctionDeclaration f is evaluated, perform the following steps
        in place of the FunctionDeclaration Evaluation algorithm provided in

test/annexB/language/eval-code/direct/func-if-decl-else-stmt-eval-func-exsting-fn-no-init.js

@@ -6,18 +6,18 @@ description: Existing variable binding is not modified (IfStatement with a decla
 esid: sec-functiondeclarations-in-ifstatement-statement-clauses
 es6id: B.3.4
 flags: [generated, noStrict]
-info: >
+info: |
     The following rules for IfStatement augment those in 13.6:
-    
+
     IfStatement[Yield, Return]:
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
         if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
-    
+
 
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     b. When the FunctionDeclaration f is evaluated, perform the following steps
        in place of the FunctionDeclaration Evaluation algorithm provided in

test/annexB/language/eval-code/direct/func-if-decl-else-stmt-eval-func-exsting-fn-update.js

@@ -6,18 +6,18 @@ description: Variable-scoped binding is updated following evaluation (IfStatemen
 esid: sec-functiondeclarations-in-ifstatement-statement-clauses
 es6id: B.3.4
 flags: [generated, noStrict]
-info: >
+info: |
     The following rules for IfStatement augment those in 13.6:
-    
+
     IfStatement[Yield, Return]:
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
         if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
-    
+
 
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     b. When the FunctionDeclaration f is evaluated, perform the following steps
        in place of the FunctionDeclaration Evaluation algorithm provided in

test/annexB/language/eval-code/direct/func-if-decl-else-stmt-eval-func-exsting-var-no-init.js

@@ -6,18 +6,18 @@ description: Existing variable binding is not modified (IfStatement with a decla
 esid: sec-functiondeclarations-in-ifstatement-statement-clauses
 es6id: B.3.4
 flags: [generated, noStrict]
-info: >
+info: |
     The following rules for IfStatement augment those in 13.6:
-    
+
     IfStatement[Yield, Return]:
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
         if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
-    
+
 
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     a. If declaredFunctionOrVarNames does not contain F, then
     [...]

test/annexB/language/eval-code/direct/func-if-decl-else-stmt-eval-func-exsting-var-update.js

@@ -6,18 +6,18 @@ description: Variable-scoped binding is updated following evaluation (IfStatemen
 esid: sec-functiondeclarations-in-ifstatement-statement-clauses
 es6id: B.3.4
 flags: [generated, noStrict]
-info: >
+info: |
     The following rules for IfStatement augment those in 13.6:
-    
+
     IfStatement[Yield, Return]:
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
         if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
-    
+
 
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     b. When the FunctionDeclaration f is evaluated, perform the following steps
        in place of the FunctionDeclaration Evaluation algorithm provided in

test/annexB/language/eval-code/direct/func-if-decl-else-stmt-eval-func-init.js

@@ -6,18 +6,18 @@ description: Variable binding is initialized to `undefined` in outer scope (IfSt
 esid: sec-functiondeclarations-in-ifstatement-statement-clauses
 es6id: B.3.4
 flags: [generated, noStrict]
-info: >
+info: |
     The following rules for IfStatement augment those in 13.6:
-    
+
     IfStatement[Yield, Return]:
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
         if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
-    
+
 
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     a. If declaredFunctionOrVarNames does not contain F, then
        i. If varEnvRec is a global Environment Record, then

test/annexB/language/eval-code/direct/func-if-decl-else-stmt-eval-func-no-skip-param.js

@@ -6,18 +6,18 @@ description: Extension observed when there is a formal parameter with the same n
 esid: sec-functiondeclarations-in-ifstatement-statement-clauses
 es6id: B.3.4
 flags: [generated, noStrict]
-info: >
+info: |
     The following rules for IfStatement augment those in 13.6:
-    
+
     IfStatement[Yield, Return]:
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
         if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
-    
+
 
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     ii. If replacing the FunctionDeclaration f with a VariableStatement that
         has F as a BindingIdentifier would not produce any Early Errors for

test/annexB/language/eval-code/direct/func-if-decl-else-stmt-eval-func-no-skip-try.js

@@ -0,0 +1,54 @@
+// This file was procedurally generated from the following sources:
+// - src/annex-b-fns/eval-func-no-skip-try.case
+// - src/annex-b-fns/eval-func/direct-if-decl-else-stmt.template
+/*---
+description: Extension is observed when creation of variable binding would not produce an early error (try statement) (IfStatement with a declaration in the first statement position in eval code)
+esid: sec-functiondeclarations-in-ifstatement-statement-clauses
+es6id: B.3.4
+flags: [generated, noStrict]
+info: |
+    The following rules for IfStatement augment those in 13.6:
+
+    IfStatement[Yield, Return]:
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
+        if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
+
+
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+
+    B.3.5 VariableStatements in Catch Blocks
+
+    [...]
+    - It is a Syntax Error if any element of the BoundNames of CatchParameter
+      also occurs in the VarDeclaredNames of Block unless CatchParameter is
+      CatchParameter:BindingIdentifier and that element is only bound by a
+      VariableStatement, the VariableDeclarationList of a for statement, or the
+      ForBinding of a for-in statement.
+---*/
+
+(function() {
+  eval(
+    'assert.sameValue(\
+      f, undefined, "Initialized binding created prior to evaluation"\
+    );\
+    \
+    try {\
+      throw null;\
+    } catch (f) {if (true) function f() { return 123; } else ;}\
+    \
+    assert.sameValue(\
+      typeof f,\
+      "function",\
+      "binding value is updated following evaluation"\
+    );\
+    assert.sameValue(f(), 123);'
+  );
+}());

test/annexB/language/eval-code/direct/func-if-decl-else-stmt-eval-func-skip-early-err-block.js

@@ -0,0 +1,51 @@
+// This file was procedurally generated from the following sources:
+// - src/annex-b-fns/eval-func-skip-early-err-block.case
+// - src/annex-b-fns/eval-func/direct-if-decl-else-stmt.template
+/*---
+description: Extension not observed when creation of variable binding would produce an early error (Block statement) (IfStatement with a declaration in the first statement position in eval code)
+esid: sec-functiondeclarations-in-ifstatement-statement-clauses
+es6id: B.3.4
+flags: [generated, noStrict]
+info: |
+    The following rules for IfStatement augment those in 13.6:
+
+    IfStatement[Yield, Return]:
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
+        if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
+
+
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+---*/
+
+(function() {
+  eval(
+    'assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created prior to evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created prior to evaluation"\
+    );\
+    \
+    {\
+    let f = 123;if (true) function f() {  } else ;}\
+    \
+    assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created following evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created following evaluation"\
+    );'
+  );
+}());

test/annexB/language/eval-code/direct/func-if-decl-else-stmt-eval-func-skip-early-err-for-in.js

@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/annex-b-fns/eval-func-skip-early-err-for-in.case
+// - src/annex-b-fns/eval-func/direct-if-decl-else-stmt.template
+/*---
+description: Extension not observed when creation of variable binding would produce an early error (for-of statement) (IfStatement with a declaration in the first statement position in eval code)
+esid: sec-functiondeclarations-in-ifstatement-statement-clauses
+es6id: B.3.4
+flags: [generated, noStrict]
+info: |
+    The following rules for IfStatement augment those in 13.6:
+
+    IfStatement[Yield, Return]:
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
+        if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
+
+
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+---*/
+
+(function() {
+  eval(
+    'assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created prior to evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created prior to evaluation"\
+    );\
+    \
+    for (let f in { key: 0 }) {if (true) function f() {  } else ;}\
+    \
+    assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created following evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created following evaluation"\
+    );'
+  );
+}());

test/annexB/language/eval-code/direct/func-if-decl-else-stmt-eval-func-skip-early-err-for-of.js

@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/annex-b-fns/eval-func-skip-early-err-for-of.case
+// - src/annex-b-fns/eval-func/direct-if-decl-else-stmt.template
+/*---
+description: Extension not observed when creation of variable binding would produce an early error (for-of statement) (IfStatement with a declaration in the first statement position in eval code)
+esid: sec-functiondeclarations-in-ifstatement-statement-clauses
+es6id: B.3.4
+flags: [generated, noStrict]
+info: |
+    The following rules for IfStatement augment those in 13.6:
+
+    IfStatement[Yield, Return]:
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
+        if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
+
+
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+---*/
+
+(function() {
+  eval(
+    'assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created prior to evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created prior to evaluation"\
+    );\
+    \
+    for (let f of [0]) {if (true) function f() {  } else ;}\
+    \
+    assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created following evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created following evaluation"\
+    );'
+  );
+}());

test/annexB/language/eval-code/direct/func-if-decl-else-stmt-eval-func-skip-early-err-for.js

@@ -0,0 +1,51 @@
+// This file was procedurally generated from the following sources:
+// - src/annex-b-fns/eval-func-skip-early-err-for.case
+// - src/annex-b-fns/eval-func/direct-if-decl-else-stmt.template
+/*---
+description: Extension not observed when creation of variable binding would produce an early error (for statement) (IfStatement with a declaration in the first statement position in eval code)
+esid: sec-functiondeclarations-in-ifstatement-statement-clauses
+es6id: B.3.4
+flags: [generated, noStrict]
+info: |
+    The following rules for IfStatement augment those in 13.6:
+
+    IfStatement[Yield, Return]:
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
+        if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
+
+
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+---*/
+
+(function() {
+  eval(
+    'assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created prior to evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created prior to evaluation"\
+    );\
+    \
+    for (let f; ; ) {if (true) function f() {  } else ;break;\
+    }\
+    \
+    assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created following evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created following evaluation"\
+    );'
+  );
+}());

test/annexB/language/eval-code/direct/func-if-decl-else-stmt-eval-func-skip-early-err-switch.js

@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/annex-b-fns/eval-func-skip-early-err-switch.case
+// - src/annex-b-fns/eval-func/direct-if-decl-else-stmt.template
+/*---
+description: Extension not observed when creation of variable binding would produce an early error (switch statement) (IfStatement with a declaration in the first statement position in eval code)
+esid: sec-functiondeclarations-in-ifstatement-statement-clauses
+es6id: B.3.4
+flags: [generated, noStrict]
+info: |
+    The following rules for IfStatement augment those in 13.6:
+
+    IfStatement[Yield, Return]:
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
+        if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
+
+
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+---*/
+
+(function() {
+  eval(
+    'assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created prior to evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created prior to evaluation"\
+    );\
+    \
+    switch (0) {\
+      default:\
+        let f;if (true) function f() {  } else ;}\
+    \
+    assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created following evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created following evaluation"\
+    );'
+  );
+}());

test/annexB/language/eval-code/direct/func-if-decl-else-stmt-eval-func-skip-early-err-try.js

@@ -0,0 +1,61 @@
+// This file was procedurally generated from the following sources:
+// - src/annex-b-fns/eval-func-skip-early-err-try.case
+// - src/annex-b-fns/eval-func/direct-if-decl-else-stmt.template
+/*---
+description: Extension is not observed when creation of variable binding would produce an early error (try statement) (IfStatement with a declaration in the first statement position in eval code)
+esid: sec-functiondeclarations-in-ifstatement-statement-clauses
+es6id: B.3.4
+flags: [generated, noStrict]
+info: |
+    The following rules for IfStatement augment those in 13.6:
+
+    IfStatement[Yield, Return]:
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
+        if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
+        if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
+
+
+    B.3.3.3 Changes to EvalDeclarationInstantiation
+
+    [...]
+    ii. If replacing the FunctionDeclaration f with a VariableStatement that
+        has F as a BindingIdentifier would not produce any Early Errors for
+        body, then
+    [...]
+
+    B.3.5 VariableStatements in Catch Blocks
+
+    [...]
+    - It is a Syntax Error if any element of the BoundNames of CatchParameter
+      also occurs in the VarDeclaredNames of Block unless CatchParameter is
+      CatchParameter:BindingIdentifier and that element is only bound by a
+      VariableStatement, the VariableDeclarationList of a for statement, or the
+      ForBinding of a for-in statement.
+---*/
+
+(function() {
+  eval(
+    'assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created prior to evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created prior to evaluation"\
+    );\
+    \
+    try {\
+      throw {};\
+    } catch ({ f }) {if (true) function f() {  } else ;}\
+    \
+    assert.throws(ReferenceError, function() {\
+      f;\
+    }, "An initialized binding is not created following evaluation");\
+    assert.sameValue(\
+      typeof f,\
+      "undefined",\
+      "An uninitialized binding is not created following evaluation"\
+    );'
+  );
+}());

test/annexB/language/eval-code/direct/func-if-decl-else-stmt-eval-func-skip-early-err.js

@@ -6,18 +6,18 @@ description: Extension not observed when creation of variable binding would prod
 esid: sec-functiondeclarations-in-ifstatement-statement-clauses
 es6id: B.3.4
 flags: [generated, noStrict]
-info: >
+info: |
     The following rules for IfStatement augment those in 13.6:
-    
+
     IfStatement[Yield, Return]:
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
         if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
-    
+
 
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     ii. If replacing the FunctionDeclaration f with a VariableStatement that
         has F as a BindingIdentifier would not produce any Early Errors for

test/annexB/language/eval-code/direct/func-if-decl-else-stmt-eval-func-update.js

@@ -6,18 +6,18 @@ description: Variable binding value is updated following evaluation (IfStatement
 esid: sec-functiondeclarations-in-ifstatement-statement-clauses
 es6id: B.3.4
 flags: [generated, noStrict]
-info: >
+info: |
     The following rules for IfStatement augment those in 13.6:
-    
+
     IfStatement[Yield, Return]:
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else Statement[?Yield, ?Return]
         if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield] else FunctionDeclaration[?Yield]
         if ( Expression[In, ?Yield] ) FunctionDeclaration[?Yield]
-    
+
 
     B.3.3.3 Changes to EvalDeclarationInstantiation
-    
+
     [...]
     b. When the FunctionDeclaration f is evaluated, perform the following steps
        in place of the FunctionDeclaration Evaluation algorithm provided in