Conditional type inference regression in 4.2*

[robertf224]

Bug Report

🔎 Search Terms

"conditional type inference"

🕗 Version & Regression Information

This changed between versions 4.1.5 and 4.2.2

⏯ Playground Link

Playground link with relevant code

💻 Code

export interface IFruits {
    tropical: {
        papaya: number;
        pineapple: number;
        guava: number;
    };

    stone: {
        peach: number;
        nectarine: number;
    };

    berry: {
        strawberry: number;
        blueberry: number;
    };
}

/**
 * Aggregating all the second level keys (the fruits) into a single union type.
 */
export type FruitKey = {
    [category in keyof IFruits]: keyof IFruits[category];
}[keyof IFruits];

/**
 * Helper to pick only fruit categories (first level) that are required for the requested fruit keys.
 */
type RequiredFruitCategories<K extends FruitKey> = {
    [category in keyof IFruits]: Extract<K, keyof IFruits[category]> extends never ? never : category;
}[keyof IFruits];


/**
 * Takes a nested slice of the IFruits interface depending on the fruit keys (second level) that
 * we ask for -- essentially a nested `Pick`.  So `FruitsSubset<"papaya" | "peach">` ends up being:
 * {
 *      tropical: {
 *          papaya: number;
 *      };
 *      stone: {
 *          peach: number;
 *      };
 * }
 */
type FruitsSubset<K extends FruitKey> = {
    [category in RequiredFruitCategories<K>]: Pick<
        IFruits[category],
        Extract<K, keyof IFruits[category]>
    >;
};

/**
 * Just wrapping the above in an interface for other interfaces (i.e. React props) to extend.
 */
interface FruitsSubsetOpts<K extends FruitKey> {
    fruits: FruitsSubset<K>;
}

type MyFavoriteFruitsSubset = FruitsSubset<"papaya" | "peach">;
// Inferring the key from above -- this ends up being `"papaya" | "peach"` on TS 4.1.5 but `never` on 4.2.3
type MyFavoriteFruitsSubsetKey = MyFavoriteFruitsSubset extends FruitsSubset<infer K> ? K : never;

type MyFavoriteFruitsSubsetOpts = FruitsSubsetOpts<"papaya" | "peach">;
// Inferring the key from above -- this ends up being `"papaya" | "peach"` on both TS 4.1.5 and 4.2.3
// Pretty confusing because FruitsSubsetOpts is just a wrapper around FruitsSubset!
type MyFavoriteFruitsSubsetOptsKey = MyFavoriteFruitsSubsetOpts extends FruitsSubsetOpts<infer K> ? K : never;

🙁 Actual behavior

MyFavoriteFruitsSubsetKey can be properly inferred on TS 4.1.5 but not on 4.2.3 (we tried migrating to 4.2.2 locally and this broke so the change in behavior is somewhere between 4.1.5 and 4.2.2)

🙂 Expected behavior

MyFavoriteFruitsSubsetKey should be properly inferred on both versions. Could be we're doing a thing we shouldn't be doing in the first place, but it's strange that it only kind of breaks and doesn't completely break.

[MartinJohns]

You forgot to fill out the issue template. 🤔

[robertf224]

ah sorry will edit

[ahejlsberg]

This is an effect of #42284 and basically a duplicate of #42421.

Previously, the MyFavoriteFruitsSubset type alias would resolve to the exact same type identity as FruitsSubset<"papaya" | "peach">, and when printing back types in diagnostics and quick info, that's what we'd show. Now, we create a separate type identity for MyFavoriteFruitsSubset and preserve the alias when printing back the type. In the MyFavoriteFruitsSubsetKey conditional type this means we're no longer inferring from one instantiation of the FruitsSubset<...> type alias to another (where we can just infer between the type arguments). Rather, we're performing structural type inference between two mapped types, and, because the transformation is lossy, we can't produce an inference for K.

[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.