[Constraint system] Support if let / if case in function builders.

Use the generalized constraint generation and binding for patterns to
introduce support for if-let and if-case in function builders, handling
arbitrary patterns.

Part of function builder generalization, rdar://problem/50426203.

Author: DougGregor

lib/Sema/BuilderTransform.cpp

@@ -376,10 +376,6 @@ class BuilderClosureVisitor
   static bool isBuildableIfChainRecursive(IfStmt *ifStmt,
                                           unsigned &numPayloads,
                                           bool &isOptional) {
-    // Check whether we can handle the conditional.
-    if (!ConstraintSystem::canGenerateConstraints(ifStmt->getCond()))
-      return false;
-
     // The 'then' clause contributes a payload.
     numPayloads++;
 
@@ -447,6 +443,14 @@ class BuilderClosureVisitor
                                  unsigned numPayloads, bool isOptional,
                                  bool isTopLevel = false) {
     assert(payloadIndex < numPayloads);
+
+    // First generate constraints for the conditions. This can introduce
+    // variable bindings that will be used within the "then" branch.
+    if (cs && cs->generateConstraints(ifStmt->getCond(), dc)) {
+      hadError = true;
+      return nullptr;
+    }
+
     // Make sure we recursively visit both sides even if we're not
     // building expressions.
 
@@ -503,12 +507,6 @@ class BuilderClosureVisitor
           payloadIndex + 1, numPayloads, isOptional);
     }
 
-    // Generate constraints for the conditions.
-    if (cs->generateConstraints(ifStmt->getCond(), dc)) {
-      hadError = true;
-      return nullptr;
-    }
-
     // The operand should have optional type if we had optional results,
     // so we just need to call `buildIf` now, since we're at the top level.
     if (isOptional && isTopLevel) {
@@ -941,8 +939,16 @@ class BuilderClosureRewriter
         continue;
       }
 
-      case StmtConditionElement::CK_PatternBinding:
-        llvm_unreachable("unhandled statement condition");
+      case StmtConditionElement::CK_PatternBinding: {
+        ConstraintSystem &cs = solution.getConstraintSystem();
+        auto target = *cs.getStmtConditionTarget(&condElement);
+        auto resolvedTarget = rewriteTarget(target);
+        if (resolvedTarget) {
+          condElement.setInitializer(resolvedTarget->getAsExpr());
+          condElement.setPattern(resolvedTarget->getInitializationPattern());
+        }
+        continue;
+      }
       }
     }
     ifStmt->setCond(condition);

lib/Sema/CSGen.cpp

@@ -4166,21 +4166,6 @@ Type ConstraintSystem::generateConstraints(Pattern *pattern,
   return cg.getTypeForPattern(pattern, locator, Type(), bindPatternVarsOneWay);
 }
 
-bool ConstraintSystem::canGenerateConstraints(StmtCondition condition) {
-  for (const auto &element : condition) {
-    switch (element.getKind()) {
-    case StmtConditionElement::CK_Availability:
-    case StmtConditionElement::CK_Boolean:
-      continue;
-
-    case StmtConditionElement::CK_PatternBinding:
-      return false;
-    }
-  }
-
-  return true;
-}
-
 bool ConstraintSystem::generateConstraints(StmtCondition condition,
                                            DeclContext *dc) {
   // FIXME: This should be folded into constraint generation for conditions.
@@ -4213,8 +4198,21 @@ bool ConstraintSystem::generateConstraints(StmtCondition condition,
       continue;
     }
 
-    case StmtConditionElement::CK_PatternBinding:
-      llvm_unreachable("unhandled statement condition");
+    case StmtConditionElement::CK_PatternBinding: {
+      auto *pattern = TypeChecker::resolvePattern(
+          condElement.getPattern(), dc, /*isStmtCondition*/true);
+      if (!pattern)
+        return true;
+
+      auto target = SolutionApplicationTarget::forInitialization(
+          condElement.getInitializer(), dc, Type(),
+          pattern, /*bindPatternVarsOneWay=*/true);
+      if (generateConstraints(target, FreeTypeVariableBinding::Disallow))
+        return true;
+
+      setStmtConditionTarget(&condElement, target);
+      continue;
+    }
     }
   }
 

