`extends any ?` may return right hand in conditional types

TypeScript Version: 4.0.5

Search Terms:

• type inference
• extends any
• conditional types
• right hand

Expected behavior:

type D1 = X1 <O1> returns false.

Actual behavior:

In the code below, type D1 = X1<O1> seems to return false, but it actually returns true.
If you change the seemingly irrelevant right-hand type in extends any ? written for union distribution to undefined, it will behave as intended.

Related Issues:

Code

type X1<T> = IfEq<
  AllKeys1<T>,
  keyof T,
  true,
  false
>;

type X2<T> = IfEq<
  AllKeys2<T>,
  keyof T,
  true,
  false
>;

type IfEq<X, Y, T, E> = [X] extends [Y] ? ([Y] extends [X] ? T : E) : E;

// AllKeys<{ x: ... } | { x: ...; y: ... }> -> "x" | ("x" | "y") -> "x" | "y"
type AllKeys1<O extends Object> = O extends any ? keyof O : never;
type AllKeys2<O extends Object> = O extends any ? keyof O : undefined;

type O1 = { x: string; y: number } | { x: boolean; z: number }
type A1 = AllKeys1<O1> // "x" | "y" | "z"
type A2 = AllKeys2<O1> // "x" | "y" | "z"
type B = keyof O1 // "x"

type C1 = IfEq<A1, B, true, false> // false
type C2 = IfEq<A2, B, true, false> // false
type D1 = X1<O1> // true ???
type D2 = X2<O1> // false

type O2 = { x: string; y: number } | { x: boolean; y: Object }
type E1 = X1<O2> // true
type E2 = X2<O2> // true

"use strict";

{
  "compilerOptions": {
    "noImplicitAny": true,
    "strictNullChecks": true,
    "strictFunctionTypes": true,
    "strictPropertyInitialization": true,
    "strictBindCallApply": true,
    "noImplicitThis": true,
    "noImplicitReturns": true,
    "alwaysStrict": true,
    "esModuleInterop": true,
    "declaration": true,
    "experimentalDecorators": true,
    "emitDecoratorMetadata": true,
    "moduleResolution": 2,
    "target": "ES2017",
    "jsx": "React",
    "module": "ESNext"
  }
}

Playground Link: Provided

Beginne mit der bereitgestellten Playground-Reproduktion unter Verwendung von TypeScript 4.0.5 und vergleiche die Ergebnisse der bedingten Typen für D1, D2, E1 und E2. Verfolge die Verarbeitung distributiver bedingter Typen durch den Compiler und überprüfe, dass die gemeldeten erwarteten und tatsächlichen Ergebnisse konsistent aufgelöst werden, ohne die anderen Fälle zu ändern.