Accept new baselines

Author: ahejlsberg

tests/baselines/reference/infiniteConstraints.errors.txt

@@ -1,11 +1,19 @@
+error TS2321: Excessive stack depth comparing types 'Extract<T[Exclude<keyof T, string | number | symbol>], Record<"val", string>>["val"]' and 'Extract<T[Exclude<keyof T, Exclude<keyof T, string | number | symbol>>], Record<"val", string>>["val"]'.
 tests/cases/compiler/infiniteConstraints.ts(4,37): error TS2536: Type '"val"' cannot be used to index type 'B[Exclude<keyof B, K>]'.
+tests/cases/compiler/infiniteConstraints.ts(27,36): error TS2345: Argument of type '{ main: Record<"val", "test">; alternate: Record<"val", "test2">; }' is not assignable to parameter of type '{ main: never; alternate: never; }'.
+  Types of property 'main' are incompatible.
+    Type 'Record<"val", "test">' is not assignable to type 'never'.
+tests/cases/compiler/infiniteConstraints.ts(29,44): error TS2345: Argument of type '{ main: Record<"val", "test">; }' is not assignable to parameter of type '{ main: never; }'.
+  Types of property 'main' are incompatible.
+    Type 'Record<"val", "test">' is not assignable to type 'never'.
 tests/cases/compiler/infiniteConstraints.ts(31,42): error TS2345: Argument of type '{ main: Record<"val", "dup">; alternate: Record<"val", "dup">; }' is not assignable to parameter of type '{ main: never; alternate: never; }'.
   Types of property 'main' are incompatible.
     Type 'Record<"val", "dup">' is not assignable to type 'never'.
 tests/cases/compiler/infiniteConstraints.ts(36,71): error TS2536: Type '"foo"' cannot be used to index type 'T[keyof T]'.
 
 
-==== tests/cases/compiler/infiniteConstraints.ts (3 errors) ====
+!!! error TS2321: Excessive stack depth comparing types 'Extract<T[Exclude<keyof T, string | number | symbol>], Record<"val", string>>["val"]' and 'Extract<T[Exclude<keyof T, Exclude<keyof T, string | number | symbol>>], Record<"val", string>>["val"]'.
+==== tests/cases/compiler/infiniteConstraints.ts (5 errors) ====
     // Both of the following types trigger the recursion limiter in getImmediateBaseConstraint
 
     type T1<B extends { [K in keyof B]: Extract<B[Exclude<keyof B, K>], { val: string }>["val"] }> = B;
@@ -35,8 +43,16 @@ tests/cases/compiler/infiniteConstraints.ts(36,71): error TS2536: Type '"foo"' c
     >(vals: T): void;
 
     const noError = ensureNoDuplicates({main: value("test"), alternate: value("test2")});
+                                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2345: Argument of type '{ main: Record<"val", "test">; alternate: Record<"val", "test2">; }' is not assignable to parameter of type '{ main: never; alternate: never; }'.
+!!! error TS2345:   Types of property 'main' are incompatible.
+!!! error TS2345:     Type 'Record<"val", "test">' is not assignable to type 'never'.
 
     const shouldBeNoError = ensureNoDuplicates({main: value("test")});
+                                               ~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2345: Argument of type '{ main: Record<"val", "test">; }' is not assignable to parameter of type '{ main: never; }'.
+!!! error TS2345:   Types of property 'main' are incompatible.
+!!! error TS2345:     Type 'Record<"val", "test">' is not assignable to type 'never'.
 
     const shouldBeError = ensureNoDuplicates({main: value("dup"), alternate: value("dup")});
                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

tests/baselines/reference/infiniteConstraints.types

@@ -39,7 +39,7 @@ declare function value<V extends string>(val: V): Value<V>;
 >val : V
 
 declare function ensureNoDuplicates<
->ensureNoDuplicates : <T extends { [K in keyof T]: Extract<T[K], Record<"val", string>>["val"] extends Extract<T[Exclude<keyof T, K>], Record<"val", string>>["val"] ? never : any; }>(vals: T) => void
+>ensureNoDuplicates : <T extends { [K in keyof T]: never; }>(vals: T) => void
 
   T extends {
     [K in keyof T]: Extract<T[K], Value>["val"] extends Extract<T[Exclude<keyof T, K>], Value>["val"]
@@ -50,9 +50,9 @@ declare function ensureNoDuplicates<
 >vals : T
 
 const noError = ensureNoDuplicates({main: value("test"), alternate: value("test2")});
->noError : void
->ensureNoDuplicates({main: value("test"), alternate: value("test2")}) : void
->ensureNoDuplicates : <T extends { [K in keyof T]: Extract<T[K], Record<"val", string>>["val"] extends Extract<T[Exclude<keyof T, K>], Record<"val", string>>["val"] ? never : any; }>(vals: T) => void
+>noError : any
+>ensureNoDuplicates({main: value("test"), alternate: value("test2")}) : any
+>ensureNoDuplicates : <T extends { [K in keyof T]: never; }>(vals: T) => void
 >{main: value("test"), alternate: value("test2")} : { main: Record<"val", "test">; alternate: Record<"val", "test2">; }
 >main : Record<"val", "test">
 >value("test") : Record<"val", "test">
@@ -64,9 +64,9 @@ const noError = ensureNoDuplicates({main: value("test"), alternate: value("test2
 >"test2" : "test2"
 
 const shouldBeNoError = ensureNoDuplicates({main: value("test")});
->shouldBeNoError : void
->ensureNoDuplicates({main: value("test")}) : void
->ensureNoDuplicates : <T extends { [K in keyof T]: Extract<T[K], Record<"val", string>>["val"] extends Extract<T[Exclude<keyof T, K>], Record<"val", string>>["val"] ? never : any; }>(vals: T) => void
+>shouldBeNoError : any
+>ensureNoDuplicates({main: value("test")}) : any
+>ensureNoDuplicates : <T extends { [K in keyof T]: never; }>(vals: T) => void
 >{main: value("test")} : { main: Record<"val", "test">; }
 >main : Record<"val", "test">
 >value("test") : Record<"val", "test">
@@ -76,7 +76,7 @@ const shouldBeNoError = ensureNoDuplicates({main: value("test")});
 const shouldBeError = ensureNoDuplicates({main: value("dup"), alternate: value("dup")});
 >shouldBeError : any
 >ensureNoDuplicates({main: value("dup"), alternate: value("dup")}) : any
->ensureNoDuplicates : <T extends { [K in keyof T]: Extract<T[K], Record<"val", string>>["val"] extends Extract<T[Exclude<keyof T, K>], Record<"val", string>>["val"] ? never : any; }>(vals: T) => void
+>ensureNoDuplicates : <T extends { [K in keyof T]: never; }>(vals: T) => void
 >{main: value("dup"), alternate: value("dup")} : { main: Record<"val", "dup">; alternate: Record<"val", "dup">; }
 >main : Record<"val", "dup">
 >value("dup") : Record<"val", "dup">