link November 29 2012 Meeting Notes

John Neumann (JN), Allen Wirfs-Brock (AWB), Waldemar Horwat (WH), Brian Terlson (BT), Luke Hoban (LH), Rick Waldron (RW), Eric Ferraiuolo (EF), Doug Crockford (DC), Yehuda Katz (YK), Erik Arvidsson (EA), Mark Miller (MM), Dave Herman (DH), Sam Tobin-Hochstadt (STH), Istvan Sebastian (IS), Andreas Rossberg (ARB), Brendan Eich (BE), Alex Russel (AR), Matt Sweeney (MS)

link Approval of ECMA/TC39 Scope Declaration

(Presented by John Neumann)

JN: (presents scope document for approval)

link Conclusion/Resolution

Approved.

link Scoping for default arguments revisited

(Presented by Allen Wirfs-Brock) See Slides

AWB: (Review legacy requirements)

Two Params, Same Name allowed (non-strict)

function f(x,x) { console.log(x); }
f(1,2); // logs: 2

Parameter and a Var with Same name

function g(x) {
  var x;
  console.log(x);
}
g(1); // logs: 1

Function Declarations Override Parameter Bindings

function h(x) {
  function x() {return 2;}
  console.log(x());
}
h(function() { return 1; }); // logs: 2

link Proposal Part 1

• Simple ES<=5.1 parameter lists introduce "var bindings" in the top level scope of a function
• All ES<=5.1 rules apply
  • Duplicated parameter names
  • Parameter names may be same as var or function Declaration
  • (missed) see slides...

ARB: These are simply the requirements.

link Proposal Part 2

• If a parameter list uses ANY parameter syntax introduced in ES6, new rules apply:
  • Destructuring Parameters
  • Default value initializers
  • Rest Parameters
• New Rules:
  • Parameter lists introduce "let bindings" in the top level scope of the function
    • No duplicate param names
    • Parameter names may not be the same as any other function top-level
  • TDZ rules apply to parameter default value initializers
    • Hoisted top-level function/var declaration are initialized after parameter initialization
  • "strict" arguments object (copy of actual args, no parameter joining)

DH/YK/LH: This is problematic for extant offending code, that is updated to use ES6 syntax. One syntax change shouldn't have adverse effects on other, not directly related, syntax.

RW: If offending code exists, it would be smart to fix the issues, new syntax does new things.

YK: Sympathetic, but disagrees

New Rules Examples:

function f(x, x, ...rest) {}
  Syntax Error: duplicate parameter name (Rule 1.A)
 
function f(x, {a:x, b:y}) {}
  Syntax Error: duplicate parameter name (Rule 1.A)
 
function f([x]) { let x; }
  Syntax Error: redeclaration of parameter x (Rule 1.B)
 
function f([x]) { var x; }
  Syntax Error: redeclaration of parameter x (Rule 1.B)
 
function f([x]) { {var x;} }
  Syntax Error: redeclaration of parameter x using hoisted var (Rule 1.B)
 
function f([x]) { {let x;} }
  Valid, redeclaration is in inner block
 
function f([x]) { function x(){} }
  Syntax Error: redeclaration of parameter x (Rule 1.B)
 
function f([x]) { class x {} }
  Syntax Error: redeclaration of parameter x (Rule 1.B)

WH/AWB/ARB: discussion about parenthesis on parameters

ARB: Points out that this is why 1JS becomes a problem where we introduce micro-modes to make things work

AWB: We need to have these to make these things work correctly

MM: Also nervous about these micro-modes, but want to see the rest of the proposal

New Rules Examples, Cont...

function f(x, y=x) {}
  Valid, x has been initialized when y's default value expression is evaluated.
 
function f(x=y, y) {}
  Runtime: ReferenceError exception y not initialized (Rule 2)
 
const a = "A";
function f(x=a) {}
  Valid
 
function f(x=a) { var a;}
  Runtime: ReferenceError a not yet initialized (Rule 2.A)
 
function f(x=a) { const a = "A";}
  Runtime: ReferenceError a not yet initialized (Rule 2.A)
 
function a() {return "A";}
function f(x=a()) {}
  Valid, a is initialized in surrounding scope, at time of parameter default value initialization.
 
function f(x=a()) { function a() { return "A"; } }
  Runtime: ReferenceError a not yet initialized (Rule 2.A)

MM, WH: I want to preserve:

1. A Function, as soon as it's in scope is already initialized
2. A Var variable, as soon as it's in scope is already initialized

ARB: Agree, but these things simply should not be in scope.

DH: We're making mistakes with let all around. We should wait to continue this discussion until this afternoon when all are present.

MM: Luke, where does the let research stand?

LH: Incomplete.

AWB: If there are disagreements with these rules, then someone needs to write rules that cover all these cases.

ARB: I proposed a set of rules and posted to es-discuss. Basic idea: a function with default arguments behaves as if it was a wrapper function supplying the default arguments. So initializers cannot see any definitions from the body.

link Simplest example:

1	// scope boundaries