[Sema] Don't mark apply exprs as non-throwing if they haven't been type checked yet

Apply exprs in initialiser expressions for lazy properties were being incorrectly marked as not throwing due to the fact that initialiser expressions for lazy properties don't have a solution applied to them until they get type checked as a part of the synthesised getter.

Author: hamishknight

lib/Sema/TypeCheckError.cpp

@@ -1409,7 +1409,8 @@ class CheckErrorCoverage : public ErrorHandlingWalker<CheckErrorCoverage> {
 
     // HACK: functions can get queued multiple times in
     // definedFunctions, so be sure to be idempotent.
-    if (!E->isThrowsSet()) {
+    if (!E->isThrowsSet() &&
+        classification.getResult() != ThrowingKind::Invalid) {
       E->setThrows(classification.getResult() == ThrowingKind::RethrowingOnly ||
                    classification.getResult() == ThrowingKind::Throws);
     }
@@ -1483,6 +1484,9 @@ class CheckErrorCoverage : public ErrorHandlingWalker<CheckErrorCoverage> {
       Flags.set(ContextFlags::HasAnyThrowSite);
       if (requiresTry) Flags.set(ContextFlags::HasTryThrowSite);
 
+      // We set the throwing bit of an apply expr after performing this
+      // analysis, so ensure we don't emit duplicate diagnostics for functions
+      // that have been queued multiple times.
       if (auto expr = E.dyn_cast<Expr*>())
         if (auto apply = dyn_cast<ApplyExpr>(expr))
           if (apply->isThrowsSet())

test/decl/func/throwing_functions.swift

@@ -162,7 +162,91 @@ enum MSV : Error {
 func genError() throws -> Int { throw MSV.Foo }
 
 struct IllegalContext {
-  var x: Int = genError() // expected-error {{call can throw, but errors cannot be thrown out of a property initializer}}
+  var x1: Int = genError() // expected-error {{call can throw, but errors cannot be thrown out of a property initializer}}
+
+  let x2 = genError() // expected-error {{call can throw, but errors cannot be thrown out of a property initializer}}
+
+  var x3 = try genError() // expected-error {{call can throw, but errors cannot be thrown out of a property initializer}}
+
+  let x4: Int = try genError() // expected-error {{call can throw, but errors cannot be thrown out of a property initializer}}
+
+  var x5 = B() // expected-error {{call can throw, but errors cannot be thrown out of a property initializer}}
+
+  var x6 = try B() // expected-error {{call can throw, but errors cannot be thrown out of a property initializer}}
+
+  var x7 = { // expected-error {{call can throw, but errors cannot be thrown out of a property initializer}}
+    return try genError()
+  }()
+
+  var x8: Int = {
+    do {
+      return genError() // expected-error {{call can throw but is not marked with 'try'}}
+      // expected-note@-1 {{did you mean to use 'try'?}}
+      // expected-note@-2 {{did you mean to handle error as optional value?}}
+      // expected-note@-3 {{did you mean to disable error propagation?}}
+    } catch {
+      return 0
+    }
+  }()
+
+  var x9: Int = {
+    do {
+      return try genError()
+    } catch {
+      return 0
+    }
+  }()
+
+  var x10: B = {
+    do {
+      return try B()
+    } catch {
+      return B(foo: 0)
+    }
+  }()
+
+  lazy var y1: Int = genError() // expected-error {{call can throw, but it is not marked with 'try' and the error is not handled}}
+
+  lazy var y2 = genError() // expected-error {{call can throw, but it is not marked with 'try' and the error is not handled}}
+
+  lazy var y3 = try genError() // expected-error {{errors thrown from here are not handled}}
+
+  lazy var y4: Int = try genError() // expected-error {{errors thrown from here are not handled}}
+
+  lazy var y5 = B() // expected-error {{call can throw, but it is not marked with 'try' and the error is not handled}}
+
+  lazy var y6 = try B() // expected-error {{errors thrown from here are not handled}}
+
+  lazy var y7 = { // expected-error {{call can throw, but it is not marked with 'try' and the error is not handled}}
+    return try genError()
+  }()
+
+  lazy var y8: Int = {
+    do {
+      return genError() // expected-error {{call can throw but is not marked with 'try'}}
+      // expected-note@-1 {{did you mean to use 'try'?}}
+      // expected-note@-2 {{did you mean to handle error as optional value?}}
+      // expected-note@-3 {{did you mean to disable error propagation?}}
+    } catch {
+      return 0
+    }
+  }()
+
+  lazy var y9: Int = {
+    do {
+      return try genError()
+    } catch {
+      return 0
+    }
+  }()
+
+  lazy var y10: B = {
+    do {
+      return try B()
+    } catch {
+      return B(foo: 0)
+    }
+  }()
 
   func foo(_ x: Int = genError()) {} // expected-error {{call can throw, but errors cannot be thrown out of a default argument}}