[Constraint system] Move statement condition constraint generation.

Move constraint generation for statement conditions onto the
constraint system; it doesn't really have any reason to be located
within the function builder transform.

Author: DougGregor

lib/Sema/BuilderTransform.cpp

@@ -324,27 +324,11 @@ class BuilderClosureVisitor
   CONTROL_FLOW_STMT(Yield)
   CONTROL_FLOW_STMT(Defer)
 
-  /// Whether we can handle all of the conditions for this statement.
-  static bool canHandleStmtConditions(StmtCondition condition) {
-    for (const auto &element : condition) {
-      switch (element.getKind()) {
-      case StmtConditionElement::CK_Boolean:
-        continue;
-
-      case StmtConditionElement::CK_PatternBinding:
-      case StmtConditionElement::CK_Availability:
-        return false;
-      }
-    }
-
-    return true;
-  }
-
   static bool isBuildableIfChainRecursive(IfStmt *ifStmt,
                                           unsigned &numPayloads,
                                           bool &isOptional) {
     // Check whether we can handle the conditional.
-    if (!canHandleStmtConditions(ifStmt->getCond()))
+    if (!ConstraintSystem::canGenerateConstraints(ifStmt->getCond()))
       return false;
 
     // The 'then' clause contributes a payload.
@@ -470,38 +454,12 @@ class BuilderClosureVisitor
           payloadIndex + 1, numPayloads, isOptional);
     }
 
-    // Condition must convert to Bool.
-    // FIXME: This should be folded into constraint generation for conditions.
-    auto boolDecl = ctx.getBoolDecl();
-    if (!boolDecl) {
+    // Generate constraints for the conditions.
+    if (cs->generateConstraints(ifStmt->getCond(), dc)) {
       hadError = true;
       return nullptr;
     }
 
-    // Generate constraints for the conditions.
-    for (const auto &condElement : ifStmt->getCond()) {
-      switch (condElement.getKind()) {
-      case StmtConditionElement::CK_Boolean: {
-        Expr *condExpr = condElement.getBoolean();
-        condExpr = cs->generateConstraints(condExpr, dc);
-        if (!condExpr) {
-          hadError = true;
-          return nullptr;
-        }
-
-        cs->addConstraint(ConstraintKind::Conversion,
-                          cs->getType(condExpr),
-                          boolDecl->getDeclaredType(),
-                          cs->getConstraintLocator(condExpr));
-        continue;
-      }
-
-      case StmtConditionElement::CK_PatternBinding:
-      case StmtConditionElement::CK_Availability:
-        llvm_unreachable("unhandled statement condition");
-      }
-    }
-
     // 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) {

lib/Sema/CSGen.cpp

@@ -3798,6 +3798,54 @@ Type ConstraintSystem::generateConstraints(Pattern *pattern,
   return cg.getTypeForPattern(pattern, locator);
 }
 
+bool ConstraintSystem::canGenerateConstraints(StmtCondition condition) {
+  for (const auto &element : condition) {
+    switch (element.getKind()) {
+    case StmtConditionElement::CK_Boolean:
+      continue;
+
+    case StmtConditionElement::CK_PatternBinding:
+    case StmtConditionElement::CK_Availability:
+      return false;
+    }
+  }
+
+  return true;
+}
+
+bool ConstraintSystem::generateConstraints(StmtCondition condition,
+                                           DeclContext *dc) {
+  // FIXME: This should be folded into constraint generation for conditions.
+  auto boolDecl = getASTContext().getBoolDecl();
+  if (!boolDecl) {
+    return true;
+  }
+
+  for (const auto &condElement : condition) {
+    switch (condElement.getKind()) {
+    case StmtConditionElement::CK_Boolean: {
+      Expr *condExpr = condElement.getBoolean();
+      condExpr = generateConstraints(condExpr, dc);
+      if (!condExpr) {
+        return true;
+      }
+
+      addConstraint(ConstraintKind::Conversion,
+                    getType(condExpr),
+                    boolDecl->getDeclaredType(),
+                    getConstraintLocator(condExpr));
+      continue;
+    }
+
+    case StmtConditionElement::CK_PatternBinding:
+    case StmtConditionElement::CK_Availability:
+      llvm_unreachable("unhandled statement condition");
+    }
+  }
+
+  return false;
+}
+
 void ConstraintSystem::optimizeConstraints(Expr *e) {
   if (getASTContext().TypeCheckerOpts.DisableConstraintSolverPerformanceHacks)
     return;

lib/Sema/ConstraintSystem.h

@@ -3065,6 +3065,16 @@ class ConstraintSystem {
   /// \returns a possibly-sanitized initializer, or null if an error occurred.
   Type generateConstraints(Pattern *P, ConstraintLocatorBuilder locator);
 
+  /// 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
+  /// if generation succeeded.
+  bool generateConstraints(StmtCondition condition, DeclContext *dc);
+
   /// Generate constraints for a given set of overload choices.
   ///
   /// \param constraints The container of generated constraint choices.