typeof on a well-known symbol in a computed property name has a poor error

[DanielRosenwasser]

Found talking to @benlesh

If you try to write the following

interface SymbolConstructor {
  observable: symbol;
}

declare function from<T>(obj: { [typeof Symbol.observable](): Observable<T> }): Observable<T>;
//                               ^^^^^^ Look at this use of 'typeof'.

type Observer<T> = (x: T) => void;

interface Observable<T> {
  subscribe(observer: Observer<T>): { unsubscribe(): void }
}

You'll get an error like

A computed property name in a type literal must refer to an expression whose type is a literal type or a 'unique symbol' type.

This is pretty confusing, because we do support well-known symbols that are declared with symbol instead of unique symbol if you use the following syntax:

declare function from<T>(obj: { [Symbol.observable](): Observable<T> }): Observable<T>;
//                               ^ No 'typeof'.

It would be great if we could detect this case and specialize the error message with something like

Computed property names can only be named with well-known symbols without the 'typeof' operator. Try replacing `typeof {0}` with `{0}`.

[jonhue]

#42530 adds this error message 🙂

[benlesh]

Related... this also has issues (given any permutation of your example code):

// Imagine you got a reference to the symbol from somewhere else.
const symbolObservable = Symbol.observable;

const obj = {
    [symbolObservable](): Observable<any> {
        return null!;
    }
}

const x = from(obj);  // Error: Argument of type '{ [x: string]: () => Observable<any>; }' is not assignable to parameter of type '{ [Symbol.observable](): Observable<unknown>; [observable](): Observable<unknown>; }'.

[DanielRosenwasser]

This is really just going to be closed by #24738 if I understand correctly.

[DanielRosenwasser]

Or I guess #42543 now

[jonhue]

@DanielRosenwasser just out of curiosity: was this fixed by #42543 and could be closed or should this remain open? 🙂

[DanielRosenwasser]

Yup, thanks!