Merge pull request #17183 from slavapestov/lazy-init-throws-4.2

[Sema] Correctly reject throwing apply expressions in lazy property initializers [4.2]

Author: slavapestov

lib/Sema/TypeCheckError.cpp

@@ -873,6 +873,14 @@ class Context {
     llvm_unreachable("invalid classify result");
   }
 
+  static Context getContextForPatternBinding(PatternBindingDecl *pbd) {
+    if (!pbd->isStatic() && pbd->getDeclContext()->isTypeContext()) {
+      return Context(Kind::IVarInitializer);
+    } else {
+      return Context(Kind::GlobalVarInitializer);
+    }
+  }
+
   Kind TheKind;
   bool DiagnoseErrorOnTry = false;
   DeclContext *RethrowsDC = nullptr;
@@ -895,6 +903,23 @@ class Context {
       result.RethrowsDC = D;
       return result;
     }
+
+    // HACK: If the decl is the synthesized getter for a 'lazy' property, then
+    // treat the context as a property initializer in order to produce a better
+    // diagnostic; the only code we should be diagnosing on is within the
+    // initializer expression that has been transplanted from the var's pattern
+    // binding decl. We don't perform the analysis on the initializer while it's
+    // still a part of that PBD, as it doesn't get a solution applied there.
+    if (auto *accessor = dyn_cast<AccessorDecl>(D)) {
+      if (auto *var = dyn_cast<VarDecl>(accessor->getStorage())) {
+        if (accessor->isGetter() && var->getAttrs().hasAttribute<LazyAttr>()) {
+          auto *pbd = var->getParentPatternBinding();
+          assert(pbd && "lazy var didn't have a pattern binding decl");
+          return getContextForPatternBinding(pbd);
+        }
+      }
+    }
+
     return Context(getKindForFunctionBody(
         D->getInterfaceType(), D->getNumParameterLists()));
   }
@@ -904,14 +929,10 @@ class Context {
       return Context(Kind::DefaultArgument);
     }
 
-    auto binding = cast<PatternBindingInitializer>(init)->getBinding();
+    auto *binding = cast<PatternBindingInitializer>(init)->getBinding();
     assert(!binding->getDeclContext()->isLocalContext() &&
            "setting up error context for local pattern binding?");
-    if (!binding->isStatic() && binding->getDeclContext()->isTypeContext()) {
-      return Context(Kind::IVarInitializer);
-    } else {
-      return Context(Kind::GlobalVarInitializer);
-    }
+    return getContextForPatternBinding(binding);
   }
 
   static Context forEnumElementInitializer(EnumElementDecl *elt) {
@@ -1409,7 +1430,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 +1505,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/Parse/errors.swift

@@ -86,20 +86,6 @@ func testAutoclosures() throws {
   takesThrowingAutoclosure(genNoError())
 }
 
-struct IllegalContext {
-  var x: Int = genError() // expected-error {{call can throw, but errors cannot be thrown out of a property initializer}}
-
-  func foo(_ x: Int = genError()) {} // expected-error {{call can throw, but errors cannot be thrown out of a default argument}}
-
-  func catcher() throws {
-    do {
-      _ = try genError()
-    } catch MSV.CarriesInt(genError()) { // expected-error {{call can throw, but errors cannot be thrown out of a catch pattern}}
-    } catch MSV.CarriesInt(let i) where i == genError() { // expected-error {{call can throw, but errors cannot be thrown out of a catch guard expression}}
-    }
-  }
-}
-
 func illformed() throws {
     do {
       _ = try genError()

test/decl/func/throwing_functions.swift

@@ -153,3 +153,108 @@ let _ = rdar33040113() // expected-error {{call can throw but is not marked with
 // 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! }}
+
+enum MSV : Error {
+  case Foo, Bar, Baz
+  case CarriesInt(Int)
+}
+
+func genError() throws -> Int { throw MSV.Foo }
+
+struct IllegalContext {
+  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 errors cannot be thrown out of a property initializer}}
+
+  lazy var y2 = genError() // expected-error {{call can throw, but errors cannot be thrown out of a property initializer}}
+
+  lazy var y3 = try genError() // expected-error {{call can throw, but errors cannot be thrown out of a property initializer}}
+
+  lazy var y4: Int = try genError() // expected-error {{call can throw, but errors cannot be thrown out of a property initializer}}
+
+  lazy var y5 = B() // expected-error {{call can throw, but errors cannot be thrown out of a property initializer}}
+
+  lazy var y6 = try B() // expected-error {{call can throw, but errors cannot be thrown out of a property initializer}}
+
+  lazy var y7 = { // expected-error {{call can throw, but errors cannot be thrown out of a property initializer}}
+    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}}
+
+  func catcher() throws {
+    do {
+      _ = try genError()
+    } catch MSV.CarriesInt(genError()) { // expected-error {{call can throw, but errors cannot be thrown out of a catch pattern}}
+    } catch MSV.CarriesInt(let i) where i == genError() { // expected-error {{call can throw, but errors cannot be thrown out of a catch guard expression}}
+    }
+  }
+}