[ResultBuilders] Restrict use of uninitialized variable declarations

Support uninitialized variable declarations only if result builder
implementation has `buildExpression(_: Void) -> ...` function.

Author: xedin

include/swift/Sema/ConstraintSystem.h

@@ -148,6 +148,12 @@ struct ResultBuilder {
 
   Identifier BuildOptionalId;
 
+  /// Identifies whether this builder supports assignment expressions.
+  ///
+  /// Unfortunately this cannot be cached together with other operations
+  /// because this check examines the parameter type of `buildExpression`.
+  Optional<bool> SupportsAssignments;
+
   /// Counter used to give unique names to the variables that are
   /// created implicitly.
   unsigned VarCounter = 0;
@@ -172,6 +178,9 @@ struct ResultBuilder {
 
   bool supportsOptional() { return supports(getBuildOptionalId()); }
 
+  /// Checks whether the builder supports assignment expressions.
+  bool supportsAssignments();
+
   /// Checks whether the `buildPartialBlock` method is supported.
   bool supportsBuildPartialBlock(bool checkAvailability);
 

lib/Sema/BuilderTransform.cpp

@@ -1022,8 +1022,21 @@ class ResultBuilderTransform
         case DeclKind::IfConfig:
         // Skip #warning/#error; we'll handle them when applying
         // the builder.
+        case DeclKind::PatternBinding: {
+          auto *PB = cast<PatternBindingDecl>(decl);
+          // If builder doesn't support assignments, we need to
+          // make sure that all local variables are explicitly
+          // initialized.
+          if (!builder.supportsAssignments()) {
+            for (unsigned i : range(PB->getNumPatternEntries())) {
+              if (!PB->isExplicitlyInitialized(i))
+                return failTransform(decl);
+            }
+          }
+
+          LLVM_FALLTHROUGH;
+        }
         case DeclKind::PoundDiagnostic:
-        case DeclKind::PatternBinding:
         case DeclKind::Var:
         case DeclKind::Param:
           newBody.push_back(element);
@@ -2759,7 +2772,9 @@ std::vector<ReturnStmt *> TypeChecker::findReturnStatements(AnyFunctionRef fn) {
 
 ResultBuilderOpSupport TypeChecker::checkBuilderOpSupport(
     Type builderType, DeclContext *dc, Identifier fnName,
-    ArrayRef<Identifier> argLabels, SmallVectorImpl<ValueDecl *> *allResults) {
+    ArrayRef<Identifier> argLabels,
+    SmallVectorImpl<ValueDecl *> *allResults,
+    llvm::function_ref<bool(FuncDecl *)> additionalChecks) {
 
   auto isUnavailable = [&](Decl *D) -> bool {
     if (AvailableAttr::isUnavailable(D))
@@ -2791,6 +2806,9 @@ ResultBuilderOpSupport TypeChecker::checkBuilderOpSupport(
           continue;
       }
 
+      if (!additionalChecks(func))
+        continue;
+
       // Check if the the candidate has a suitable availability for the
       // calling context.
       if (isUnavailable(func)) {
@@ -3020,6 +3038,25 @@ bool ResultBuilder::supports(Identifier fnBaseName,
   return support.isSupported(checkAvailability);
 }
 
+bool ResultBuilder::supportsAssignments() {
+  if (SupportsAssignments)
+    return *SupportsAssignments;
+
+  auto &ctx = DC->getASTContext();
+
+  auto candidate = TypeChecker::checkBuilderOpSupport(
+      BuilderType, DC, ctx.Id_buildExpression, /*argLabels=*/{Identifier()},
+      /*allResults=*/{}, /*additionalChecks=*/[&](FuncDecl *candidate) {
+        auto *param = candidate->getParameters()->get(0);
+        return param->getInterfaceType()->isEqual(ctx.TheEmptyTupleType);
+      });
+
+  bool isSupported = candidate.isSupported(/*requireAvailable=*/true);
+  SupportsAssignments.emplace(isSupported);
+
+  return isSupported;
+}
+
 Expr *ResultBuilder::buildCall(SourceLoc loc, Identifier fnName,
                                ArrayRef<Expr *> argExprs,
                                ArrayRef<Identifier> argLabels) const {

lib/Sema/TypeChecker.h

@@ -1238,11 +1238,15 @@ UnresolvedMemberExpr *getUnresolvedMemberChainBase(Expr *expr);
 
 /// Checks whether a result builder type has a well-formed result builder
 /// method with the given name. If provided and non-empty, the argument labels
-/// are verified against any candidates.
-ResultBuilderOpSupport
-checkBuilderOpSupport(Type builderType, DeclContext *dc, Identifier fnName,
-                      ArrayRef<Identifier> argLabels = {},
-                      SmallVectorImpl<ValueDecl *> *allResults = nullptr);
+/// are verified against any candidates. Additional checks on otherwise matching
+/// candidates could be performed by passing "additionalChecks" closure.
+ResultBuilderOpSupport checkBuilderOpSupport(
+    Type builderType, DeclContext *dc, Identifier fnName,
+    ArrayRef<Identifier> argLabels = {},
+    SmallVectorImpl<ValueDecl *> *allResults = nullptr,
+    llvm::function_ref<bool(FuncDecl *)> additionalChecks = [](FuncDecl *) {
+      return true;
+    });
 
 /// Checks whether a result builder type has a well-formed result builder
 /// method with the given name. If provided and non-empty, the argument labels

test/Constraints/result_builder_ast_transform.swift

@@ -36,6 +36,9 @@ enum Either<T,U> {
 
 @resultBuilder
 struct TupleBuilder {
+  static func buildExpression(_: Void) {}
+  static func buildExpression<T>(_ t: T) -> T { t }
+
   static func buildBlock() -> () { }
 
   static func buildBlock<T1>(_ t1: T1) -> T1 {