Grammar conflicts with explicit resource management

[waldemarhorwat]

This proposal's grammar conflicts with the proposed explicit resource management grammar. An example of a problematic token sequence is:

await void x;

This parses as both:

• await «void x»;: a CoverAwaitExpressionAndAwaitUsingDeclarationHead containing a CoverVoidExpressionAndVoidDiscard
• «await void» x;: an AwaitUsingDeclaration containing a CoverAwaitExpressionAndAwaitUsingDeclarationHead

At this stage we haven't gotten to expanding the cover grammars yet. We don't know which cover grammar to attempt to expand, so we have a spec defect.

[rbuckton]

• «await void» x;: an AwaitUsingDeclaration containing a CoverAwaitExpressionAndAwaitUsingDeclarationHead

AwaitUsingDeclaration requires CoverAwaitExpressionAndAwaitUsingDeclarationHead parse to await using, not await void, so await void x can never be a legal AwaitUsingDeclaration. I'm 100% certain the intended grammar has no conflict, though it's quite possible there needs to be some revisions to the cover grammar to iron out the wrinkles.

With any luck though, we can use _ instead of void and avoid these wrinkles.

[waldemarhorwat]

• «await void» x;: an AwaitUsingDeclaration containing a CoverAwaitExpressionAndAwaitUsingDeclarationHead

AwaitUsingDeclaration requires CoverAwaitExpressionAndAwaitUsingDeclarationHead parse to await using

The problem here is that it doesn't. The latter is a cover grammar. We've reached the ambiguity before refining that cover grammar and we have a choice of conflicting cover grammars to try to refine.

[rbuckton]

I think that's resolvable though, for example:

UnaryExpression[Yield, Await, Discard] :
    UpdateExpression[?Yield, ?Await]
    `delete` UnaryExpression[?Yield, ?Await, ~Discard]
    `typeof` UnaryExpression[?Yield, ?Await, ~Discard]
    `+` UnaryExpression[?Yield, ?Await, ~Discard]
    `-` UnaryExpression[?Yield, ?Await, ~Discard]
    `~` UnaryExpression[?Yield, ?Await, ~Discard]
    `!` UnaryExpression[?Yield, ?Await, ~Discard]
    CoverVoidExpressionAndVoidDiscard[?Yield, ?Await, ?Discard]
    [+Await] CoverAwaitExpressionAndAwaitUsingDeclarationHead[?Yield]

CoverAwaitExpressionAndAwaitUsingDeclarationHead[Yield] :
    `await` UnaryExpression[?Yield, +Await, ~Discard]

CoverVoidExpressionAndVoidDiscard[Yield, Await, Discard] :
    [+Discard] `void` UnaryExpression[?Yield, ?Await]?
    [~Discard] `void` UnaryExpression[?Yield, ?Await]

And you only set +Discard outside of UnaryExpression.

[waldemarhorwat]

There are other problems:

void-x

is now either a void-expression with operand -x or a void cover grammar from which x is subtracted.

[ljharb]

void should require a space after it regardless.

[rbuckton]

Another option might be to drop CoverVoidExpressionAndVoidDiscard and instead introduce covers to the individual places where it would be legal, i.e.:

CoverAssignmentExpressionAndVoidDiscard[In, Yield, Await] :
  AssigmentExpression[?In, ?Yield, ?Await]
  `void`
  
ElementList[Yield, Await] :
  Elision? CoverAssignmentExpressionAndVoidDiscard[+In, ?Yield, ?Await]
  Elision? SpreadElement[?Yield, ?Await]
  ElementList[?Yield, ?Await] `,` Elision? CoverAssignmentExpressionAndVoidDiscard[+In, ?Yield, ?Await]
  ElementList[?Yield, ?Await] `,` Elision? SpreadElement[?Yield, ?Await]
  
PropertyDefinition[Yield, Await] :
  IdentifierReference[?Yield, ?Await]
  CoverInitializedName[?Yield, ?Await]
  PropertyName[?Yield, ?Await] `:` CoverAssignmentExpressionAndVoidDiscard[+In, ?Yield, ?Await]
  MethodDefinition[?Yield, ?Await]
  `...` AssignmentExpression[+In, ?Yield, ?Await]
  
ArgumentList[Yield, Await] :
  CoverAssignmentExpressionAndVoidDiscard[+In, ?Yield, ?Await]
  `...` AssignmentExpression[+In, ?Yield, ?Await]
  ArgumentList[?Yield, ?Await] `,` CoverAssignmentExpressionAndVoidDiscard[+In, ?Yield, ?Await]
  ArgumentList[?Yield, ?Await] `,` `...` AssignmentExpression[+In, ?Yield, ?Await]