A extends B relation break after wrapping by extra interface

[nzhl]

TypeScript Version: 3.9.2

Search Terms: subtypes, extends

Expected behavior: {name: "age"} extends {name: string} so A extends B

Code

export type IsFlatObject<T extends object> = Extract<
  Exclude<T[keyof T],  Date | FileList>,
  any[] | object
> extends never
  ? true
  : false;

export type FieldValues = Record<string, any>;

export type FieldName<TFieldValues extends FieldValues> = IsFlatObject<
  TFieldValues
> extends true
  ? Extract<keyof TFieldValues, string>
    : string;


export type CustomElement<TFieldValues> = {
    name: FieldName<TFieldValues>;
};


type ISChild<A, B> = A extends B ? true : false

type A = CustomElement<{age: string}>  // i.e {name: "age"}  
type B = CustomElement<FieldValues>   //  i.e {name: string}
type ShouldBeTrue = ISChild<{name: "age"}, {name: string}>   // type true 
type ShouldBeTrueAsWell = ISChild<A, B> // type false 

Output

Compiler Options

{
  "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

[RyanCavanaugh]

Regressed sometime between 3.3 and 3.5

[jamiehaywood]

is there any update on this?

[weswigham]

So, the example as given is fixed, but not for the right reasons. Now A and B have separate aliases - A and B, respectively, so we no longer use the variance result to compare them. If you change the example to

type ShouldBeTrueAsWell = ISChild<CustomElement<{age: string}>, CustomElement<FieldValues>> // type false

the issue still repros. The root cause is that we measure all of IsFlatObject, FieldName, and CustomElement as solely covariant on their type parameters. This is incorrect. Root-cause-wise, this is a dupe of #31295. We incorrectly measure the variance of a conditional type checkType clause. While the conditional may be covariant on a parameter within the check type (or actually bivariant, by our current relationship rules), the result of evaluating the condition, the true or false type, may be entirely unrelated, and may vary entirely differently with the type parameter in question.

The fix is simple to put together - mark conditional check type positions as Unmeasurable variance. The issue, however, is that this makes us fall back to structural comparisons when comparing many conditional instantiations which we previously shortcut (albeit potentially incorrectly) - a notable example is our own conditionalTypeDoesntSpinForever test which shows that doing that alone re-breaks the issue which #27804 (the introduction of alias measurement on conditionals directly) originally fixed, making us OOM on the test.