[Tests] Update tests to reflect new output.

Author: Amritpan Kaur

test/Concurrency/async_overload_filtering.swift

@@ -18,7 +18,12 @@ var a: String? = nil
 
 // CHECK: attempting disjunction choice $T0 bound to decl async_overload_filtering.(file).filter_async(fn2:)
 // CHECK-NEXT: overload set choice binding $T0 := {{.*}}
+// CHECK-NEXT: (considering -> ({{.*}}) -> {{.*}} applicable fn {{.*}}
 // CHECK-NEXT: increasing 'sync-in-asynchronous' score by 1
+// CHECK-NEXT: (added constraint: {{.*}} arg conv () async -> {{.*}}
+// CHECK-NEXT: (removed constraint: ({{.*}}) -> {{.*}} applicable fn {{.*}}
+// CHECK-NEXT: (outcome: simplified)
+// CHECK-NEXT: )
 // CHECK-NEXT: solution is worse than the best solution
 filter_async {
   Obj()

test/Constraints/common_type.swift

@@ -28,9 +28,27 @@ func f(_: Double) -> Y { return Y() }
 
 func testCallCommonType() {
   // CHECK: overload set choice binding $T{{[0-9]+}} := (Int) -> X
-  // CHECK-NEXT: (common result type for $T{{[0-9]+}} is Int)
+  // CHECK-NEXT: (considering -> (_const $T2) -> $T3 applicable fn $T1
+  // CHECK-NEXT: (added constraint: $T2 arg conv Int
+  // CHECK-NEXT: (removed constraint: (_const $T2) -> $T3 applicable fn $T1
+  // CHECK-NEXT: (outcome: simplified)
+  // CHECK-NEXT: )
+  // CHECK-NEXT: (considering -> $T3[.g: value] == $T4
+  // CHECK-NEXT: (added constraint: disjunction
+  // CHECK-NEXT: > $T4 bound to decl common_type
+  // CHECK-NEXT: > $T4 bound to decl common_type
+  // CHECK-NEXT: (common result type for $T4 is Int)
   // CHECK: (overload set choice binding $T{{[0-9]+}} := (Double) -> Y)
-  // CHECK-NEXT: (common result type for $T{{[0-9]+}} is Double)
+  // CHECK-NEXT: (considering -> (_const $T2) -> $T3 applicable fn $T1
+  // CHECK-NEXT: (added constraint: $T2 arg conv Double
+  // CHECK-NEXT: (removed constraint: (_const $T2) -> $T3 applicable fn $T1
+  // CHECK-NEXT: (outcome: simplified)
+  // CHECK-NEXT: )
+  // CHECK-NEXT: (considering -> $T3[.g: value] == $T4
+  // CHECK-NEXT: (added constraint: disjunction
+  // CHECK-NEXT: > $T4 bound to decl common_type
+  // CHECK-NEXT: > $T4 bound to decl common_type
+  // CHECK-NEXT: (common result type for $T4 is Double)
   _ = f(0).g(0)
 }
 

test/Constraints/one_way_solve.swift

@@ -37,10 +37,23 @@ func testTernaryOneWayOverload(b: Bool) {
   // CHECK: (attempting type variable $T11 := Int8
 
   // CHECK: solving component #1
-  // CHECK: (attempting type variable $T11 := Int8 
-  // CHECK: (found solution: [component: non-default literal(s), value: 2] [component: use of overloaded unapplied function(s), value: 2]) 
-
-  // CHECK: (composed solution: [component: non-default literal(s), value: 2] [component: use of overloaded unapplied function(s), value: 2])
-  // CHECK-NOT: (composed solution: [component: non-default literal(s), value: 2] [component: use of overloaded unapplied function(s), value: 2])
+  // CHECK: (attempting type variable $T11 := Int8
+  // CHECK: (considering -> $T5 conv $T11
+  // CHECK: (removed constraint: $T5 conv $T11
+  // CHECK: (outcome: simplified)
+  // CHECK: )
+  // CHECK: (considering -> $T10 conv $T11
+  // CHECK: (removed constraint: $T10 conv $T11
+  // CHECK: (outcome: simplified)
+  // CHECK: )
+  // CHECK: (considering -> $T11 conv Int8
+  // CHECK: > $T10 conv $T11
+  // CHECK: > $T11 conv Int8
+  // CHECK: )
+  // CHECK: )
+  // CHECK: found solution: [non-default literal(s) = 2] [use of overloaded unapplied function(s) = 2]
+
+  // CHECK: composed solution: [non-default literal(s) = 2] [use of overloaded unapplied function(s) = 2]
+  // CHECK-NOT: composed solution: [non-default literal(s) = 2] [use of overloaded unapplied function(s) = 2]
   let _: Int8 = b ? Builtin.one_way(int8Or16(17)) : Builtin.one_way(int8Or16(42))
 }

test/Constraints/overload_filtering.swift

@@ -35,6 +35,10 @@ func testSubscript(x: X, i: Int) {
 func testUnresolvedMember(i: Int) -> X {
   // CHECK: disabled disjunction term {{.*}} bound to decl overload_filtering.(file).X.init(_:)
   // CHECK-NEXT: disabled disjunction term {{.*}} bound to decl overload_filtering.(file).X.init(_:_:_:)
+  // CHECK-NEXT: (removed constraint: disjunction
+  // CHECK-NEXT: > $T1 bound to decl overload_filtering
+  // CHECK-NEXT: > [disabled] $T1 bound to decl overload_filtering
+  // CHECK-NEXT: > [disabled] $T1 bound to decl overload_filtering
   // CHECK-NEXT: introducing single enabled disjunction term {{.*}} bound to decl overload_filtering.(file).X.init(_:_:)
   return .init(i, i)
 }
@@ -56,6 +60,10 @@ func test_member_filtering() {
   func test(s: S) {
     // CHECK: disabled disjunction term {{.*}} bound to decl overload_filtering.(file).test_member_filtering().S.bar(v:)
     // CHECK-NEXT: disabled disjunction term {{.*}} bound to decl overload_filtering.(file).test_member_filtering().S.bar(a:b:)
+    // CHECK-NEXT: (removed constraint: disjunction
+    // CHECK-NEXT: > $T4 bound to decl overload_filtering
+    // CHECK-NEXT: > [disabled] $T4 bound to decl overload_filtering
+    // CHECK-NEXT: > [disabled] $T4 bound to decl overload_filtering
     // CHECK-NEXT: introducing single enabled disjunction term {{.*}} bound to decl overload_filtering.(file).test_member_filtering().S.bar
     s.foo(42).bar(42)
   }