RxJS type inference fails in 3.6.2

[felixfbecker]

TypeScript Version: 3.6.2

Search Terms: type inference 3.6

Code

function asObservable(input: string | ObservableInput<string>): Observable<string> {
 return typeof input === 'string' ? of(input) : from(input)
}

Expected behavior:
This function managed to compile correctly in 3.5 with RxJS 6.5.2

Actual behavior:
In 3.6, it fails with

Type 'Observable<unknown>' is not assignable to type 'Observable<string>'.
 Type 'unknown' is not assignable to type 'string'.ts(2322)

the type of from() does not get inferred anymore.
It is declared as

function from<O extends ObservableInput<any>>(input: O): Observable<ObservedValueOf<O>>

Specifically, the ObservedValueOf<T> type fails now with ObservableInput<T>:

type ObservedValueOf<O> = O extends ObservableInput<infer T> ? T : never;

type ObservableInput<T> = SubscribableOrPromise<T> | ArrayLike<T> | Iterable<T>;

which worked before.

Related Issues: Filed at ReactiveX/rxjs#4992

[j-oliveras]

Related to #33125?

[benlesh]

Yeah, this one is really not good for RxJS and will break a lot of people. This comment is a solid illustration of why

[maxdeviant]

Not using RxJS, but I can confirm that a number of spots in our codebase where type inference was working before (in 3.4.1) broke after upgrading to 3.6.2.

[weswigham]

So, this is my minimal repro:

declare function of<T>(a: T): Observable<T>;
declare function from<O extends ObservableInput<any>>(input: O): Observable<ObservedValueOf<O>>;

type ObservedValueOf<O> = O extends ObservableInput<infer T> ? T : never;

interface Subscribable<T> {
 subscribe(next?: (value: T) => void, error?: (error: any) => void, complete?: () => void): void;
}
type ObservableInput<T> = Subscribable<T> | Subscribable<never>;


declare class Observable<T> implements Subscribable<T> {
 subscribe(next?: (value: T) => void, error?: (error: any) => void, complete?: () => void): void;
}

function asObservable(input: string | ObservableInput<string>): Observable<string> {
 return typeof input === 'string' ? of(input) : from(input)
}

The Subscribable<never> is ultimately what produces the unknown inference result, looks like. If ObservableInput only contains a Subscribable<T>, there's no problem. I'll look into why our inference is unknown now~

[weswigham]

Haaaaaaaaaaaaaaaaaaaaaah the issue is with our new inference matching code. We try to infer from Subscribable<never> to Subscribable<T> | Subscribable<never> - we match Subscribable<never> up to itself, strip it, then say "welp, nothing left in the source, must be done", and do not produce an inference for T. Now, since there's no inference for T, we assign it unknown, which then is union'ed with the inference from the other input type options once that flows out of the conditional and effectively erases 'em.