Fix react-redux break on DT

src/compiler/checker.ts

@@ -388,7 +388,7 @@ namespace ts {
         const intersectionTypes = createMap<IntersectionType>();
         const literalTypes = createMap<LiteralType>();
         const indexedAccessTypes = createMap<IndexedAccessType>();
-        const conditionalTypes = createMap<Type>();
+        const conditionalTypes = createMap<Type | undefined>();
         const evolvingArrayTypes: EvolvingArrayType[] = [];
         const undefinedProperties = createMap<Symbol>() as UnderscoreEscapedMap<Symbol>;
 
@@ -10138,11 +10138,24 @@ namespace ts {
             const trueType = instantiateType(root.trueType, mapper);
             const falseType = instantiateType(root.falseType, mapper);
             const instantiationId = `${root.isDistributive ? "d" : ""}${getTypeId(checkType)}>${getTypeId(extendsType)}?${getTypeId(trueType)}:${getTypeId(falseType)}`;
-            const result = conditionalTypes.get(instantiationId);
-            if (result) {
-                return result;
+            if (conditionalTypes.has(instantiationId)) {
+                const result = conditionalTypes.get(instantiationId);
+                if (result !== undefined) {
+                    return result;
+                }
+                // Somehow the conditional type depends on itself - usually via `infer` types in the `extends` clause
+                // paired with a (potentially deferred) circularly constrained type.
+                // The conditional _must_ be deferred.
+                const deferred = getDeferredConditionalType(root, mapper, /*combinedMapper*/ undefined, checkType, extendsType, trueType, falseType);
+                conditionalTypes.set(instantiationId, deferred);
+                return deferred;
             }
+            conditionalTypes.set(instantiationId, undefined);
             const newResult = getConditionalTypeWorker(root, mapper, checkType, extendsType, trueType, falseType);
+            const cachedRecursiveResult = conditionalTypes.get(instantiationId);
+            if (cachedRecursiveResult) {
+                return cachedRecursiveResult;
+            }
             conditionalTypes.set(instantiationId, newResult);
             return newResult;
         }
@@ -10206,6 +10219,10 @@ namespace ts {
                 }
             }
             // Return a deferred type for a check that is neither definitely true nor definitely false
+            return getDeferredConditionalType(root, mapper, combinedMapper, checkType, extendsType, trueType, falseType);
+        }
+
+        function getDeferredConditionalType(root: ConditionalRoot, mapper: TypeMapper | undefined, combinedMapper: TypeMapper | undefined, checkType: Type, extendsType: Type, trueType: Type, falseType: Type) {
             const erasedCheckType = getActualTypeVariable(checkType);
             const result = <ConditionalType>createType(TypeFlags.Conditional);
             result.root = root;

tests/baselines/reference/circularTypeofWithVarOrFunc.errors.txt

@@ -4,13 +4,11 @@ tests/cases/conformance/types/specifyingTypes/typeQueries/circularTypeofWithVarO
 tests/cases/conformance/types/specifyingTypes/typeQueries/circularTypeofWithVarOrFunc.ts(5,6): error TS2456: Type alias 'typeAlias2' circularly references itself.
 tests/cases/conformance/types/specifyingTypes/typeQueries/circularTypeofWithVarOrFunc.ts(7,18): error TS2577: Return type annotation circularly references itself.
 tests/cases/conformance/types/specifyingTypes/typeQueries/circularTypeofWithVarOrFunc.ts(9,6): error TS2456: Type alias 'typeAlias3' circularly references itself.
-tests/cases/conformance/types/specifyingTypes/typeQueries/circularTypeofWithVarOrFunc.ts(18,6): error TS2456: Type alias 'R' circularly references itself.
-tests/cases/conformance/types/specifyingTypes/typeQueries/circularTypeofWithVarOrFunc.ts(19,29): error TS2577: Return type annotation circularly references itself.
-tests/cases/conformance/types/specifyingTypes/typeQueries/circularTypeofWithVarOrFunc.ts(25,6): error TS2456: Type alias 'R2' circularly references itself.
-tests/cases/conformance/types/specifyingTypes/typeQueries/circularTypeofWithVarOrFunc.ts(26,15): error TS2577: Return type annotation circularly references itself.
+tests/cases/conformance/types/specifyingTypes/typeQueries/circularTypeofWithVarOrFunc.ts(20,3): error TS2322: Type 'number' is not assignable to type 'ReturnType<(input: Input) => ReturnType<typeof mul>>'.
+tests/cases/conformance/types/specifyingTypes/typeQueries/circularTypeofWithVarOrFunc.ts(26,20): error TS2322: Type '0' is not assignable to type 'ReturnType<() => ReturnType<typeof f>>'.
 
 
-==== tests/cases/conformance/types/specifyingTypes/typeQueries/circularTypeofWithVarOrFunc.ts (10 errors) ====
+==== tests/cases/conformance/types/specifyingTypes/typeQueries/circularTypeofWithVarOrFunc.ts (8 errors) ====
     type typeAlias1 = typeof varOfAliasedType1;
          ~~~~~~~~~~
 !!! error TS2456: Type alias 'typeAlias1' circularly references itself.
@@ -41,20 +39,16 @@ tests/cases/conformance/types/specifyingTypes/typeQueries/circularTypeofWithVarO
     }
 
     type R = ReturnType<typeof mul>;
