Deep readonly type with a nested tuple made deep writeable incorrectly extends `never`

Bug Report

🔎 Search Terms

never tuple
readonly tuple
change name of type
change result of type

🕗 Version & Regression Information

• This changed between versions 4.4.4 (correct) and 4.5.5 (incorrect) and 4.6.4 (correct) and >= 4.7.4, <= 5.2.2 (incorrect) and 5.3.2 (correct)

⏯ Playground Link

Playground link with relevant code

💻 Code

type DeepWriteable<T> = { -readonly [P in keyof T]: DeepWriteable<T[P]> };
type IsNever<T> = [T] extends [never] ? true : false;

type DeepExactArray<Arr extends any[], Shape> = {
  [K in keyof Arr]: DeepExactShape<Arr[K], Shape[K & keyof Shape]>;
};
type DeepExactShape<Obj, Shape> =
  (
    Obj extends Shape
    ? (
      Shape extends any
      ? (
        Obj extends any[]
        ? DeepExactArray<Obj, Shape>
        : (
          IsNever<Exclude<keyof Obj, keyof Shape>> extends true
          ? (
            Obj extends object
            ? {
              [K in keyof Obj]: K extends keyof Shape ? DeepExactShape<Obj[K], Shape[K]> : never;
            }
            : Obj
          )
          : never
        )
      )
      : never
    )
    : never
  );

const obj = {
  topLevel: {
    data: {
      myTuple: [{ tup1: null, extra: '' }]
    }
  }
} as const;
type Obj = DeepWriteable<typeof obj>;
type ShapeToValidate = {
  topLevel: {
    data?: {
      myTuple: [{ tup1: null }] | null;
    };
  }
};
type ValidatedShape = DeepExactShape<Obj, ShapeToValidate>;
//   ^? { topLevel: { data: { myTuple: [never]; }; }; }
type test = Obj extends ValidatedShape ? true : false;
//    ^? type test = true;
type test2 = Obj extends { topLevel: { data: { myTuple: [never]; }; }; } ? true : false;
//    ^? type test2 = false;

const thing: test = false; // Changing the name of type test, for example, to tes, in either usage negates the type from false to true, then back to false

🙁 Actual behavior

A type with a multi-level nested tuple incorrectly extends itself but with a slight modification: the element of the tuple is replaced with never, but only when the type is created the using above DeepExactShape type. When using the same type with the never replacement, but explicitly written out instead, it correctly does not extend.

In addition, when removing the as const statement, it correctly does not extend. When changing the nested depth of the tuple from 3 to 2 (removing the topLevel property), it correctly does not extend.

Finally, when changing the name of type test, for example, to tes, in either usage negates the type from false to true, then back to false as visible in the two-slash query and when hovering over the type (in 4.7.4 and above)

🙂 Expected behavior

In both cases, the initial type, Obj, should not extend either the created type (from DeepExactShape), or the explicitly defined type, with, or without, the as const statement included.

Changing the name of a type should not result in the value of the type being different.

The degree of nesting (2 vs 3) should not change whether the type extends the created type.

Bắt đầu với TypeScript Playground được liên kết và tái hiện ví dụ tuple lồng nhau trên các phiên bản được liệt kê trong báo cáo. So sánh các kiểu được tính toán cho ValidatedShape, test và test2 trong khi thay đổi tên kiểu, độ sâu lồng nhau và as const; được xem là hoàn tất khi các biến thể này nhất quán tạo ra kết quả không mở rộng như mong đợi.