Merge pull request #61944 from angela-laar/refactor-generate-constraints-for-closures

[CSClosure] Refactor generateConstraints

Author: angela-laar

include/swift/Sema/ConstraintSystem.h

@@ -5042,15 +5042,7 @@ class ConstraintSystem {
   bool generateConstraints(SolutionApplicationTarget &target,
                            FreeTypeVariableBinding allowFreeTypeVariables);
 
-  /// Generate constraints for the body of the given closure.
-  ///
-  /// \param closure the closure expression
-  ///
-  /// \returns \c true if constraint generation failed, \c false otherwise
-  LLVM_NODISCARD
-  bool generateConstraints(ClosureExpr *closure);
-
-  /// Generate constraints for the body of the given function.
+  /// Generate constraints for the body of the given function or closure.
   ///
   /// \param fn The function or closure expression
   /// \param body The body of the given function that should be

lib/Sema/CSSimplify.cpp

@@ -10798,7 +10798,7 @@ bool ConstraintSystem::resolveClosure(TypeVariableType *typeVar,
   setSolutionApplicationTarget(closure, target);
 
   // Generate constraints from the body of this closure.
-  return !generateConstraints(closure);
+  return !generateConstraints(AnyFunctionRef{closure}, closure->getBody());
 }
 
 ConstraintSystem::SolutionKind
@@ -14545,7 +14545,7 @@ ConstraintSystem::simplifyConstraint(const Constraint &constraint) {
 
   case ConstraintKind::Disjunction:
   case ConstraintKind::Conjunction:
-    // {Dis, Con}junction constraints are never solved here.
+    // See {Dis, Con}junctionStep class in CSStep.cpp for solving
     return SolutionKind::Unsolved;
 
   case ConstraintKind::OneWayEqual:

lib/Sema/CSSyntacticElement.cpp

@@ -383,6 +383,11 @@ struct SyntacticElementContext
     }
   }
 
+  NullablePtr<ClosureExpr> getAsClosureExpr() const {
+    return dyn_cast_or_null<ClosureExpr>(
+        this->dyn_cast<AbstractClosureExpr *>());
+  }
+
   NullablePtr<AbstractClosureExpr> getAsAbstractClosureExpr() const {
     return this->dyn_cast<AbstractClosureExpr *>();
   }
@@ -905,6 +910,8 @@ class SyntacticElementConstraintGenerator
   }
 
   void visitBraceStmt(BraceStmt *braceStmt) {
+    auto &ctx = cs.getASTContext();
+
     if (context.isSingleExpressionClosure(cs)) {
       for (auto node : braceStmt->getElements()) {
         if (auto expr = node.dyn_cast<Expr *>()) {
@@ -922,7 +929,36 @@ class SyntacticElementConstraintGenerator
       return;
     }
 
-    auto &ctx = cs.getASTContext();
+    // If this brace statement represents a body of an empty or
+    // multi-statement closure.
+    if (locator->directlyAt<ClosureExpr>()) {
+      auto *closure = context.getAsClosureExpr().get();
+      // If this closure has an empty body and no explicit result type
+      // let's bind result type to `Void` since that's the only type empty
+      // body can produce. Otherwise, if (multi-statement) closure doesn't
+      // have an explicit result (no `return` statements) let's default it to
+      // `Void`.
+      //
+      // Note that result builder bodies always have a `return` statement
+      // at the end, so they don't need to be defaulted.
+      if (!cs.getAppliedResultBuilderTransform({closure}) &&
+          !hasExplicitResult(closure)) {
+        auto constraintKind =
+            (closure->hasEmptyBody() && !closure->hasExplicitResultType())
+                ? ConstraintKind::Bind
+                : ConstraintKind::Defaultable;
+
+        cs.addConstraint(
+            constraintKind, cs.getClosureType(closure)->getResult(),
+            ctx.TheEmptyTupleType,
+            cs.getConstraintLocator(closure, ConstraintLocator::ClosureResult));
+      }
+
+      // Let's not walk into the body if empty or multi-statement closure
+      // doesn't participate in inference.
+      if (!cs.participatesInInference(closure))
+        return;
+    }
 
     if (isChildOf(StmtKind::Case)) {
       auto *caseStmt = cast<CaseStmt>(
@@ -1122,39 +1158,6 @@ class SyntacticElementConstraintGenerator
 };
 }
 
-bool ConstraintSystem::generateConstraints(ClosureExpr *closure) {
-  auto &ctx = closure->getASTContext();
-
-  if (participatesInInference(closure)) {
-    SyntacticElementConstraintGenerator generator(
-        *this, SyntacticElementContext::forClosure(closure),
-        getConstraintLocator(closure));
-
-    generator.visit(closure->getBody());
-
-    if (closure->hasSingleExpressionBody())
-      return generator.hadError;
-  }
-
-  // If this closure has an empty body and no explicit result type
-  // let's bind result type to `Void` since that's the only type empty body
-  // can produce. Otherwise, if (multi-statement) closure doesn't have
-  // an explicit result (no `return` statements) let's default it to `Void`.
-  if (!hasExplicitResult(closure)) {
-    auto constraintKind =
-        (closure->hasEmptyBody() && !closure->hasExplicitResultType())
-            ? ConstraintKind::Bind
-            : ConstraintKind::Defaultable;
-
-    addConstraint(
-        constraintKind, getClosureType(closure)->getResult(),
-        ctx.TheEmptyTupleType,
-        getConstraintLocator(closure, ConstraintLocator::ClosureResult));
-  }
-
-  return false;
-}
-
 bool ConstraintSystem::generateConstraints(AnyFunctionRef fn, BraceStmt *body) {
   NullablePtr<ConstraintLocator> locator;