[Constraint system] Abstract the record of an applied function builder.

std::pair and std::tuple are a bad, bad drug. NFC, but helps with
future refactoring.

Author: DougGregor

lib/Sema/BuilderTransform.cpp

@@ -586,14 +586,16 @@ ConstraintSystem::TypeMatchResult ConstraintSystem::applyFunctionBuilder(
   assert(transformedType && "Missing type");
 
   // Record the transformation.
-  assert(std::find_if(builderTransformedClosures.begin(),
-                      builderTransformedClosures.end(),
-                      [&](const std::tuple<ClosureExpr *, Type, Expr *> &elt) {
-                        return std::get<0>(elt) == closure;
-                      }) == builderTransformedClosures.end() &&
+  assert(std::find_if(
+      builderTransformedClosures.begin(),
+      builderTransformedClosures.end(),
+      [&](const std::pair<ClosureExpr *, AppliedBuilderTransform> &elt) {
+        return elt.first == closure;
+      }) == builderTransformedClosures.end() &&
          "already transformed this closure along this path!?!");
   builderTransformedClosures.push_back(
-    std::make_tuple(closure, builderType, singleExpr));
+      std::make_pair(closure,
+                     AppliedBuilderTransform{builderType, singleExpr}));
 
   // Bind the result type of the closure to the type of the transformed
   // expression.

lib/Sema/CSApply.cpp

@@ -7461,7 +7461,7 @@ namespace {
         auto builder =
             Rewriter.solution.builderTransformedClosures.find(closure);
         if (builder != Rewriter.solution.builderTransformedClosures.end()) {
-          auto singleExpr = builder->second.second;
+          auto singleExpr = builder->second.singleExpr;
           auto returnStmt = new (tc.Context) ReturnStmt(
              singleExpr->getStartLoc(), singleExpr, /*implicit=*/true);
           auto braceStmt = BraceStmt::create(
@@ -7586,7 +7586,7 @@ bool ConstraintSystem::applySolutionFixes(Expr *E, const Solution &solution) {
       if (auto *closure = dyn_cast<ClosureExpr>(E)) {
         auto result = solution.builderTransformedClosures.find(closure);
         if (result != solution.builderTransformedClosures.end()) {
-          auto *transformedExpr = result->second.second;
+          auto *transformedExpr = result->second.singleExpr;
           // Since this closure has been transformed into something
           // else let's look inside transformed expression instead.
           transformedExpr->walk(*this);

lib/Sema/CSSolver.cpp

@@ -174,14 +174,11 @@ Solution ConstraintSystem::finalize() {
 
   for (const auto &transformed : builderTransformedClosures) {
     auto known =
-        solution.builderTransformedClosures.find(std::get<0>(transformed));
+        solution.builderTransformedClosures.find(transformed.first);
     if (known != solution.builderTransformedClosures.end()) {
-      assert(known->second.second == std::get<2>(transformed));
+      assert(known->second.singleExpr == transformed.second.singleExpr);
     }
-    solution.builderTransformedClosures.insert(
-      std::make_pair(std::get<0>(transformed),
-                     std::make_pair(std::get<1>(transformed),
-                                    std::get<2>(transformed))));
+    solution.builderTransformedClosures.insert(transformed);
   }
 
   return solution;
@@ -253,10 +250,7 @@ void ConstraintSystem::applySolution(const Solution &solution) {
     CheckedConformances.push_back(conformance);
 
   for (const auto &transformed : solution.builderTransformedClosures) {
-    builderTransformedClosures.push_back(
-      std::make_tuple(transformed.first,
-                      transformed.second.first,
-                      transformed.second.second));
+    builderTransformedClosures.push_back(transformed);
   }
 
   // Register any fixes produced along this path.

lib/Sema/ConstraintSystem.h

@@ -502,6 +502,16 @@ enum ScoreKind {
 /// The number of score kinds.
 const unsigned NumScoreKinds = SK_LastScoreKind + 1;
 
+/// Describes what happened when a function builder transform was applied
+/// to a particular closure.
+struct AppliedBuilderTransform {
+  /// The builder type that was applied to the closure.
+  Type builderType;
+
+  /// The single expression to which the closure was transformed.
+  Expr *singleExpr;
+};
+
 /// Describes the fixed score of a solution to the constraint system.
 struct Score {
   unsigned Data[NumScoreKinds] = {};
@@ -656,7 +666,7 @@ class Solution {
       Conformances;
 
   /// The set of closures that have been transformed by a function builder.
-  llvm::MapVector<ClosureExpr *, std::pair<Type, Expr *>>
+  llvm::MapVector<ClosureExpr *, AppliedBuilderTransform>
       builderTransformedClosures;
 
   /// Simplify the given type by substituting all occurrences of
@@ -1150,7 +1160,7 @@ class ConstraintSystem {
       CheckedConformances;
 
   /// The set of closures that have been transformed by a function builder.
-  SmallVector<std::tuple<ClosureExpr *, Type, Expr *>, 4>
+  std::vector<std::pair<ClosureExpr *, AppliedBuilderTransform>>
       builderTransformedClosures;
 
 public: