Sema: Reject non-stored local variables in result builders

We would previously reject properties without an initializer expression,
but this is not quite sufficient, because of 'lazy', property wrappers,
and observers.

We could probably support all three in result builder contexts, but
for now, let's diagnose them like other computed properties, instead of
crashing.

Fixes part of <rdar://problem/73545981>.

Author: slavapestov

lib/Sema/BuilderTransform.cpp

@@ -268,14 +268,27 @@ class BuilderClosureVisitor
   }
 
   void visitPatternBindingDecl(PatternBindingDecl *patternBinding) {
-    // If any of the entries lacks an initializer, don't handle this node.
-    if (!llvm::all_of(range(patternBinding->getNumPatternEntries()),
-                      [&](unsigned index) {
-            return patternBinding->isExplicitlyInitialized(index);
-        })) {
-      if (!unhandledNode)
-        unhandledNode = patternBinding;
-      return;
+    // Enforce some restrictions on local variables inside a result builder.
+    for (unsigned i : range(patternBinding->getNumPatternEntries())) {
+      // The pattern binding must have an initial value expression.
+      if (!patternBinding->isExplicitlyInitialized(i)) {
+        if (!unhandledNode)
+          unhandledNode = patternBinding;
+        return;
+      }
+
+      // Each variable bound by the pattern must be stored, and cannot
+      // have observers.
+      SmallVector<VarDecl *, 8> variables;
+      patternBinding->getPattern(i)->collectVariables(variables);
+
+      for (auto *var : variables) {
+        if (!var->getImplInfo().isSimpleStored()) {
+          if (!unhandledNode)
+            unhandledNode = patternBinding;
+          return;
+        }
+      }
     }
 
     // If there is a constraint system, generate constraints for the pattern

test/Constraints/result_builder_invalid_vars.swift

@@ -0,0 +1,45 @@
+// RUN: %target-typecheck-verify-swift
+
+@resultBuilder
+struct DummyBuilder { // expected-note 5 {{struct 'DummyBuilder' declared here}}
+  static func buildBlock<T>(_ t: T) -> T {
+    return t
+  }
+}
+
+func dummy<T>(@DummyBuilder _: () -> T) {}
+
+dummy {
+  var computedVar: Int { return 123 } // expected-error {{closure containing a declaration cannot be used with result builder 'DummyBuilder'}}
+  ()
+}
+
+dummy {
+  lazy var lazyVar: Int = 123 // expected-error {{closure containing a declaration cannot be used with result builder 'DummyBuilder'}}
+  ()
+}
+
+dummy {
+  var observedVar: Int = 123 { // expected-error {{closure containing a declaration cannot be used with result builder 'DummyBuilder'}}
+    didSet {}
+  }
+
+  ()
+}
+
+dummy {
+  var observedVar: Int = 123 { // expected-error {{closure containing a declaration cannot be used with result builder 'DummyBuilder'}}
+    willSet {}
+  }
+
+  ()
+}
+
+@propertyWrapper struct Wrapper {
+  var wrappedValue: Int
+}
+
+dummy {
+  @Wrapper var wrappedVar: Int = 123 // expected-error {{closure containing a declaration cannot be used with result builder 'DummyBuilder'}}
+  ()
+}