lib/Sema/ConstraintSystem.h

@@ -3283,10 +3283,6 @@ class ConstraintSystem {
   Type generateConstraints(Pattern *P, ConstraintLocatorBuilder locator,
                            bool bindPatternVarsOneWay);
 
-  /// Determines whether we can generate constraints for this statement
-  /// condition.
-  static bool canGenerateConstraints(StmtCondition condition);
-
   /// Generate constraints for a statement condition.
   ///
   /// \returns true if there was an error in constraint generation, false

test/Constraints/function_builder.swift

@@ -491,3 +491,48 @@ tuplify(true) { c in
 // CHECK-SAME: hello
 // CHECK-SAME: true
 
+// Use if let / if case with various forms of decomposition.
+func getOptionalInt(_: Bool) -> Int? { return 25 }
+
+enum E {
+  case a
+  case b(Int, String?)
+}
+
+func getE(_ i: Int) -> E {
+  switch i {
+  case 0:
+    return .a
+  case 1:
+    return .b(17, "hello")
+  case 2:
+    return .b(42, nil)
+  default:
+    fatalError("Unhandled case")
+  }
+}
+
+tuplify(true) { c in
+  "testIfLetMatching"
+  if let theValue = getOptionalInt(c) {
+    theValue + 17
+  }
+  if case let .a = getE(0) {
+    "matched without payload"
+  }
+  if case let .b(i, s?) = getE(1) {
+    "matched with payload"
+    s + "!"
+    i + 17
+  }
+  if case let .b(i, s?) = getE(2) {
+    fatalError("cannot match this")
+  } else {
+    "intentional mismatch"
+  }
+}
+// CHECK: testIfLetMatching
+// CHECK-SAME: Optional(42)
+// CHECK-SAME: Optional("matched without payload")
+// CHECK-SAME: "matched with payload", "hello!", 34
+// CHECK-SAME: "intentional mismatch"

test/Constraints/function_builder_one_way.swift

@@ -50,12 +50,12 @@ func tuplify<C: Collection, T>(_ collection: C, @TupleBuilder body: (C.Element)
 
 // CHECK: ---Connected components---
 // CHECK-NEXT:  0: $T1 $T2 $T3 $T5 $T6 $T7 $T8 $T10 $T11 $T78 $T79 depends on 2
-// CHECK-NEXT:  2: $T13 $T18 $T29 $T42 $T53 $T55 $T56 $T57 $T58 $T59 $T60 $T61 $T62 $T63 $T64 $T65 $T66 $T67 $T69 $T70 $T71 $T72 $T73 $T74 $T75 $T76 $T77 depends on 1, 3, 4, 6, 9
-// CHECK-NEXT:  9: $T48 $T49 $T50 $T51 $T52 depends on 8
-// CHECK-NEXT:  8: $T43 $T44 $T45 $T46 $T47
-// CHECK-NEXT:  6: $T31 $T35 $T36 $T37 $T38 $T39 $T40 $T41 depends on 5, 7
-// CHECK-NEXT:  7: $T32 $T33 $T34
-// CHECK-NEXT:  5: $T30
+// CHECK-NEXT:  2: $T13 $T18 $T29 $T43 $T54 $T55 $T56 $T57 $T58 $T59 $T60 $T61 $T62 $T63 $T64 $T65 $T66 $T67 $T69 $T70 $T71 $T72 $T73 $T74 $T75 $T76 $T77 depends on 1, 3, 4, 6, 9
+// CHECK-NEXT:  9: $T49 $T50 $T51 $T52 $T53 depends on 8
+// CHECK-NEXT:  8: $T44 $T45 $T46 $T47 $T48
+// CHECK-NEXT:  6: $T32 $T36 $T37 $T38 $T39 $T40 $T41 $T42 depends on 5, 7
+// CHECK-NEXT:  7: $T33 $T34 $T35
+// CHECK-NEXT:  5: $T31
 // CHECK-NEXT:  4: $T19 $T20 $T21 $T22 $T23 $T24 $T25 $T26 $T27 $T28
 // CHECK-NEXT:  3: $T16 $T17
 // CHECK-NEXT:  1: $T12