test/Parse/try_swift5.swift - third_party/swift - Git at Google

 // RUN: %target-typecheck-verify-swift -swift-version 5

 // Intentionally has lower precedence than assignments and ?:
 infix operator %%%% : LowPrecedence
 precedencegroup LowPrecedence {
   associativity: none
   lowerThan: AssignmentPrecedence
 }
 func %%%%<T, U>(x: T, y: U) -> Int { return 0 }

 // Intentionally has lower precedence between assignments and ?:
 infix operator %%% : MiddlingPrecedence
 precedencegroup MiddlingPrecedence {
   associativity: none
   higherThan: AssignmentPrecedence
   lowerThan: TernaryPrecedence
 }
 func %%%<T, U>(x: T, y: U) -> Int { return 1 }

 func foo() throws -> Int { return 0 }
 func bar() throws -> Int { return 0 }

 var x = try foo() + bar()
 x = try foo() + bar()
 x += try foo() + bar()
 x += try foo() %%%% bar() // expected-error {{'try' following assignment operator does not cover everything to its right}} // expected-error {{call can throw but is not marked with 'try'}} // expected-warning {{result of operator '%%%%' is unused}}
                           // expected-note@-1 {{did you mean to use 'try'?}} {{21-21=try }}
                           // expected-note@-2 {{did you mean to handle error as optional value?}} {{21-21=try? }}
                           // expected-note@-3 {{did you mean to disable error propagation?}} {{21-21=try! }}
 x += try foo() %%% bar()
 x = foo() + try bar() // expected-error {{'try' cannot appear to the right of a non-assignment operator}} // expected-error {{call can throw but is not marked with 'try'}}
                       // expected-note@-1 {{did you mean to use 'try'?}} {{5-5=try }}
                       // expected-note@-2 {{did you mean to handle error as optional value?}} {{5-5=try? }}
                       // expected-note@-3 {{did you mean to disable error propagation?}} {{5-5=try! }}

 var y = true ? try foo() : try bar() + 0
 var z = true ? try foo() : try bar() %%% 0 // expected-error {{'try' following conditional operator does not cover everything to its right}}

 var a = try! foo() + bar()
 a = try! foo() + bar()
 a += try! foo() + bar()
 a += try! foo() %%%% bar() // expected-error {{'try!' following assignment operator does not cover everything to its right}} // expected-error {{call can throw but is not marked with 'try'}} // expected-warning {{result of operator '%%%%' is unused}}
                            // expected-note@-1 {{did you mean to use 'try'?}} {{22-22=try }}
                            // expected-note@-2 {{did you mean to handle error as optional value?}} {{22-22=try? }}
                            // expected-note@-3 {{did you mean to disable error propagation?}} {{22-22=try! }}
 a += try! foo() %%% bar()
 a = foo() + try! bar() // expected-error {{'try!' cannot appear to the right of a non-assignment operator}} // expected-error {{call can throw but is not marked with 'try'}}
                        // expected-note@-1 {{did you mean to use 'try'?}} {{5-5=try }}
                        // expected-note@-2 {{did you mean to handle error as optional value?}} {{5-5=try? }}
                        // expected-note@-3 {{did you mean to disable error propagation?}} {{5-5=try! }}

 var b = true ? try! foo() : try! bar() + 0
 var c = true ? try! foo() : try! bar() %%% 0 // expected-error {{'try!' following conditional operator does not cover everything to its right}}

 infix operator ?+= : AssignmentPrecedence
 func ?+=(lhs: inout Int?, rhs: Int?) {
   lhs = lhs! + rhs!
 }

 var i = try? foo() + bar()
 let _: Double = i // expected-error {{cannot convert value of type 'Int?' to specified type 'Double'}}
 i = try? foo() + bar()
 i ?+= try? foo() + bar()
 i ?+= try? foo() %%%% bar() // expected-error {{'try?' following assignment operator does not cover everything to its right}} // expected-error {{call can throw but is not marked with 'try'}} // expected-warning {{result of operator '%%%%' is unused}}
                             // expected-note@-1 {{did you mean to use 'try'?}} {{23-23=try }}
                             // expected-note@-2 {{did you mean to handle error as optional value?}} {{23-23=try? }}
                             // expected-note@-3 {{did you mean to disable error propagation?}} {{23-23=try! }}
 i ?+= try? foo() %%% bar()
 _ = foo() == try? bar() // expected-error {{'try?' cannot appear to the right of a non-assignment operator}} // expected-error {{call can throw but is not marked with 'try'}}
                         // expected-note@-1 {{did you mean to use 'try'?}} {{5-5=try }}
                         // expected-note@-2 {{did you mean to handle error as optional value?}} {{5-5=try? }}
                         // expected-note@-3 {{did you mean to disable error propagation?}} {{5-5=try! }}
 _ = (try? foo()) == bar() // expected-error {{call can throw but is not marked with 'try'}}
                           // expected-note@-1 {{did you mean to use 'try'?}} {{21-21=try }}
                           // expected-note@-2 {{did you mean to handle error as optional value?}} {{21-21=try? }}
                           // expected-note@-3 {{did you mean to disable error propagation?}} {{21-21=try! }}
 _ = foo() == (try? bar()) // expected-error {{call can throw but is not marked with 'try'}}
                           // expected-note@-1 {{did you mean to use 'try'?}} {{5-5=try }}
                           // expected-note@-2 {{did you mean to handle error as optional value?}} {{5-5=try? }}
                           // expected-note@-3 {{did you mean to disable error propagation?}} {{5-5=try! }}
 _ = (try? foo()) == (try? bar())

 let j = true ? try? foo() : try? bar() + 0
 let k = true ? try? foo() : try? bar() %%% 0 // expected-error {{'try?' following conditional operator does not cover everything to its right}}

 try let singleLet = foo() // expected-error {{'try' must be placed on the initial value expression}} {{1-5=}} {{21-21=try }}
 try var singleVar = foo() // expected-error {{'try' must be placed on the initial value expression}} {{1-5=}} {{21-21=try }}
 try let uninit: Int // expected-error {{'try' must be placed on the initial value expression}}
 try let (destructure1, destructure2) = (foo(), bar()) // expected-error {{'try' must be placed on the initial value expression}} {{1-5=}} {{40-40=try }}
 try let multi1 = foo(), multi2 = bar() // expected-error {{'try' must be placed on the initial value expression}} expected-error 2 {{call can throw but is not marked with 'try'}}
                                        // expected-note@-1 {{did you mean to use 'try'?}} {{18-18=try }} expected-note@-1 {{did you mean to use 'try'?}} {{34-34=try }}
                                        // expected-note@-2 {{did you mean to handle error as optional value?}} {{18-18=try? }} expected-note@-2 {{did you mean to handle error as optional value?}} {{34-34=try? }}
                                        // expected-note@-3 {{did you mean to disable error propagation?}} {{18-18=try! }} expected-note@-3 {{did you mean to disable error propagation?}} {{34-34=try! }}
 class TryDecl { // expected-note {{in declaration of 'TryDecl'}}
   try let singleLet = foo() // expected-error {{'try' must be placed on the initial value expression}} {{3-7=}} {{23-23=try }}
                             // expected-error @-1 {{call can throw, but errors cannot be thrown out of a property initializer}}
   try var singleVar = foo() // expected-error {{'try' must be placed on the initial value expression}} {{3-7=}} {{23-23=try }}
                             // expected-error @-1 {{call can throw, but errors cannot be thrown out of a property initializer}}

   try // expected-error {{expected declaration}}
   func method() {}
 }

 func test() throws -> Int {
   try while true { // expected-error {{'try' cannot be used with 'while'}}
     try break // expected-error {{'try' cannot be used with 'break'}}
   }

   try throw // expected-error {{'try' must be placed on the thrown expression}} {{3-7=}} {{3-3=try }} expected-error {{expected expression in 'throw' statement}}
   ; // Reset parser.

   try return // expected-error {{'try' cannot be used with 'return'}} expected-error {{non-void function should return a value}}
   ; // Reset parser.

   try throw foo() // expected-error {{'try' must be placed on the thrown expression}} {{3-7=}} {{13-13=try }}
   // expected-error@-1 {{thrown expression type 'Int' does not conform to 'Error'}}
   try return foo() // expected-error {{'try' must be placed on the returned expression}} {{3-7=}} {{14-14=try }}
 }

 // Test operators.
 func *(a : String, b : String) throws -> Int { return 42 }
 let _ = "foo"
         *  // expected-error {{operator can throw but expression is not marked with 'try'}}
            // expected-note@-1 {{did you mean to use 'try'?}} {{9-9=try }}
            // expected-note@-2 {{did you mean to handle error as optional value?}} {{9-9=try? }}
            // expected-note@-3 {{did you mean to disable error propagation?}} {{9-9=try! }}
         "bar"
 let _ = try! "foo"*"bar"
 let _ = try? "foo"*"bar"
 let _ = (try? "foo"*"bar") ?? 0


 // <rdar://problem/21414023> Assertion failure when compiling function that takes throwing functions and rethrows
 func rethrowsDispatchError(handleError: ((Error) throws -> ()), body: () throws -> ()) rethrows {
   do {
     body()   // expected-error {{call can throw but is not marked with 'try'}}
              // expected-note@-1 {{did you mean to use 'try'?}} {{5-5=try }}
              // expected-note@-2 {{did you mean to handle error as optional value?}} {{5-5=try? }}
              // expected-note@-3 {{did you mean to disable error propagation?}} {{5-5=try! }}
   } catch {
   }
 }

 // <rdar://problem/21432429> Calling rethrows from rethrows crashes Swift compiler
 struct r21432429 {
   func x(_ f: () throws -> ()) rethrows {}
   func y(_ f: () throws -> ()) rethrows {
     x(f)  // expected-error {{call can throw but is not marked with 'try'}} expected-note {{call is to 'rethrows' function, but argument function can throw}}
   }
 }

 // <rdar://problem/21427855> Swift 2: Omitting try from call to throwing closure in rethrowing function crashes compiler
 func callThrowingClosureWithoutTry(closure: (Int) throws -> Int) rethrows {
   closure(0)  // expected-error {{call can throw but is not marked with 'try'}} expected-warning {{result of call to function returning 'Int' is unused}}
               // expected-note@-1 {{did you mean to use 'try'?}} {{3-3=try }}
               // expected-note@-2 {{did you mean to handle error as optional value?}} {{3-3=try? }}
               // expected-note@-3 {{did you mean to disable error propagation?}} {{3-3=try! }}
 }

 func producesOptional() throws -> Int? { return nil }
 let singleOptional = try? producesOptional()
 let _: String = singleOptional // expected-error {{cannot convert value of type 'Int?' to specified type 'String'}}

 let _ = (try? foo())!! // expected-error {{cannot force unwrap value of non-optional type 'Int'}}

 func producesDoubleOptional() throws -> Int?? { return 3 }
 let _: String = try? producesDoubleOptional() // expected-error {{cannot convert value of type 'Int??' to specified type 'String'}}

 func maybeThrow() throws {}
 try maybeThrow() // okay
 try! maybeThrow() // okay
 try? maybeThrow() // okay since return type of maybeThrow is Void
 _ = try? maybeThrow() // okay

 let _: () -> Void = { try! maybeThrow() } // okay
 let _: () -> Void = { try? maybeThrow() } // okay since return type of maybeThrow is Void


 if try? maybeThrow() { // expected-error {{cannot be used as a boolean}} {{4-4=((}} {{21-21=) != nil)}}
 }
 let _: Int = try? foo() // expected-error {{value of optional type 'Int?' not unwrapped; did you mean to use 'try!' or chain with '?'?}} {{14-18=try!}}

 class X {}
 func test(_: X) {}
 func producesObject() throws -> AnyObject { return X() }
 test(try producesObject()) // expected-error {{'AnyObject' is not convertible to 'X'; did you mean to use 'as!' to force downcast?}} {{26-26= as! X}}

 _ = "a\(try maybeThrow())b"
 _ = try "a\(maybeThrow())b"
 _ = "a\(maybeThrow())" // expected-error {{call can throw but is not marked with 'try'}}
               // expected-note@-1 {{did you mean to use 'try'?}} {{9-9=try }}
               // expected-note@-2 {{did you mean to handle error as optional value?}} {{9-9=try? }}
               // expected-note@-3 {{did you mean to disable error propagation?}} {{9-9=try! }}

 extension DefaultStringInterpolation {
   mutating func appendInterpolation() throws {}
 }

 _ = try "a\()b"
 _ = "a\()b" // expected-error {{interpolation can throw but is not marked with 'try'}}
               // expected-note@-1 {{did you mean to use 'try'?}} {{5-5=try }}
               // expected-note@-2 {{did you mean to handle error as optional value?}} {{5-5=try? }}
               // expected-note@-3 {{did you mean to disable error propagation?}} {{5-5=try! }}
 _ = try "\() \(1)"

 func testGenericOptionalTry<T>(_ call: () throws -> T ) {
   let _: String = try? call() // expected-error {{cannot convert value of type 'T?' to specified type 'String'}}
 }

 func genericOptionalTry<T>(_ call: () throws -> T ) -> T? {
   let x = try? call() // no error expected
   return x
 }

 // Test with a non-optional type
 let _: String = genericOptionalTry({ () throws -> Int in return 3 }) // expected-error {{cannot convert value of type 'Int?' to specified type 'String'}}

 // Test with an optional type
 let _: String = genericOptionalTry({ () throws -> Int? in return nil }) // expected-error {{cannot convert value of type 'Int??' to specified type 'String'}}

 func produceAny() throws -> Any {
   return 3
 }

 let _: Int? = try? produceAny() as? Int // good
 let _: Int? = (try? produceAny()) as? Int // good
 let _: String = try? produceAny() as? Int // expected-error {{cannot convert value of type 'Int?' to specified type 'String'}}
 let _: String = (try? produceAny()) as? Int // expected-error {{cannot convert value of type 'Int?' to specified type 'String'}}


 struct ThingProducer {
   func produceInt() throws -> Int { return 3 }
   func produceIntNoThrowing() -> Int { return 3 }
   func produceAny() throws -> Any { return 3 }
   func produceOptionalAny() throws -> Any? { return 3 }
   func produceDoubleOptionalInt() throws -> Int?? { return 3 }
 }

 let optProducer: ThingProducer? = ThingProducer()
 let _: Int? = try? optProducer?.produceInt()
 let _: Int = try? optProducer?.produceInt() // expected-error {{cannot convert value of type 'Int?' to specified type 'Int'}}
 let _: String = try? optProducer?.produceInt() // expected-error {{cannot convert value of type 'Int?' to specified type 'String'}}
 let _: Int?? = try? optProducer?.produceInt() // This was the expected type before Swift 5, but this still works; just adds more optional-ness

 let _: Int? = try? optProducer?.produceIntNoThrowing() // expected-warning {{no calls to throwing functions occur within 'try' expression}}

 let _: Int? = (try? optProducer?.produceAny()) as? Int // good
 let _: Int? = try? optProducer?.produceAny() as? Int // good
 let _: Int?? = try? optProducer?.produceAny() as? Int // good
 let _: String = try? optProducer?.produceAny() as? Int // expected-error {{cannot convert value of type 'Int?' to specified type 'String'}}

 let _: String = try? optProducer?.produceDoubleOptionalInt() // expected-error {{cannot convert value of type 'Int??' to specified type 'String'}}

 let producer = ThingProducer()

 let _: Int = try? producer.produceDoubleOptionalInt() // expected-error {{cannot convert value of type 'Int??' to specified type 'Int'}}

 // We don't offer 'try!' here because it would not change the type of the expression in Swift 5+
 let _: Int? = try? producer.produceDoubleOptionalInt() // expected-error {{cannot convert value of type 'Int??' to specified type 'Int?'}}

 let _: Int?? = try? producer.produceDoubleOptionalInt() // good
 let _: Int??? = try? producer.produceDoubleOptionalInt() // good
 let _: String = try? producer.produceDoubleOptionalInt() // expected-error {{cannot convert value of type 'Int??' to specified type 'String'}}

 // rdar://problem/46742002
 protocol Dummy : class {}

 class F<T> {
   func wait() throws -> T { fatalError() }
 }

 func bar(_ a: F<Dummy>, _ b: F<Dummy>) {
   _ = (try? a.wait()) === (try? b.wait())
 }
	// RUN: %target-typecheck-verify-swift -swift-version 5

	// Intentionally has lower precedence than assignments and ?:
	infix operator %%%% : LowPrecedence
	precedencegroup LowPrecedence {
	associativity: none
	lowerThan: AssignmentPrecedence
	}
	func %%%%<T, U>(x: T, y: U) -> Int { return 0 }

	// Intentionally has lower precedence between assignments and ?:
	infix operator %%% : MiddlingPrecedence
	precedencegroup MiddlingPrecedence {
	associativity: none
	higherThan: AssignmentPrecedence
	lowerThan: TernaryPrecedence
	}
	func %%%<T, U>(x: T, y: U) -> Int { return 1 }

	func foo() throws -> Int { return 0 }
	func bar() throws -> Int { return 0 }

	var x = try foo() + bar()
	x = try foo() + bar()
	x += try foo() + bar()
	x += try foo() %%%% bar() // expected-error {{'try' following assignment operator does not cover everything to its right}} // expected-error {{call can throw but is not marked with 'try'}} // expected-warning {{result of operator '%%%%' is unused}}
	// expected-note@-1 {{did you mean to use 'try'?}} {{21-21=try }}
	// expected-note@-2 {{did you mean to handle error as optional value?}} {{21-21=try? }}
	// expected-note@-3 {{did you mean to disable error propagation?}} {{21-21=try! }}
	x += try foo() %%% bar()
	x = foo() + try bar() // expected-error {{'try' cannot appear to the right of a non-assignment operator}} // expected-error {{call can throw but is not marked with 'try'}}
	// expected-note@-1 {{did you mean to use 'try'?}} {{5-5=try }}
	// expected-note@-2 {{did you mean to handle error as optional value?}} {{5-5=try? }}
	// expected-note@-3 {{did you mean to disable error propagation?}} {{5-5=try! }}

	var y = true ? try foo() : try bar() + 0
	var z = true ? try foo() : try bar() %%% 0 // expected-error {{'try' following conditional operator does not cover everything to its right}}

	var a = try! foo() + bar()
	a = try! foo() + bar()
	a += try! foo() + bar()
	a += try! foo() %%%% bar() // expected-error {{'try!' following assignment operator does not cover everything to its right}} // expected-error {{call can throw but is not marked with 'try'}} // expected-warning {{result of operator '%%%%' is unused}}
	// expected-note@-1 {{did you mean to use 'try'?}} {{22-22=try }}
	// expected-note@-2 {{did you mean to handle error as optional value?}} {{22-22=try? }}
	// expected-note@-3 {{did you mean to disable error propagation?}} {{22-22=try! }}
	a += try! foo() %%% bar()
	a = foo() + try! bar() // expected-error {{'try!' cannot appear to the right of a non-assignment operator}} // expected-error {{call can throw but is not marked with 'try'}}
	// expected-note@-1 {{did you mean to use 'try'?}} {{5-5=try }}
	// expected-note@-2 {{did you mean to handle error as optional value?}} {{5-5=try? }}
	// expected-note@-3 {{did you mean to disable error propagation?}} {{5-5=try! }}

	var b = true ? try! foo() : try! bar() + 0
	var c = true ? try! foo() : try! bar() %%% 0 // expected-error {{'try!' following conditional operator does not cover everything to its right}}

	infix operator ?+= : AssignmentPrecedence
	func ?+=(lhs: inout Int?, rhs: Int?) {
	lhs = lhs! + rhs!
	}

	var i = try? foo() + bar()
	let _: Double = i // expected-error {{cannot convert value of type 'Int?' to specified type 'Double'}}
	i = try? foo() + bar()
	i ?+= try? foo() + bar()
	i ?+= try? foo() %%%% bar() // expected-error {{'try?' following assignment operator does not cover everything to its right}} // expected-error {{call can throw but is not marked with 'try'}} // expected-warning {{result of operator '%%%%' is unused}}
	// expected-note@-1 {{did you mean to use 'try'?}} {{23-23=try }}
	// expected-note@-2 {{did you mean to handle error as optional value?}} {{23-23=try? }}
	// expected-note@-3 {{did you mean to disable error propagation?}} {{23-23=try! }}
	i ?+= try? foo() %%% bar()
	_ = foo() == try? bar() // expected-error {{'try?' cannot appear to the right of a non-assignment operator}} // expected-error {{call can throw but is not marked with 'try'}}
	// expected-note@-1 {{did you mean to use 'try'?}} {{5-5=try }}
	// expected-note@-2 {{did you mean to handle error as optional value?}} {{5-5=try? }}
	// expected-note@-3 {{did you mean to disable error propagation?}} {{5-5=try! }}
	_ = (try? foo()) == bar() // expected-error {{call can throw but is not marked with 'try'}}
	// expected-note@-1 {{did you mean to use 'try'?}} {{21-21=try }}
	// expected-note@-2 {{did you mean to handle error as optional value?}} {{21-21=try? }}
	// expected-note@-3 {{did you mean to disable error propagation?}} {{21-21=try! }}
	_ = foo() == (try? bar()) // expected-error {{call can throw but is not marked with 'try'}}
	// expected-note@-1 {{did you mean to use 'try'?}} {{5-5=try }}
	// expected-note@-2 {{did you mean to handle error as optional value?}} {{5-5=try? }}
	// expected-note@-3 {{did you mean to disable error propagation?}} {{5-5=try! }}
	_ = (try? foo()) == (try? bar())

	let j = true ? try? foo() : try? bar() + 0
	let k = true ? try? foo() : try? bar() %%% 0 // expected-error {{'try?' following conditional operator does not cover everything to its right}}

	try let singleLet = foo() // expected-error {{'try' must be placed on the initial value expression}} {{1-5=}} {{21-21=try }}
	try var singleVar = foo() // expected-error {{'try' must be placed on the initial value expression}} {{1-5=}} {{21-21=try }}
	try let uninit: Int // expected-error {{'try' must be placed on the initial value expression}}
	try let (destructure1, destructure2) = (foo(), bar()) // expected-error {{'try' must be placed on the initial value expression}} {{1-5=}} {{40-40=try }}
	try let multi1 = foo(), multi2 = bar() // expected-error {{'try' must be placed on the initial value expression}} expected-error 2 {{call can throw but is not marked with 'try'}}
	// expected-note@-1 {{did you mean to use 'try'?}} {{18-18=try }} expected-note@-1 {{did you mean to use 'try'?}} {{34-34=try }}
	// expected-note@-2 {{did you mean to handle error as optional value?}} {{18-18=try? }} expected-note@-2 {{did you mean to handle error as optional value?}} {{34-34=try? }}
	// expected-note@-3 {{did you mean to disable error propagation?}} {{18-18=try! }} expected-note@-3 {{did you mean to disable error propagation?}} {{34-34=try! }}
	class TryDecl { // expected-note {{in declaration of 'TryDecl'}}
	try let singleLet = foo() // expected-error {{'try' must be placed on the initial value expression}} {{3-7=}} {{23-23=try }}
	// expected-error @-1 {{call can throw, but errors cannot be thrown out of a property initializer}}
	try var singleVar = foo() // expected-error {{'try' must be placed on the initial value expression}} {{3-7=}} {{23-23=try }}
	// expected-error @-1 {{call can throw, but errors cannot be thrown out of a property initializer}}

	try // expected-error {{expected declaration}}
	func method() {}
	}

	func test() throws -> Int {
	try while true { // expected-error {{'try' cannot be used with 'while'}}
	try break // expected-error {{'try' cannot be used with 'break'}}
	}

	try throw // expected-error {{'try' must be placed on the thrown expression}} {{3-7=}} {{3-3=try }} expected-error {{expected expression in 'throw' statement}}
	; // Reset parser.

	try return // expected-error {{'try' cannot be used with 'return'}} expected-error {{non-void function should return a value}}
	; // Reset parser.

	try throw foo() // expected-error {{'try' must be placed on the thrown expression}} {{3-7=}} {{13-13=try }}
	// expected-error@-1 {{thrown expression type 'Int' does not conform to 'Error'}}
	try return foo() // expected-error {{'try' must be placed on the returned expression}} {{3-7=}} {{14-14=try }}
	}

	// Test operators.
	func *(a : String, b : String) throws -> Int { return 42 }
	let _ = "foo"
	* // expected-error {{operator can throw but expression is not marked with 'try'}}
	// expected-note@-1 {{did you mean to use 'try'?}} {{9-9=try }}
	// expected-note@-2 {{did you mean to handle error as optional value?}} {{9-9=try? }}
	// expected-note@-3 {{did you mean to disable error propagation?}} {{9-9=try! }}
	"bar"
	let _ = try! "foo"*"bar"
	let _ = try? "foo"*"bar"
	let _ = (try? "foo"*"bar") ?? 0


	// <rdar://problem/21414023> Assertion failure when compiling function that takes throwing functions and rethrows
	func rethrowsDispatchError(handleError: ((Error) throws -> ()), body: () throws -> ()) rethrows {
	do {
	body() // expected-error {{call can throw but is not marked with 'try'}}
	// expected-note@-1 {{did you mean to use 'try'?}} {{5-5=try }}
	// expected-note@-2 {{did you mean to handle error as optional value?}} {{5-5=try? }}
	// expected-note@-3 {{did you mean to disable error propagation?}} {{5-5=try! }}
	} catch {
	}
	}

	// <rdar://problem/21432429> Calling rethrows from rethrows crashes Swift compiler
	struct r21432429 {
	func x(_ f: () throws -> ()) rethrows {}
	func y(_ f: () throws -> ()) rethrows {
	x(f) // expected-error {{call can throw but is not marked with 'try'}} expected-note {{call is to 'rethrows' function, but argument function can throw}}
	}
	}

	// <rdar://problem/21427855> Swift 2: Omitting try from call to throwing closure in rethrowing function crashes compiler
	func callThrowingClosureWithoutTry(closure: (Int) throws -> Int) rethrows {
	closure(0) // expected-error {{call can throw but is not marked with 'try'}} expected-warning {{result of call to function returning 'Int' is unused}}
	// expected-note@-1 {{did you mean to use 'try'?}} {{3-3=try }}
	// expected-note@-2 {{did you mean to handle error as optional value?}} {{3-3=try? }}
	// expected-note@-3 {{did you mean to disable error propagation?}} {{3-3=try! }}
	}

	func producesOptional() throws -> Int? { return nil }
	let singleOptional = try? producesOptional()
	let _: String = singleOptional // expected-error {{cannot convert value of type 'Int?' to specified type 'String'}}

	let _ = (try? foo())!! // expected-error {{cannot force unwrap value of non-optional type 'Int'}}

	func producesDoubleOptional() throws -> Int?? { return 3 }
	let _: String = try? producesDoubleOptional() // expected-error {{cannot convert value of type 'Int??' to specified type 'String'}}

	func maybeThrow() throws {}
	try maybeThrow() // okay
	try! maybeThrow() // okay
	try? maybeThrow() // okay since return type of maybeThrow is Void
	_ = try? maybeThrow() // okay

	let _: () -> Void = { try! maybeThrow() } // okay
	let _: () -> Void = { try? maybeThrow() } // okay since return type of maybeThrow is Void


	if try? maybeThrow() { // expected-error {{cannot be used as a boolean}} {{4-4=((}} {{21-21=) != nil)}}
	}
	let _: Int = try? foo() // expected-error {{value of optional type 'Int?' not unwrapped; did you mean to use 'try!' or chain with '?'?}} {{14-18=try!}}

	class X {}
	func test(_: X) {}
	func producesObject() throws -> AnyObject { return X() }
	test(try producesObject()) // expected-error {{'AnyObject' is not convertible to 'X'; did you mean to use 'as!' to force downcast?}} {{26-26= as! X}}

	_ = "a\(try maybeThrow())b"
	_ = try "a\(maybeThrow())b"
	_ = "a\(maybeThrow())" // expected-error {{call can throw but is not marked with 'try'}}
	// expected-note@-1 {{did you mean to use 'try'?}} {{9-9=try }}
	// expected-note@-2 {{did you mean to handle error as optional value?}} {{9-9=try? }}
	// expected-note@-3 {{did you mean to disable error propagation?}} {{9-9=try! }}

	extension DefaultStringInterpolation {
	mutating func appendInterpolation() throws {}
	}

	_ = try "a\()b"
	_ = "a\()b" // expected-error {{interpolation can throw but is not marked with 'try'}}
	// expected-note@-1 {{did you mean to use 'try'?}} {{5-5=try }}
	// expected-note@-2 {{did you mean to handle error as optional value?}} {{5-5=try? }}
	// expected-note@-3 {{did you mean to disable error propagation?}} {{5-5=try! }}
	_ = try "\() \(1)"

	func testGenericOptionalTry<T>(_ call: () throws -> T ) {
	let _: String = try? call() // expected-error {{cannot convert value of type 'T?' to specified type 'String'}}
	}

	func genericOptionalTry<T>(_ call: () throws -> T ) -> T? {
	let x = try? call() // no error expected
	return x
	}

	// Test with a non-optional type
	let _: String = genericOptionalTry({ () throws -> Int in return 3 }) // expected-error {{cannot convert value of type 'Int?' to specified type 'String'}}

	// Test with an optional type
	let _: String = genericOptionalTry({ () throws -> Int? in return nil }) // expected-error {{cannot convert value of type 'Int??' to specified type 'String'}}

	func produceAny() throws -> Any {
	return 3
	}

	let _: Int? = try? produceAny() as? Int // good
	let _: Int? = (try? produceAny()) as? Int // good
	let _: String = try? produceAny() as? Int // expected-error {{cannot convert value of type 'Int?' to specified type 'String'}}
	let _: String = (try? produceAny()) as? Int // expected-error {{cannot convert value of type 'Int?' to specified type 'String'}}


	struct ThingProducer {
	func produceInt() throws -> Int { return 3 }
	func produceIntNoThrowing() -> Int { return 3 }
	func produceAny() throws -> Any { return 3 }
	func produceOptionalAny() throws -> Any? { return 3 }
	func produceDoubleOptionalInt() throws -> Int?? { return 3 }
	}

	let optProducer: ThingProducer? = ThingProducer()
	let _: Int? = try? optProducer?.produceInt()
	let _: Int = try? optProducer?.produceInt() // expected-error {{cannot convert value of type 'Int?' to specified type 'Int'}}
	let _: String = try? optProducer?.produceInt() // expected-error {{cannot convert value of type 'Int?' to specified type 'String'}}
	let _: Int?? = try? optProducer?.produceInt() // This was the expected type before Swift 5, but this still works; just adds more optional-ness

	let _: Int? = try? optProducer?.produceIntNoThrowing() // expected-warning {{no calls to throwing functions occur within 'try' expression}}

	let _: Int? = (try? optProducer?.produceAny()) as? Int // good
	let _: Int? = try? optProducer?.produceAny() as? Int // good
	let _: Int?? = try? optProducer?.produceAny() as? Int // good
	let _: String = try? optProducer?.produceAny() as? Int // expected-error {{cannot convert value of type 'Int?' to specified type 'String'}}

	let _: String = try? optProducer?.produceDoubleOptionalInt() // expected-error {{cannot convert value of type 'Int??' to specified type 'String'}}

	let producer = ThingProducer()

	let _: Int = try? producer.produceDoubleOptionalInt() // expected-error {{cannot convert value of type 'Int??' to specified type 'Int'}}

	// We don't offer 'try!' here because it would not change the type of the expression in Swift 5+
	let _: Int? = try? producer.produceDoubleOptionalInt() // expected-error {{cannot convert value of type 'Int??' to specified type 'Int?'}}

	let _: Int?? = try? producer.produceDoubleOptionalInt() // good
	let _: Int??? = try? producer.produceDoubleOptionalInt() // good
	let _: String = try? producer.produceDoubleOptionalInt() // expected-error {{cannot convert value of type 'Int??' to specified type 'String'}}

	// rdar://problem/46742002
	protocol Dummy : class {}

	class F<T> {
	func wait() throws -> T { fatalError() }
	}

	func bar(_ a: F<Dummy>, _ b: F<Dummy>) {
	_ = (try? a.wait()) === (try? b.wait())
	}