react-redux: conditional type inference from alias fails after re-alias support in #42284

[sandersn]

Bug Report

On DT, react-redux/react-redux-tests.tsx:1433:

interface OwnProps {
    own: string;
}
const Component: React.FC<OwnProps & ReduxProps> = ({ own, dispatch }) => null;
                                                        // ~~~~~~~~ 'dispatch' does not exist on PropsWithChildren<OwnProps> 
const connector = connect();
type ReduxProps = ConnectedProps<typeof connector>;

🙂 Expected behavior

The object type that's the first parameter to the arrow function should have two properties own (from OwnProps) and dispatch (from ConnectedProps<typeof connector>.

ConnectedProps is a conditional type with a false branch never, and it looks like the false branch is incorrectly selected:

export type ConnectedProps<TConnector> =
    TConnector extends InferableComponentEnhancerWithProps<infer TInjectedProps, any>
        ? TInjectedProps
        : never;

That must be because inference to InferableComponentEnhancerWithProps<infer TInjectedProps, any> fails.

🙁 Actual behavior

Component: React.FC<OwnProps> not : React.FC<OwnProps & DispatchProp>

Workaround

I observed that connect: Connect and also that

interface Connect {
  (): InferableComponentEnhancer<DispatchProp>;
  // ... many other properties ...
}
export type InferableComponentEnhancer<TInjectedProps> =
    InferableComponentEnhancerWithProps<TInjectedProps, {}>;

Manually de-aliasing InferableComponentEnhancer fixes the error:

interface Connect {
  (): InferableComponentEnhancerWithProps<DispatchProp, {}>;
  // ... many other properties ...
}

[ahejlsberg]

The core issue here is that with our improved type alias preservation we now give distinct identities to otherwise equivalent instantiations of InferableComponentEnhancer and InferableComponentEnhancerWithProps. That in turn means we end up doing structural inference where otherwise we would have just inferred between type arguments--and the structural inference in this case is less precise because we erase type parameters from generic signatures before inferring.

It's possible we could improve inference between instantiated signatures that originate in the same signature declaration and fix the issue that way, but I'm not too hopeful.

[ahejlsberg]

Looking a little deeper, the issue is that InferableComponentEnhancerWithProps uses the first type parameter in a lossy fashion that makes it impossible to recover during structural inference. So, only when inferring from the exact same alias can the information be recovered. The quickest fix right now would be to try inferring from the other alias when inference from the first alias fails:

export type ConnectedProps<TConnector> =
    TConnector extends InferableComponentEnhancerWithProps<infer TInjectedProps, any> ?
        unknown extends TInjectedProps ?
            TConnector extends InferableComponentEnhancer<infer TInjectedProps> ?
                TInjectedProps :
                never :
            TInjectedProps :
        never;

This fixes the issue and works in a backwards compatible matter.

[sandersn]

I put up a workaround PR for react-redux types.

[ahejlsberg]

@DanielRosenwasser We should include this in the release notes as a scenario that might be broken by #42284.

[typescript-bot]

This issue has been marked 'Working as Intended' and has seen no recent activity. It has been automatically closed for house-keeping purposes.

[DanielRosenwasser]

I understand what is happening, but I don't know if I can reliably communicate that in the release notes for the average user though. I'll think on it.