[Constraint System] Refactor generateConstraints

We don't need a separate generateConstraints function for closures.

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/AST/Module.cpp

@@ -3497,8 +3497,7 @@ ArrayRef<OpaqueTypeDecl *> SourceFile::getOpaqueReturnTypeDecls() {
   for (auto *vd : UnvalidatedDeclsWithOpaqueReturnTypes.takeVector()) {
     if (auto opaqueDecl = vd->getOpaqueResultTypeDecl()) {
       auto inserted = ValidatedOpaqueReturnTypes.insert(
-                {opaqueDecl->getOpaqueReturnTypeIdentifier().str(),
-                 opaqueDecl});
+          {opaqueDecl->getOpaqueReturnTypeIdentifier().str(), opaqueDecl});
       if (inserted.second) {
         OpaqueReturnTypes.push_back(opaqueDecl);
       }

lib/Parse/ParseDecl.cpp

@@ -7234,13 +7234,13 @@ Parser::parseDeclVar(ParseDeclOptions Flags,
 
       pattern = patternRes.get();
     }
-    
+
     bool hasOpaqueReturnTy = false;
     if (auto typedPattern = dyn_cast<TypedPattern>(pattern)) {
       hasOpaqueReturnTy = typedPattern->getTypeRepr()->hasOpaque();
     }
     auto sf = CurDeclContext->getParentSourceFile();
-    
+
     // Configure all vars with attributes, 'static' and parent pattern.
     pattern->forEachVariable([&](VarDecl *VD) {
       VD->setStatic(StaticLoc.isValid());
@@ -7543,13 +7543,12 @@ ParserResult<FuncDecl> Parser::parseDeclFunc(SourceLoc StaticLoc,
                               CurDeclContext);
 
   // Let the source file track the opaque return type mapping, if any.
-  if (FuncRetTy && FuncRetTy->hasOpaque() &&
-      !InInactiveClauseEnvironment) {
+  if (FuncRetTy && FuncRetTy->hasOpaque() && !InInactiveClauseEnvironment) {
     if (auto sf = CurDeclContext->getParentSourceFile()) {
       sf->addUnvalidatedDeclWithOpaqueResultType(FD);
     }
   }
-  
+
   // Parse a 'where' clause if present.
   if (Tok.is(tok::kw_where)) {
     ContextChange CC(*this, FD);
@@ -8512,7 +8511,7 @@ Parser::parseDeclSubscript(SourceLoc StaticLoc,
       Context, name, StaticLoc, StaticSpelling, SubscriptLoc, Indices.get(),
       ArrowLoc, ElementTy.get(), CurDeclContext, GenericParams);
   Subscript->getAttrs() = Attributes;
-  
+
   // Let the source file track the opaque return type mapping, if any.
   if (ElementTy.get() && ElementTy.get()->hasOpaque() &&
       !InInactiveClauseEnvironment) {

lib/Sema/CSSimplify.cpp

@@ -10797,7 +10797,8 @@ bool ConstraintSystem::resolveClosure(TypeVariableType *typeVar,
   setSolutionApplicationTarget(closure, target);
 
   // Generate constraints from the body of this closure.
-  return !generateConstraints(closure);
+  return !generateConstraints(
+      AnyFunctionRef(cast<AbstractClosureExpr>(closure)), closure->getBody());
 }
 
 ConstraintSystem::SolutionKind
@@ -14543,7 +14544,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

@@ -1122,46 +1122,44 @@ class SyntacticElementConstraintGenerator
 };
 }
 
-bool ConstraintSystem::generateConstraints(ClosureExpr *closure) {
-  auto &ctx = closure->getASTContext();
+bool ConstraintSystem::generateConstraints(AnyFunctionRef fn, BraceStmt *body) {
+  NullablePtr<ConstraintLocator> locator;
 
-  if (participatesInInference(closure)) {
-    SyntacticElementConstraintGenerator generator(
-        *this, SyntacticElementContext::forClosure(closure),
-        getConstraintLocator(closure));
+  if (auto *func = fn.getAbstractFunctionDecl()) {
+    locator = getConstraintLocator(func);
+  } else {
+    auto closure = cast<ClosureExpr>(fn.getAbstractClosureExpr());
+    locator = getConstraintLocator(closure);
 
-    generator.visit(closure->getBody());
+    auto &ctx = closure->getASTContext();
 
-    if (closure->hasSingleExpressionBody())
-      return generator.hadError;
-  }
+    if (participatesInInference(closure)) {
+      SyntacticElementConstraintGenerator generator(
+          *this, closure, getConstraintLocator(closure));
 
-  // 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;
+      generator.visit(closure->getBody());
 
-    addConstraint(
-        constraintKind, getClosureType(closure)->getResult(),
-        ctx.TheEmptyTupleType,
-        getConstraintLocator(closure, ConstraintLocator::ClosureResult));
-  }
+      if (closure->hasSingleExpressionBody())
+        return generator.hadError;
+    }
 
-  return false;
-}
+    // 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;
 
-bool ConstraintSystem::generateConstraints(AnyFunctionRef fn, BraceStmt *body) {
-  NullablePtr<ConstraintLocator> locator;
+      addConstraint(
+          constraintKind, getClosureType(closure)->getResult(),
+          ctx.TheEmptyTupleType,
+          getConstraintLocator(closure, ConstraintLocator::ClosureResult));
+    }
 
-  if (auto *func = fn.getAbstractFunctionDecl()) {
-    locator = getConstraintLocator(func);
-  } else {
-    locator = getConstraintLocator(fn.getAbstractClosureExpr());
+    return false;
   }
 
   SyntacticElementConstraintGenerator generator(