Accept new baselines

tests/baselines/reference/typeArgumentDefaultUsesConstraintOnCircularDefault.errors.txt

@@ -4,7 +4,7 @@ tests/cases/compiler/typeArgumentDefaultUsesConstraintOnCircularDefault.ts(3,18)
 
 
 ==== tests/cases/compiler/typeArgumentDefaultUsesConstraintOnCircularDefault.ts (2 errors) ====
-    type Test<T extends string = T> = { value: T };
+    type Test<T extends string = T> = { value: T };  // Error
                                  ~
 !!! error TS2744: Type parameter defaults can only reference previously declared type parameters.
     
@@ -13,5 +13,11 @@ tests/cases/compiler/typeArgumentDefaultUsesConstraintOnCircularDefault.ts(3,18)
 !!! error TS2322: Type '{ foo: string; }' is not assignable to type 'Test<any>'.
 !!! error TS2322:   Object literal may only specify known properties, and 'foo' does not exist in type 'Test<any>'.
     
-    let zzy: Test = { value: {} };  // should error
+    let zzy: Test = { value: {} };
+    
+    // Simplified repro from #28873
+    
+    class C1<T extends C1 = any> {}
+    
+    class C2<T extends C2<any> = any> {}
     

tests/baselines/reference/typeArgumentDefaultUsesConstraintOnCircularDefault.js

@@ -1,11 +1,28 @@
 //// [typeArgumentDefaultUsesConstraintOnCircularDefault.ts]
-type Test<T extends string = T> = { value: T };
+type Test<T extends string = T> = { value: T };  // Error
 
 let zz: Test = { foo: "abc" };  // should error on comparison with Test<string>
 
-let zzy: Test = { value: {} };  // should error
+let zzy: Test = { value: {} };
+
+// Simplified repro from #28873
+
+class C1<T extends C1 = any> {}
+
+class C2<T extends C2<any> = any> {}
 
 
 //// [typeArgumentDefaultUsesConstraintOnCircularDefault.js]
 var zz = { foo: "abc" }; // should error on comparison with Test<string>
-var zzy = { value: {} }; // should error
+var zzy = { value: {} };
+// Simplified repro from #28873
+var C1 = /** @class */ (function () {
+    function C1() {
+    }
+    return C1;
+}());
+var C2 = /** @class */ (function () {
+    function C2() {
+    }
+    return C2;
+}());

tests/baselines/reference/typeArgumentDefaultUsesConstraintOnCircularDefault.symbols

@@ -1,5 +1,5 @@
 === tests/cases/compiler/typeArgumentDefaultUsesConstraintOnCircularDefault.ts ===
-type Test<T extends string = T> = { value: T };
+type Test<T extends string = T> = { value: T };  // Error
 >Test : Symbol(Test, Decl(typeArgumentDefaultUsesConstraintOnCircularDefault.ts, 0, 0))
 >T : Symbol(T, Decl(typeArgumentDefaultUsesConstraintOnCircularDefault.ts, 0, 10))
 >T : Symbol(T, Decl(typeArgumentDefaultUsesConstraintOnCircularDefault.ts, 0, 10))
@@ -11,8 +11,20 @@ let zz: Test = { foo: "abc" };  // should error on comparison with Test<string>
 >Test : Symbol(Test, Decl(typeArgumentDefaultUsesConstraintOnCircularDefault.ts, 0, 0))
 >foo : Symbol(foo, Decl(typeArgumentDefaultUsesConstraintOnCircularDefault.ts, 2, 16))
 
-let zzy: Test = { value: {} };  // should error
+let zzy: Test = { value: {} };
 >zzy : Symbol(zzy, Decl(typeArgumentDefaultUsesConstraintOnCircularDefault.ts, 4, 3))
 >Test : Symbol(Test, Decl(typeArgumentDefaultUsesConstraintOnCircularDefault.ts, 0, 0))
 >value : Symbol(value, Decl(typeArgumentDefaultUsesConstraintOnCircularDefault.ts, 4, 17))
 
+// Simplified repro from #28873
+
+class C1<T extends C1 = any> {}
+>C1 : Symbol(C1, Decl(typeArgumentDefaultUsesConstraintOnCircularDefault.ts, 4, 30))
+>T : Symbol(T, Decl(typeArgumentDefaultUsesConstraintOnCircularDefault.ts, 8, 9))
+>C1 : Symbol(C1, Decl(typeArgumentDefaultUsesConstraintOnCircularDefault.ts, 4, 30))
+
+class C2<T extends C2<any> = any> {}
+>C2 : Symbol(C2, Decl(typeArgumentDefaultUsesConstraintOnCircularDefault.ts, 8, 31))
+>T : Symbol(T, Decl(typeArgumentDefaultUsesConstraintOnCircularDefault.ts, 10, 9))
+>C2 : Symbol(C2, Decl(typeArgumentDefaultUsesConstraintOnCircularDefault.ts, 8, 31))
+

tests/baselines/reference/typeArgumentDefaultUsesConstraintOnCircularDefault.types

@@ -1,5 +1,5 @@
 === tests/cases/compiler/typeArgumentDefaultUsesConstraintOnCircularDefault.ts ===
-type Test<T extends string = T> = { value: T };
+type Test<T extends string = T> = { value: T };  // Error
 >Test : Test<T>
 >value : T
 
@@ -9,9 +9,17 @@ let zz: Test = { foo: "abc" };  // should error on comparison with Test<string>
 >foo : string
 >"abc" : "abc"
 
-let zzy: Test = { value: {} };  // should error
+let zzy: Test = { value: {} };
 >zzy : Test<any>
 >{ value: {} } : { value: {}; }
 >value : {}
 >{} : {}
 
+// Simplified repro from #28873
+
+class C1<T extends C1 = any> {}
+>C1 : C1<T>
+
+class C2<T extends C2<any> = any> {}
+>C2 : C2<T>
+