-         ~
-!!! error TS2456: Type alias 'R' circularly references itself.
     function mul(input: Input): R {
-                                ~
-!!! error TS2577: Return type annotation circularly references itself.
       return input.a * input.b;
+      ~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2322: Type 'number' is not assignable to type 'ReturnType<(input: Input) => ReturnType<typeof mul>>'.
     }
 
     // Repro from #26104
 
     type R2 = ReturnType<typeof f>;
-         ~~
-!!! error TS2456: Type alias 'R2' circularly references itself.
     function f(): R2 { return 0; }
-                  ~~
-!!! error TS2577: Return type annotation circularly references itself.
+                       ~~~~~~~~~
+!!! error TS2322: Type '0' is not assignable to type 'ReturnType<() => ReturnType<typeof f>>'.
 

tests/baselines/reference/circularTypeofWithVarOrFunc.types

@@ -37,11 +37,11 @@ interface Input {
 }
 
 type R = ReturnType<typeof mul>;
->R : any
->mul : (input: Input) => any
+>R : ReturnType<(input: Input) => ReturnType<typeof mul>>
+>mul : (input: Input) => ReturnType<typeof mul>
 
 function mul(input: Input): R {
->mul : (input: Input) => any
+>mul : (input: Input) => ReturnType<typeof mul>
 >input : Input
 
   return input.a * input.b;
@@ -57,10 +57,10 @@ function mul(input: Input): R {
 // Repro from #26104
 
 type R2 = ReturnType<typeof f>;
->R2 : any
->f : () => any
+>R2 : ReturnType<() => ReturnType<typeof f>>
+>f : () => ReturnType<typeof f>
 
 function f(): R2 { return 0; }
->f : () => any
+>f : () => ReturnType<typeof f>
 >0 : 0
 

tests/baselines/reference/circularlyConstrainedMappedTypeContainingConditionalNoInfiniteInstantiationDepth.js

@@ -0,0 +1,69 @@
+//// [circularlyConstrainedMappedTypeContainingConditionalNoInfiniteInstantiationDepth.ts]
+declare class Component<P> {
+    constructor(props: Readonly<P>);
+    constructor(props: P, context?: any);
+    readonly props: Readonly<P> & Readonly<{ children?: {} }>;
+}
+interface ComponentClass<P = {}> {
+    new (props: P, context?: any): Component<P>;
+    propTypes?: WeakValidationMap<P>;
+    defaultProps?: Partial<P>;
+    displayName?: string;
+}
+interface FunctionComponent<P = {}> {
+    (props: P & { children?: {} }, context?: any): {} | null;
+    propTypes?: WeakValidationMap<P>;
+    defaultProps?: Partial<P>;
+    displayName?: string;
+}
+
+export declare const nominalTypeHack: unique symbol;
+export interface Validator<T> {
+    (props: object, propName: string, componentName: string, location: string, propFullName: string): Error | null;
+    [nominalTypeHack]?: T;
+}
+type WeakValidationMap<T> = {
+    [K in keyof T]?: null extends T[K]
+        ? Validator<T[K] | null | undefined>
+        : undefined extends T[K]
+        ? Validator<T[K] | null | undefined>
+        : Validator<T[K]>
+};
+type ComponentType<P = {}> = ComponentClass<P> | FunctionComponent<P>;
+
+export type Shared<
+    InjectedProps,
+    DecorationTargetProps extends Shared<InjectedProps, DecorationTargetProps>
+    > = {
+        [P in Extract<keyof InjectedProps, keyof DecorationTargetProps>]?: InjectedProps[P] extends DecorationTargetProps[P] ? DecorationTargetProps[P] : never;
+    };
+
+// Infers prop type from component C
+export type GetProps<C> = C extends ComponentType<infer P> ? P : never;
+
+export type ConnectedComponentClass<
+    C extends ComponentType<any>,
+    P
+> = ComponentClass<P> & {
+    WrappedComponent: C;
+};
+
+export type Matching<InjectedProps, DecorationTargetProps> = {
+    [P in keyof DecorationTargetProps]: P extends keyof InjectedProps
+        ? InjectedProps[P] extends DecorationTargetProps[P]
+            ? DecorationTargetProps[P]
+            : InjectedProps[P]
+        : DecorationTargetProps[P];
+};
+
+export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+
+export type InferableComponentEnhancerWithProps<TInjectedProps, TNeedsProps> =
+    <C extends ComponentType<Matching<TInjectedProps, GetProps<C>>>>(
+        component: C
+    ) => ConnectedComponentClass<C, Omit<GetProps<C>, keyof Shared<TInjectedProps, GetProps<C>>> & TNeedsProps>;
+
+
+//// [circularlyConstrainedMappedTypeContainingConditionalNoInfiniteInstantiationDepth.js]
+"use strict";
+exports.__esModule = true;