ES6 feature: Let and Const Declaration

[ariya]

Syntax:

Per Rev 32 (Feb 2, 2015) of the draft spec, the relevant grammar is on Section 13.2.1 on Let and Const Declarations:

LexicalDeclaration[In, Yield] :
  LetOrConst BindingList[?In, ?Yield] ;

LetOrConst :
  let
  const

BindingList[In, Yield] :
  LexicalBinding[?In, ?Yield]
  BindingList[?In, ?Yield] , LexicalBinding[?In, ?Yield]

LexicalBinding[In, Yield] :
  BindingIdentifier[?Yield] Initializer[?In, ?Yield]opt
  BindingPattern[?Yield] Initializer[?In, ?Yield]

Referred to by:

Declaration:

Declaration[Yield] :
  HoistableDeclaration _[?Yield]
  ClassDeclaration[?Yield]
  LexicalDeclaration[In, ?Yield]

StatementListItem:

StatementListItem[Yield, Return] :
  Statement[?Yield, ?Return]
  Declaration[?Yield]

Iteration:

for ( LexicalDeclaration[?Yield] Expression[In, ?Yield]opt ; Expression[In, ?Yield]opt ) Statement[?Yield, ?Return]
for ( ForDeclaration[?Yield] in Expression[In, ?Yield] ) Statement[?Yield, ?Return]

whereas:

ForDeclaration[Yield] :
  LetOrConst ForBinding[?Yield]

ForBinding[Yield] :
  BindingIdentifier[?Yield]
  BindingPattern[?Yield]

Early errors:

• const without initializer: const x; (from Esprima 1.x)
• for-in with multiple let identifiers: for (let x,y in z){}
• for-in with multiple const identifiers: for (const x,y in z){}
• for-in with let initializer: for (let i = 1 in x){}
• for-in with const initializer: for (const i = 1 in x){}
  • More TBD

Spec:

13.2.1 Let and Const Declarations.

Relevant AST interfaces (from https://github.com/estree/estree):

interface VariableDeclaration <: Declaration {
    type: "VariableDeclaration";
    declarations: [ VariableDeclarator ];
    kind: "var";
}

extend interface VariableDeclaration {
    kind: "var" | "let" | "const";
}

See also

• Error messages in V8
• Harmony branch: switch case accepting declaration

Note that V8 doesn't yet support various early errors for lexical declarations. In the mean time, we may need to use the generic Unexpected token... message for such an error.

[ariya]

Note that Esprima is always able to parse let and const hitherto (as variable declaration). However, it does not yet have the formalized lexical declaration. Thus, implementing this feature finally allows const to be used in other places (switch case, etc).

[ariya]

@ikarienator Just to confirm, there is also this grammar:

for ( [lookahead ∉ {let [}] LeftHandSideExpression[?Yield] in Expression[In, ?Yield] ) Statement[?Yield, ?Return]

Does this mean that the code like for (let i in [1, 2, 3]){} is not valid?

[ikarienator]

That example is valid but does not fall into that production. It falls into:

for ( ForDeclaration[?Yield] in Expression[In, ?Yield] ) Statement[?Yield, ?Return]

The lookahead is for disambiguous.
Note that the lookahead is actually of two tokens let and [.

[ariya]

Ah you're right. And technically it's not even a LexicalDeclaration because ForDeclaration only permits one binding, not multiple.

[ariya]

How about for (const i in x) {}? Not sure how valid it should be, using the const there is a bit unnatural.

[ikarienator]

Weirdly enough, it is allowed. The semantics is that it can only be assigned once. I think the spec should clarify it more on in what occasion it could be used. https://people.mozilla.org/~jorendorff/es6-draft.html#sec-for-statement-runtime-semantics-labelledevaluation

[ariya]

Weirdly enough, it is allowed.

Let's keep it invalid for now, until there is a better clarification.

Now with that, please review this PR #1076 @ikarienator 😉

[michaelficarra]

No clarification needed. It should definitely be allowed.

[ikarienator]

I meant the clarification on the use case. The definition is clear.
On Sun, Feb 22, 2015 at 10:28 Michael Ficarra notifications@github.com
wrote:

No classification needed. It should definitely be allowed.

—
Reply to this email directly or view it on GitHub
#1065 (comment).

[ariya]

Tasks in this ticket have been implemented. Further enhancements and more early errors will be filed separately.