Parser incorrectly rejects exponentiation whose LHS is an unparenthesized `await`, as in `await a ** 2`

[bakkot]

TypeScript Version: 4.1.0-insiders.20201002 [nightly]

Search Terms: exponentiation exponential async await operator parser

Code

async function f() {
    await 1 ** 1;
}

Expected behavior:

No error.

Actual behavior:

Error: "An unary expression with the 'await' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. (17006)"

Playground Link: Here

Related Issues: Couldn't find any.

Incidentally, the grammar in the error message is also wrong (or at least unusual) - it's normally "a" unary expression, not "an", in my experience, since most people pronounce it "yoon-ary" rather than "oon-ary".

[DanielRosenwasser]

Pretty sure I've heard "an unary" might be a UK-ism, but agree, it should be "a unary".

[DanielRosenwasser]

I'm a little confused - if I look at the spec, I can't seem to find a derivation for ExponentiationExpression to await 1 ** 1.

ExponentiationExpression seems to need an UpdateExpression on the left, which does not include an AwaitExpression. On the other hand, UnaryExpression does, but that's kind of the point of the syntax split. Am I missing something?

[bakkot]

Huh. No, I think you're right, and it's just that every other parser and also all the major browsers got this wrong.

[DanielRosenwasser]

I don't know how exactly to say this, but I'm just very shocked that every other parser and major browser vendor got this wrong. Would you be interested in bringing this up at the next TC39 meeting with me?

[bakkot]

Sure, though I doubt there's much of an action item here except adding a test262 test (though, if engines are reluctant to risk potential web breakage, we might instead need to figure out how to spec what is apparently web reality).

I'm pretty sure what happens is that all these parsers treat await in a different way than normal unary operators, and also have recursive descent parsers which deal with the -1 ** 1 case by explicitly forbidding the combination of a unary operator and **, which fails here because await is not treated as unary operator. At least, that's how I missed it. V8 too.

[DanielRosenwasser]

Yeah, it seems like the change in the "web reality" case is just moving AwaitExpression around, though it's not my preference to treat await differently than void in this case.

[bakkot]

Let's move the discussion to tc39/ecma262#2197, since I beileve you are correct that this isn't actually a TypeScript bug.