[Tests] NFC: Adjust all the test-cases improved by multi-statement inference

xedin · xedin · commit 966f58f04405 · 2022-03-08T01:13:44.000-08:00
diff --git a/test/Constraints/closures.swift b/test/Constraints/closures.swift
@@ -252,7 +252,7 @@ struct CC {}
 func callCC<U>(_ f: (CC) -> U) -> () {}
 
 func typeCheckMultiStmtClosureCrash() {
-  callCC { // expected-error {{cannot infer return type for closure with multiple statements; add explicit type to disambiguate}} {{none}}
+  callCC {
     _ = $0
     return 1
   }
@@ -312,24 +312,23 @@ func testAcceptNothingToInt(ac1: @autoclosure () -> Int) {
 struct Thing {
   init?() {}
 }
-// This throws a compiler error
-let things = Thing().map { thing in  // expected-error {{cannot infer return type for closure with multiple statements; add explicit type to disambiguate}} {{34-34=-> <#Result#> }}
-  // Commenting out this makes it compile
+
+let things = Thing().map { thing in
   _ = thing
   return thing
 }
 
 
 // <rdar://problem/21675896> QoI: [Closure return type inference] Swift cannot find members for the result of inlined lambdas with branches
 func r21675896(file : String) {
-  let x: String = { // expected-error {{cannot infer return type for closure with multiple statements; add explicit type to disambiguate}} {{20-20= () -> <#Result#> in }}
+  let x: String = {
     if true {
       return "foo"
     }
     else {
       return file
     }
-  }().pathExtension
+  }().pathExtension // expected-error {{value of type 'String' has no member 'pathExtension'}}
 }
 
 
@@ -360,7 +359,7 @@ func someGeneric19997471<T>(_ x: T) {
 
 
 // <rdar://problem/20921068> Swift fails to compile: [0].map() { _ in let r = (1,2).0; return r }
-[0].map {  // expected-error {{cannot infer return type for closure with multiple statements; add explicit type to disambiguate}} {{5-5=-> <#Result#> }}
+let _ = [0].map {
   _ in
   let r =  (1,2).0
   return r
@@ -408,7 +407,7 @@ func r20789423() {
   print(p.f(p)())  // expected-error {{cannot convert value of type 'C' to expected argument type 'Int'}}
   // expected-error@-1:11 {{cannot call value of non-function type '()'}}
   
-  let _f = { (v: Int) in  // expected-error {{cannot infer return type for closure with multiple statements; add explicit type to disambiguate}} {{23-23=-> <#Result#> }}
+  let _f = { (v: Int) in
     print("a")
     return "hi"
   }
@@ -1127,7 +1126,7 @@ func rdar76058892() {
   func experiment(arr: [S]?) {
     test { // expected-error {{contextual closure type '() -> String' expects 0 arguments, but 1 was used in closure body}}
       if let arr = arr {
-        arr.map($0.test) // expected-note {{anonymous closure parameter '$0' is used here}}
+        arr.map($0.test) // expected-note {{anonymous closure parameter '$0' is used here}} // expected-error {{generic parameter 'T' could not be inferred}}
       }
     }
   }
diff --git a/test/Constraints/diagnostics.swift b/test/Constraints/diagnostics.swift
@@ -148,7 +148,7 @@ func ***~(_: Int, _: String) { }
 i ***~ i // expected-error{{cannot convert value of type 'Int' to expected argument type 'String'}}
 
 @available(*, unavailable, message: "call the 'map()' method on the sequence")
-public func myMap<C : Collection, T>(
+public func myMap<C : Collection, T>( // expected-note {{'myMap' has been explicitly marked unavailable here}}
   _ source: C, _ transform: (C.Iterator.Element) -> T
 ) -> [T] {
   fatalError("unavailable function can't be called")
@@ -161,7 +161,7 @@ public func myMap<T, U>(_ x: T?, _ f: (T) -> U) -> U? {
 
 // <rdar://problem/20142523>
 func rdar20142523() {
-  myMap(0..<10, { x in // expected-error{{cannot infer return type for closure with multiple statements; add explicit type to disambiguate}} {{21-21=-> <#Result#> }} {{educational-notes=complex-closure-inference}}
+  _ = myMap(0..<10, { x in // expected-error {{'myMap' is unavailable: call the 'map()' method on the sequence}}
     ()
     return x
   })
diff --git a/test/Constraints/members.swift b/test/Constraints/members.swift
@@ -595,10 +595,10 @@ func rdar50679161() {
 
   func foo() {
     _ = { () -> Void in
+      // Missing `.self` or `init` is not diagnosed here because there are errors in
+      // `if let` statement and `MiscDiagnostics` only run if the body is completely valid.
       var foo = S
-      // expected-error@-1 {{expected member name or constructor call after type name}}
-      // expected-note@-2 {{add arguments after the type to construct a value of the type}}
-      // expected-note@-3 {{use '.self' to reference the type object}}
+
       if let v = Int?(1) {
         var _ = Q(
           a: v + foo.w,
@@ -610,6 +610,14 @@ func rdar50679161() {
         )
       }
     }
+
+    _ = { () -> Void in
+      var foo = S
+      // expected-error@-1 {{expected member name or constructor call after type name}}
+      // expected-note@-2 {{add arguments after the type to construct a value of the type}}
+      // expected-note@-3 {{use '.self' to reference the type object}}
+      print(foo)
+    }
   }
 }
 
diff --git a/test/Constraints/patterns.swift b/test/Constraints/patterns.swift
@@ -230,14 +230,14 @@ func good(_ a: A<EE>) -> Int {
 }
 
 func bad(_ a: A<EE>) {
-  a.map { // expected-error {{cannot infer return type for closure with multiple statements; add explicit type to disambiguate}} {{none}}
+  let _ = a.map {
     let _: EE = $0
     return 1
   }
 }
 
 func ugly(_ a: A<EE>) {
-  a.map { // expected-error {{cannot infer return type for closure with multiple statements; add explicit type to disambiguate}} {{none}}
+  let _ = a.map {
     switch $0 {
     case .A:
       return 1
diff --git a/test/Constraints/rdar46544601.swift b/test/Constraints/rdar46544601.swift
@@ -26,6 +26,6 @@ func crash(_ p: P, payload: [UInt8]) throws {
     p.foo(arr: arr, data: []).and(result: (id, arr))
   }.then { args0 in
     let (parentID, args1) = args0
-    p.bar(root: parentID, from: p).and(args1)
+    p.bar(root: parentID, from: p).and(result: args1)
   }.whenFailure { _ in }
 }
diff --git a/test/Constraints/rdar65320500.swift b/test/Constraints/rdar65320500.swift
@@ -31,13 +31,13 @@ test_builder {
 test_builder {
   test(doesntExist()) // expected-error {{cannot find 'doesntExist' in scope}}
 
-  if let result = doesntExist() {
+  if let result = doesntExist() { // expected-error {{cannot find 'doesntExist' in scope}}
   }
 
-  if bar = test(42) {}
+  if bar = test(42) {} // expected-error {{cannot find 'bar' in scope}}
 
-  let foo = bar()
+  let foo = bar() // expected-error {{cannot find 'bar' in scope}}
 
-  switch (doesntExist()) {
+  switch (doesntExist()) { // expected-error {{cannot find 'doesntExist' in scope}}
   }
 }
diff --git a/test/Constraints/result_builder_diags.swift b/test/Constraints/result_builder_diags.swift
@@ -78,7 +78,7 @@ struct TupleBuilderWithoutIf { // expected-note 3{{struct 'TupleBuilderWithoutIf
   static func buildDo<T>(_ value: T) -> T { return value }
 }
 
-func tuplify<T>(_ cond: Bool, @TupleBuilder body: (Bool) -> T) {
+func tuplify<T>(_ cond: Bool, @TupleBuilder body: (Bool) -> T) { // expected-note {{in call to function 'tuplify(_:body:)'}}
   print(body(cond))
 }
 
@@ -307,21 +307,6 @@ struct MyTuplifiedStruct {
   }
 }
 
-func test_invalid_return_type_in_body() {
-  tuplify(true) { _ -> (Void, Int) in
-    tuplify(false) { condition in
-      if condition {
-        return 42 // expected-error {{cannot use explicit 'return' statement in the body of result builder 'TupleBuilder'}}
-        // expected-note@-1 {{remove 'return' statements to apply the result builder}} {{9-16=}}
-      } else {
-        1
-      }
-    }
-
-    42
-  }
-}
-
 // Check that we're performing syntactic use diagnostics.
 func acceptMetatype<T>(_: T.Type) -> Bool { true }
 
@@ -481,7 +466,7 @@ struct TestConstraintGenerationErrors {
   func buildTupleClosure() {
     tuplify(true) { _ in
       let a = nothing // expected-error {{cannot find 'nothing' in scope}}
-      String(nothing)
+      String(nothing) // expected-error {{cannot find 'nothing' in scope}}
     }
   }
 }
@@ -522,7 +507,7 @@ enum E3 {
 }
 
 func testCaseMutabilityMismatches(e: E3) {
-    tuplify(true) { c in
+   tuplify(true) { c in // expected-error {{generic parameter 'T' could not be inferred}}
     "testSwitch"
     switch e {
     case .a(let x, var y),
diff --git a/test/Constraints/tuple.swift b/test/Constraints/tuple.swift
@@ -218,14 +218,14 @@ extension r25271859 {
   func map<U>(f: (T) -> U) -> r25271859<U> {
   }
 
-  func andThen<U>(f: (T) -> r25271859<U>) { // expected-note {{in call to function 'andThen(f:)'}}
+  func andThen<U>(f: (T) -> r25271859<U>) {
   }
 }
 
 func f(a : r25271859<(Float, Int)>) {
-  a.map { $0.0 } // expected-error {{generic parameter 'U' could not be inferred}} (This is related to how solver is setup with multiple statements)
+  a.map { $0.0 }
     .andThen { _ in
-      print("hello") // comment this out and it runs, leave any form of print in and it doesn't
+      print("hello")
       return r25271859<String>()
   }
 }
diff --git a/test/Constraints/tuple_arguments.swift b/test/Constraints/tuple_arguments.swift
@@ -1407,25 +1407,41 @@ func processArrayOfFunctions(f1: [((Bool, Bool)) -> ()],
   }
 
   f2.forEach { block in
-  // expected-note@-1 2{{'block' declared here}}
+  // expected-note@-1 {{'block' declared here}}
     block(p) // expected-error {{parameter 'block' expects 2 separate arguments}}
+  }
+
+  f2.forEach { block in
+  // expected-note@-1 {{'block' declared here}}
     block((c, c)) // expected-error {{parameter 'block' expects 2 separate arguments; remove extra parentheses to change tuple into separate arguments}} {{11-12=}} {{16-17=}}
     block(c, c)
   }
 
+  f2.forEach { block in
+    block(c, c)
+  }
+
   f2.forEach { (block: ((Bool, Bool)) -> ()) in
   // expected-error@-1 {{cannot convert value of type '(((Bool, Bool)) -> ()) -> Void' to expected argument type '(@escaping (Bool, Bool) -> ()) throws -> Void'}}
     block(p)
     block((c, c))
-    block(c, c)
+    block(c, c) // expected-error {{parameter 'block' expects a single parameter of type '(Bool, Bool)'}}
   }
 
   f2.forEach { (block: (Bool, Bool) -> ()) in
-  // expected-note@-1 2{{'block' declared here}}
+  // expected-note@-1 {{'block' declared here}}
     block(p) // expected-error {{parameter 'block' expects 2 separate arguments}}
+  }
+
+  f2.forEach { (block: (Bool, Bool) -> ()) in
+    // expected-note@-1 {{'block' declared here}}
     block((c, c)) // expected-error {{parameter 'block' expects 2 separate arguments; remove extra parentheses to change tuple into separate arguments}} {{11-12=}} {{16-17=}}
     block(c, c)
   }
+
+  f2.forEach { (block: (Bool, Bool) -> ()) in
+    block(c, c)
+  }
 }
 
 // expected-error@+1 {{cannot create a single-element tuple with an element label}}
diff --git a/test/Constraints/without_actually_escaping.swift b/test/Constraints/without_actually_escaping.swift
@@ -10,7 +10,7 @@ func escapeX(_ xx: (Int) -> Int, _ value: Int) { // expected-note* {{non-escapin
   withoutActuallyEscaping(xx) { escapableXX in
     x = xx // expected-error{{non-escaping parameter}}
     x = escapableXX
-    x = xx // expected-error{{non-escaping parameter}}
+    x = xx
 
     _ = x(value)
     _ = xx(value)
diff --git a/test/Sema/diag_ambiguous_overloads.swift b/test/Sema/diag_ambiguous_overloads.swift
@@ -132,15 +132,13 @@ func SR12689(_ u: UnsafeBufferPointer<UInt16>) {}
 let array : [UInt16] = [1, 2]
 
 array.withUnsafeBufferPointer {
-  SR12689(UnsafeRawPointer($0).bindMemory(to: UInt16.self, capacity: 1)) // expected-error {{cannot convert value of type 'UnsafePointer<UInt16>' to expected argument type 'UnsafeBufferPointer<UInt16>'}}
-  // expected-error@-1 {{no exact matches in call to initializer}}
-  // expected-note@-2 {{candidate expects value of type 'UnsafeRawPointer' for parameter #1}}
-  // expected-note@-3 {{candidate expects value of type 'UnsafeMutableRawPointer' for parameter #1}}
-
-  UnsafeRawPointer($0) as UnsafeBufferPointer<UInt16> // expected-error {{cannot convert value of type 'UnsafeRawPointer' to type 'UnsafeBufferPointer<UInt16>' in coercion}}
-  // expected-error@-1 {{no exact matches in call to initializer}}
-  // expected-note@-2 {{found candidate with type '(UnsafeRawPointer) -> UnsafeRawPointer'}}
-  // expected-note@-3 {{found candidate with type '(UnsafeMutableRawPointer) -> UnsafeRawPointer'}}
+  _ = SR12689(UnsafeRawPointer($0).bindMemory(to: UInt16.self, capacity: 1)) // expected-error {{cannot convert value of type 'UnsafePointer<UInt16>' to expected argument type 'UnsafeBufferPointer<UInt16>'}}
+  // expected-error@-1 {{cannot convert value of type 'UnsafeBufferPointer<UInt16>' to expected argument type 'UnsafeMutableRawPointer'}}
+}
+
+array.withUnsafeBufferPointer {
+  _ = UnsafeRawPointer($0) as UnsafeBufferPointer<UInt16> // expected-error {{cannot convert value of type 'UnsafeRawPointer' to type 'UnsafeBufferPointer<UInt16>' in coercion}}
+  // expected-error@-1 {{cannot convert value of type 'UnsafeBufferPointer<UInt16>' to expected argument type 'UnsafeMutableRawPointer'}}
 }
 
 func SR12689_1(_ u: Int) -> String { "" } // expected-note {{found this candidate}} expected-note {{candidate expects value of type 'Int' for parameter #1 (got 'Double')}}
diff --git a/test/diagnostics/pretty-printed-diagnostics.swift b/test/diagnostics/pretty-printed-diagnostics.swift
@@ -124,13 +124,6 @@ foo(b:
 // CHECK:             |                ^ note: Remove '=' to make 'x' a computed property [remove '= ' and replace 'let' with 'var']
 // CHECK: [[#LINE+1]] | }
 
-// CHECK: SOURCE_DIR{{[/\]+}}test{{[/\]+}}diagnostics{{[/\]+}}pretty-printed-diagnostics.swift:[[#LINE:]]:9
-// CHECK: [[#LINE-1]] |
-// CHECK: [[#LINE]]   | let x = { () -> Result in
-// CHECK:             |          +++++++++++++++++
-// CHECK:             |         ^ error: cannot infer return type for closure with multiple statements; add explicit type to disambiguate
-// CHECK: [[#LINE+1]] |   let y = 1
-
 // CHECK: SOURCE_DIR{{[/\]+}}test{{[/\]+}}diagnostics{{[/\]+}}pretty-printed-diagnostics.swift:[[#LINE:]]:8
 // CHECK: [[#LINE-1]] |
 // CHECK: [[#LINE]]   | struct B: Decodable {
@@ -149,12 +142,6 @@ foo(b:
 // CHECK:             |                       ^ error: argument 'a' must precede argument 'b' [remove ', a: 2' and insert 'a: 2, ']
 // CHECK: [[#LINE+1]] |
 
-// CHECK: SOURCE_DIR{{[/\]+}}test{{[/\]+}}diagnostics{{[/\]+}}pretty-printed-diagnostics.swift:[[#LINE:]]:20
-// CHECK: [[#LINE-1]] |
-// CHECK: [[#LINE]]   | let 👍👍👍 = {
-// CHECK:    | --> error: cannot infer return type for closure with multiple statements; add explicit type to disambiguate [insert ' () -> <#Result#> in ']
-// CHECK: [[#LINE+1]] |   let y = 1
-
 // CHECK: SOURCE_DIR{{[/\]+}}test{{[/\]+}}diagnostics{{[/\]+}}pretty-printed-diagnostics.swift:[[#LINE:]]:5
 // CHECK: [[#LINE-2]] | // Multi-line fix-its
 // CHECK: [[#LINE-1]] | foo(a: 2, b: 1,
diff --git a/test/expr/closure/anonymous.swift b/test/expr/closure/anonymous.swift
@@ -29,11 +29,7 @@ func variadic() {
 
   takesVariadicGeneric({takesIntArray($0)})
 
-  // FIXME: Problem here is related to multi-statement closure body not being type-checked together with
-  // enclosing context. We could have inferred `$0` to be `[Int]` if `let` was a part of constraint system.
   takesVariadicGeneric({let _: [Int] = $0})
-  // expected-error@-1 {{unable to infer type of a closure parameter '$0' in the current context}}
-
   takesVariadicIntInt({_ = $0; takesIntArray($1)})
   takesVariadicIntInt({_ = $0; let _: [Int] = $1})
 }
diff --git a/test/expr/closure/closures.swift b/test/expr/closure/closures.swift
@@ -120,9 +120,8 @@ var selfRef = { selfRef() }
 // expected-note@-1 2{{through reference here}}
 // expected-error@-2 {{circular reference}}
 
-var nestedSelfRef = {
+var nestedSelfRef = { // expected-error {{circular reference}} expected-note 2 {{through reference here}}
   var recursive = { nestedSelfRef() }
-  // expected-warning@-1 {{variable 'recursive' was never mutated; consider changing to 'let' constant}}
   recursive()
 }
 
@@ -140,12 +139,11 @@ func anonymousClosureArgsInClosureWithArgs() {
   var a3 = { (z: Int) in $0 } // expected-error {{anonymous closure arguments cannot be used inside a closure that has explicit arguments; did you mean 'z'?}} {{26-28=z}}
   var a4 = { (z: [Int], w: [Int]) in
     f($0.count) // expected-error {{anonymous closure arguments cannot be used inside a closure that has explicit arguments; did you mean 'z'?}} {{7-9=z}} expected-error {{cannot convert value of type 'Int' to expected argument type 'String'}}
-    f($1.count) // expected-error {{anonymous closure arguments cannot be used inside a closure that has explicit arguments; did you mean 'w'?}} {{7-9=w}} expected-error {{cannot convert value of type 'Int' to expected argument type 'String'}}
+    f($1.count) // expected-error {{anonymous closure arguments cannot be used inside a closure that has explicit arguments; did you mean 'w'?}} {{7-9=w}}
   }
   var a5 = { (_: [Int], w: [Int]) in
     f($0.count) // expected-error {{anonymous closure arguments cannot be used inside a closure that has explicit arguments}}
     f($1.count) // expected-error {{anonymous closure arguments cannot be used inside a closure that has explicit arguments; did you mean 'w'?}} {{7-9=w}}
-    // expected-error@-1 {{cannot convert value of type 'Int' to expected argument type 'String'}}
   }
 }
 
@@ -403,7 +401,7 @@ Void(0) // expected-error{{argument passed to call that takes no arguments}}
 _ = {0}
 
 // <rdar://problem/22086634> "multi-statement closures require an explicit return type" should be an error not a note
-let samples = {   // expected-error {{cannot infer return type for closure with multiple statements; add explicit type to disambiguate}} {{16-16= () -> <#Result#> in }}
+let samples = {
           if (i > 10) { return true }
           else { return false }
         }()
@@ -485,8 +483,8 @@ func lvalueCapture<T>(c: GenericClass<T>) {
 }
 
 // Don't expose @lvalue-ness in diagnostics.
-let closure = { // expected-error {{cannot infer return type for closure with multiple statements; add explicit type to disambiguate}} {{16-16= () -> <#Result#> in }}
-  var helper = true
+let closure = {
+  var helper = true // expected-warning {{variable 'helper' was never mutated; consider changing to 'let' constant}}
   return helper
 }
 
diff --git a/test/expr/closure/inference.swift b/test/expr/closure/inference.swift
@@ -34,10 +34,9 @@ func unnamed() {
 // Regression tests.
 
 var nestedClosuresWithBrokenInference = { f: Int in {} }
-    // expected-error@-1 {{closure expression is unused}} expected-note@-1 {{did you mean to use a 'do' statement?}} {{53-53=do }}
-    // expected-error@-2 {{consecutive statements on a line must be separated by ';'}} {{44-44=;}}
-    // expected-error@-3 {{expected expression}}
-    // expected-error@-4 {{cannot find 'f' in scope}}
+    // expected-error@-1 {{consecutive statements on a line must be separated by ';'}} {{44-44=;}}
+    // expected-error@-2 {{expected expression}}
+    // expected-error@-3 {{cannot find 'f' in scope}}
 
 // SR-11540
 
diff --git a/test/expr/closure/let.swift b/test/expr/closure/let.swift
diff --git a/test/expr/expressions.swift b/test/expr/expressions.swift
diff --git a/test/expr/unary/keypath/keypath.swift b/test/expr/unary/keypath/keypath.swift
diff --git a/test/stmt/statements.swift b/test/stmt/statements.swift
diff --git a/validation-test/compiler_crashers_2_fixed/0119-rdar33613329.swift b/validation-test/compiler_crashers_2_fixed/0119-rdar33613329.swift

Original file line number	Diff line number	Diff line change
`@@ -252,7 +252,7 @@ struct CC {}`
`252`	`252`	`func callCC<U>(_ f: (CC) -> U) -> () {}`
`253`	`253`
`254`	`254`	`func typeCheckMultiStmtClosureCrash() {`
`255`		`- callCC { // expected-error {{cannot infer return type for closure with multiple statements; add explicit type to disambiguate}} {{none}}`
	`255`	`+ callCC {`
`256`	`256`	`_ = $0`
`257`	`257`	`return 1`
`258`	`258`	`}`
`@@ -312,24 +312,23 @@ func testAcceptNothingToInt(ac1: @autoclosure () -> Int) {`
`312`	`312`	`struct Thing {`
`313`	`313`	`init?() {}`
`314`	`314`	`}`
`315`		`-// This throws a compiler error`
`316`		`-let things = Thing().map { thing in // expected-error {{cannot infer return type for closure with multiple statements; add explicit type to disambiguate}} {{34-34=-> <#Result#> }}`
`317`		`- // Commenting out this makes it compile`
	`315`	`+`
	`316`	`+let things = Thing().map { thing in`
`318`	`317`	`_ = thing`
`319`	`318`	`return thing`
`320`	`319`	`}`
`321`	`320`
`322`	`321`
`323`	`322`	`// <rdar://problem/21675896> QoI: [Closure return type inference] Swift cannot find members for the result of inlined lambdas with branches`
`324`	`323`	`func r21675896(file : String) {`
`325`		`- let x: String = { // expected-error {{cannot infer return type for closure with multiple statements; add explicit type to disambiguate}} {{20-20= () -> <#Result#> in }}`
	`324`	`+ let x: String = {`
`326`	`325`	`if true {`
`327`	`326`	`return "foo"`
`328`	`327`	`}`
`329`	`328`	`else {`
`330`	`329`	`return file`
`331`	`330`	`}`
`332`		`- }().pathExtension`
	`331`	`+ }().pathExtension // expected-error {{value of type 'String' has no member 'pathExtension'}}`
`333`	`332`	`}`
`334`	`333`
`335`	`334`
`@@ -360,7 +359,7 @@ func someGeneric19997471<T>(_ x: T) {`
`360`	`359`
`361`	`360`
`362`	`361`	`// <rdar://problem/20921068> Swift fails to compile: [0].map() { _ in let r = (1,2).0; return r }`
`363`		`-[0].map { // expected-error {{cannot infer return type for closure with multiple statements; add explicit type to disambiguate}} {{5-5=-> <#Result#> }}`
	`362`	`+let _ = [0].map {`
`364`	`363`	`_ in`
`365`	`364`	`let r = (1,2).0`
`366`	`365`	`return r`
`@@ -408,7 +407,7 @@ func r20789423() {`
`408`	`407`	`print(p.f(p)()) // expected-error {{cannot convert value of type 'C' to expected argument type 'Int'}}`
`409`	`408`	`// expected-error@-1:11 {{cannot call value of non-function type '()'}}`
`410`	`409`
`411`		`- let _f = { (v: Int) in // expected-error {{cannot infer return type for closure with multiple statements; add explicit type to disambiguate}} {{23-23=-> <#Result#> }}`
	`410`	`+ let _f = { (v: Int) in`
`412`	`411`	`print("a")`
`413`	`412`	`return "hi"`
`414`	`413`	`}`
`@@ -1127,7 +1126,7 @@ func rdar76058892() {`
`1127`	`1126`	`func experiment(arr: [S]?) {`
`1128`	`1127`	`test { // expected-error {{contextual closure type '() -> String' expects 0 arguments, but 1 was used in closure body}}`
`1129`	`1128`	`if let arr = arr {`
`1130`		`- arr.map($0.test) // expected-note {{anonymous closure parameter '$0' is used here}}`
	`1129`	`+ arr.map($0.test) // expected-note {{anonymous closure parameter '$0' is used here}} // expected-error {{generic parameter 'T' could not be inferred}}`
`1131`	`1130`	`}`
`1132`	`1131`	`}`
`1133`	`1132`	`}`
Original file line number	Diff line number	Diff line change
`@@ -595,10 +595,10 @@ func rdar50679161() {`
`595`	`595`
`596`	`596`	`func foo() {`
`597`	`597`	`_ = { () -> Void in`
	`598`	+ // Missing `.self` or `init` is not diagnosed here because there are errors in
	`599`	+ // `if let` statement and `MiscDiagnostics` only run if the body is completely valid.
`598`	`600`	`var foo = S`
`599`		`- // expected-error@-1 {{expected member name or constructor call after type name}}`
`600`		`- // expected-note@-2 {{add arguments after the type to construct a value of the type}}`
`601`		`- // expected-note@-3 {{use '.self' to reference the type object}}`
	`601`	`+`
`602`	`602`	`if let v = Int?(1) {`
`603`	`603`	`var _ = Q(`
`604`	`604`	`a: v + foo.w,`
`@@ -610,6 +610,14 @@ func rdar50679161() {`
`610`	`610`	`)`
`611`	`611`	`}`
`612`	`612`	`}`
	`613`	`+`
	`614`	`+ _ = { () -> Void in`
	`615`	`+ var foo = S`
	`616`	`+ // expected-error@-1 {{expected member name or constructor call after type name}}`
	`617`	`+ // expected-note@-2 {{add arguments after the type to construct a value of the type}}`
	`618`	`+ // expected-note@-3 {{use '.self' to reference the type object}}`
	`619`	`+ print(foo)`
	`620`	`+ }`
`613`	`621`	`}`
`614`	`622`	`}`
`615`	`623`
Original file line number	Diff line number	Diff line change
`@@ -230,14 +230,14 @@ func good(_ a: A<EE>) -> Int {`
`230`	`230`	`}`
`231`	`231`
`232`	`232`	`func bad(_ a: A<EE>) {`
`233`		`- a.map { // expected-error {{cannot infer return type for closure with multiple statements; add explicit type to disambiguate}} {{none}}`
	`233`	`+ let _ = a.map {`
`234`	`234`	`let _: EE = $0`
`235`	`235`	`return 1`
`236`	`236`	`}`
`237`	`237`	`}`
`238`	`238`
`239`	`239`	`func ugly(_ a: A<EE>) {`
`240`		`- a.map { // expected-error {{cannot infer return type for closure with multiple statements; add explicit type to disambiguate}} {{none}}`
	`240`	`+ let _ = a.map {`
`241`	`241`	`switch $0 {`
`242`	`242`	`case .A:`
`243`	`243`	`return 1`
Original file line number	Diff line number	Diff line change
`@@ -26,6 +26,6 @@ func crash(_ p: P, payload: [UInt8]) throws {`
`26`	`26`	`p.foo(arr: arr, data: []).and(result: (id, arr))`
`27`	`27`	`}.then { args0 in`
`28`	`28`	`let (parentID, args1) = args0`
`29`		`- p.bar(root: parentID, from: p).and(args1)`
	`29`	`+ p.bar(root: parentID, from: p).and(result: args1)`
`30`	`30`	`}.whenFailure { _ in }`
`31`	`31`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,13 +31,13 @@ test_builder {`
`31`	`31`	`test_builder {`
`32`	`32`	`test(doesntExist()) // expected-error {{cannot find 'doesntExist' in scope}}`
`33`	`33`
`34`		`- if let result = doesntExist() {`
	`34`	`+ if let result = doesntExist() { // expected-error {{cannot find 'doesntExist' in scope}}`
`35`	`35`	`}`
`36`	`36`
`37`		`- if bar = test(42) {}`
	`37`	`+ if bar = test(42) {} // expected-error {{cannot find 'bar' in scope}}`
`38`	`38`
`39`		`- let foo = bar()`
	`39`	`+ let foo = bar() // expected-error {{cannot find 'bar' in scope}}`
`40`	`40`
`41`		`- switch (doesntExist()) {`
	`41`	`+ switch (doesntExist()) { // expected-error {{cannot find 'doesntExist' in scope}}`
`42`	`42`	`}`
`43`	`43`	`}`
Original file line number	Diff line number	Diff line change
`@@ -78,7 +78,7 @@ struct TupleBuilderWithoutIf { // expected-note 3{{struct 'TupleBuilderWithoutIf`
`78`	`78`	`static func buildDo<T>(_ value: T) -> T { return value }`
`79`	`79`	`}`
`80`	`80`
`81`		`-func tuplify<T>(_ cond: Bool, @TupleBuilder body: (Bool) -> T) {`
	`81`	`+func tuplify<T>(_ cond: Bool, @TupleBuilder body: (Bool) -> T) { // expected-note {{in call to function 'tuplify(_:body:)'}}`
`82`	`82`	`print(body(cond))`
`83`	`83`	`}`
`84`	`84`
`@@ -307,21 +307,6 @@ struct MyTuplifiedStruct {`
`307`	`307`	`}`
`308`	`308`	`}`
`309`	`309`
`310`		`-func test_invalid_return_type_in_body() {`
`311`		`- tuplify(true) { _ -> (Void, Int) in`
`312`		`- tuplify(false) { condition in`
`313`		`- if condition {`
`314`		`- return 42 // expected-error {{cannot use explicit 'return' statement in the body of result builder 'TupleBuilder'}}`
`315`		`- // expected-note@-1 {{remove 'return' statements to apply the result builder}} {{9-16=}}`
`316`		`- } else {`
`317`		`- 1`
`318`		`- }`
`319`		`- }`
`320`		`-`
`321`		`- 42`
`322`		`- }`
`323`		`-}`
`324`		`-`
`325`	`310`	`// Check that we're performing syntactic use diagnostics.`
`326`	`311`	`func acceptMetatype<T>(_: T.Type) -> Bool { true }`
`327`	`312`
`@@ -481,7 +466,7 @@ struct TestConstraintGenerationErrors {`
`481`	`466`	`func buildTupleClosure() {`
`482`	`467`	`tuplify(true) { _ in`
`483`	`468`	`let a = nothing // expected-error {{cannot find 'nothing' in scope}}`
`484`		`- String(nothing)`
	`469`	`+ String(nothing) // expected-error {{cannot find 'nothing' in scope}}`
`485`	`470`	`}`
`486`	`471`	`}`
`487`	`472`	`}`
`@@ -522,7 +507,7 @@ enum E3 {`
`522`	`507`	`}`
`523`	`508`
`524`	`509`	`func testCaseMutabilityMismatches(e: E3) {`
`525`		`- tuplify(true) { c in`
	`510`	`+ tuplify(true) { c in // expected-error {{generic parameter 'T' could not be inferred}}`
`526`	`511`	`"testSwitch"`
`527`	`512`	`switch e {`
`528`	`513`	`case .a(let x, var y),`
Original file line number	Diff line number	Diff line change
`@@ -218,14 +218,14 @@ extension r25271859 {`
`218`	`218`	`func map<U>(f: (T) -> U) -> r25271859<U> {`
`219`	`219`	`}`
`220`	`220`
`221`		`- func andThen<U>(f: (T) -> r25271859<U>) { // expected-note {{in call to function 'andThen(f:)'}}`
	`221`	`+ func andThen<U>(f: (T) -> r25271859<U>) {`
`222`	`222`	`}`
`223`	`223`	`}`
`224`	`224`
`225`	`225`	`func f(a : r25271859<(Float, Int)>) {`
`226`		`- a.map { $0.0 } // expected-error {{generic parameter 'U' could not be inferred}} (This is related to how solver is setup with multiple statements)`
	`226`	`+ a.map { $0.0 }`
`227`	`227`	`.andThen { _ in`
`228`		`- print("hello") // comment this out and it runs, leave any form of print in and it doesn't`
	`228`	`+ print("hello")`
`229`	`229`	`return r25271859<String>()`
`230`	`230`	`}`
`231`	`231`	`}`