[Sema] Treat a lazy property's synthesised getter as being a property initialiser for error handling diagnostics

The only code we should be diagnosing on in such a context is within the property's initialiser expression that has been transplanted from the var's pattern binding decl. We don't perform the analysis on the init expr while it's still a part of the original PBD, as it doesn't get a solution applied there.

Author: hamishknight

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) {

test/decl/func/throwing_functions.swift

@@ -205,19 +205,19 @@ struct IllegalContext {
     }
   }()
 
-  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 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 it is not marked with 'try' and the error is not handled}}
+  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 {{errors thrown from here are not handled}}
+  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 {{errors thrown from here are not handled}}
+  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 it is not marked with 'try' and the error is not handled}}
+  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 {{errors thrown from here are not handled}}
+  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 it is not marked with 'try' and the error is not handled}}
+  lazy var y7 = { // expected-error {{call can throw, but errors cannot be thrown out of a property initializer}}
     return try genError()
   }()