Parser does not reject `await a as any ** 1`

[JLHwung]

TypeScript Version: 4.2.0-dev.20201201

Search Terms: exponentiation, await

Code

await a as any ** 1

Expected behavior: Parser should throw

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.

Actual behavior: Does not throw

Playground Link: https://www.typescriptlang.org/play?ts=4.2.0-dev.20201201#code/G4QwTgBCELwQCmA9gWwJYGcCmA6MWMkAbYLACgEYBKAbgCgQMBPAOwGMIyrYA+KAdxBoALlCgYoLJhABUMiBSA

Related Issues: #40916, since in November meeting we have reached consensus that await x ** 1 is illegal and the parser already throws on await a! ** 1, I think it should either throw for await a as any ** 1, or add parenthesis in the output for await a if as any serves as an implicit parenthesis.

[DanielRosenwasser]

Like you said, there are 2 things here:

1. The emitter doesn't auto-parenthesize the expression. That's definitely an emit bug.
2. It's not clear to me why this should be a parse error even though we could make it so. So this part is actually a suggestion.

the parser already throws on await a! ** 1

That's different - that's still an await as the left operand of a ** whereas the as expression adds a new node.

Forcing -x as any ** y to be disambiguated seems vaguely useful. It is a breaking change though, so it's unclear whether we should.

[JLHwung]

Forcing -x as any ** y to be disambiguated seems vaguely useful. It is a breaking change though, so it's unclear whether we should.

Agreed. I am good with fixing the emit bug only.

[a-tarasyuk]

The emitter doesn't auto-parenthesize the expression. That's definitely an emit bug.

@DanielRosenwasser Should the expected result be like this?

const foo = async () => (await a) + 2;

[DanielRosenwasser]

Yup!

[a-tarasyuk]

@DanielRosenwasser Thanks. Maybe I'm wrong., doesn't JavaScript interpreters can handle await a + 2 without side issues?

const a = Promise.resolve(10);
const b = async () => await a + 2 - 1;
b().then(console.log); // 11 ?

or

const a = Promise.resolve(10);
const b = async () => await a + await a + await a + 2 + 1;
b().then(console.log); // 33 ?

**

// out.ts
const a = Promise.resolve(1);
const b = async () => await a as any ** 2 + await a as any ** 2 + await a as any ** 2;
b().then(console.log);

// out.js
"use strict";
const a = Promise.resolve(1);
const b = async () => ((await a ** 2 + await a) ** 2 + await a) ** 2;
b().then(console.log);

[jonhue]

@DanielRosenwasser I think @a-tarasyuk is right and we don't have an emit bug here. That is unless there is some JavaScript engine, I am unaware of, that cannot handle await a ** 2 without enclosing await a in parenthesis.
I agree with @JLHwung that there is an inconsistency with which TypeScript handles the cases await a ** 2 (1) and await a as any ** 2 (2).

I can see two options to address this inconsistency:

1. we throw the same error we currently throw for (1) also for (2); or
2. we remove the error altogether as it seems that JavaScript engines are able to interpret (1) correctly without any parentheses.

I'd personally be in favor of the second option. What do you think? 🙂

[JLHwung]

@a-tarasyuk @jonhue Note that in TC39 November 2020 meeting we have reached consensus that await x ** 1 is illegal, so current engines (except TS!) are not conforming to the spec.

[RyanCavanaugh]

😞✋ Fixing tricky parser bugs
😀👉 Having the spec change to match your behavior