[Diagnostics] Keep track of the indices of the tuple elements whose

types do not match in AllowTupleTypeMismatch/TupleContextualFailure.

Author: hborla

lib/Sema/CSDiagnostics.h

@@ -830,10 +830,16 @@ class InvalidUseOfAddressOf final : public ContextualFailure {
 
 /// Diagnose mismatches relating to tuple destructuring.
 class TupleContextualFailure final : public ContextualFailure {
+  /// Indices of the tuple elements whose types do not match.
+  llvm::SmallVector<unsigned, 4> Indices;
+
 public:
   TupleContextualFailure(ConstraintSystem &cs, ContextualTypePurpose purpose,
-                         Type lhs, Type rhs, ConstraintLocator *locator)
-      : ContextualFailure(cs, purpose, lhs, rhs, locator) {
+                         Type lhs, Type rhs, llvm::ArrayRef<unsigned> indices,
+                         ConstraintLocator *locator)
+      : ContextualFailure(cs, purpose, lhs, rhs, locator),
+        Indices(indices.begin(), indices.end()) {
+    std::sort(Indices.begin(), Indices.end());
     assert(getFromType()->is<TupleType>() && getToType()->is<TupleType>());
   }
 

lib/Sema/CSFix.cpp

@@ -257,6 +257,17 @@ ContextualMismatch *ContextualMismatch::create(ConstraintSystem &cs, Type lhs,
 
 bool AllowTupleTypeMismatch::coalesceAndDiagnose(
     ArrayRef<ConstraintFix *> fixes, bool asNote) const {
+  llvm::SmallVector<unsigned, 4> indices;
+  if (isElementMismatch())
+    indices.push_back(*Index);
+
+  for (auto fix : fixes) {
+    auto *tupleFix = fix->getAs<AllowTupleTypeMismatch>();
+    if (!tupleFix || !tupleFix->isElementMismatch())
+      continue;
+    indices.push_back(*tupleFix->Index);
+  }
+
   auto &cs = getConstraintSystem();
   auto *locator = getLocator();
   auto purpose = cs.getContextualTypePurpose();
@@ -288,7 +299,7 @@ bool AllowTupleTypeMismatch::coalesceAndDiagnose(
     return false;
   }
 
-  TupleContextualFailure failure(cs, purpose, fromType, toType, locator);
+  TupleContextualFailure failure(cs, purpose, fromType, toType, indices, locator);
   return failure.diagnose(asNote);
 }
 
@@ -298,8 +309,10 @@ bool AllowTupleTypeMismatch::diagnose(bool asNote) const {
 
 AllowTupleTypeMismatch *
 AllowTupleTypeMismatch::create(ConstraintSystem &cs, Type lhs, Type rhs,
-                               ConstraintLocator *locator) {
-  return new (cs.getAllocator()) AllowTupleTypeMismatch(cs, lhs, rhs, locator);
+                               ConstraintLocator *locator,
+                               Optional<unsigned> index) {
+  return new (cs.getAllocator())
+      AllowTupleTypeMismatch(cs, lhs, rhs, locator, index);
 }
 
 bool GenericArgumentsMismatch::diagnose(bool asNote) const {

lib/Sema/CSFix.h

@@ -954,14 +954,20 @@ class AllowInvalidInitRef final : public ConstraintFix {
 };
 
 class AllowTupleTypeMismatch final : public ContextualMismatch {
+  /// If this is an element mismatch, \c Index is the element index where the
+  /// type mismatch occurred. If this is an arity or label mismatch, \c Index
+  /// will be \c None.
+  Optional<unsigned> Index;
+
   AllowTupleTypeMismatch(ConstraintSystem &cs, Type lhs, Type rhs,
-                         ConstraintLocator *locator)
+                         ConstraintLocator *locator, Optional<unsigned> index)
       : ContextualMismatch(cs, FixKind::AllowTupleTypeMismatch, lhs, rhs,
-                           locator) {}
+                           locator), Index(index) {}
 
 public:
   static AllowTupleTypeMismatch *create(ConstraintSystem &cs, Type lhs,
-                                        Type rhs, ConstraintLocator *locator);
+                                        Type rhs, ConstraintLocator *locator,
+                                        Optional<unsigned> index = None);
 
   static bool classof(const ConstraintFix *fix) {
     return fix->getKind() == FixKind::AllowTupleTypeMismatch;
@@ -971,6 +977,10 @@ class AllowTupleTypeMismatch final : public ContextualMismatch {
     return "fix tuple mismatches in type and arity";
   }
 
+  bool isElementMismatch() const {
+    return Index.hasValue();
+  }
+
   bool coalesceAndDiagnose(ArrayRef<ConstraintFix *> secondaryFixes,
                            bool asNote = false) const override;
 

lib/Sema/CSSimplify.cpp

@@ -3536,7 +3536,9 @@ bool ConstraintSystem::repairFailures(
         tupleLocator->isLastElement<LocatorPathElt::SequenceElementType>())
       break;
 
-    auto *fix = AllowTupleTypeMismatch::create(*this, lhs, rhs, tupleLocator);
+    auto index = elt.getAs<LocatorPathElt::TupleElement>()->getIndex();
+    auto *fix =
+        AllowTupleTypeMismatch::create(*this, lhs, rhs, tupleLocator, index);
     conversionsOrFixes.push_back(fix);
     break;
   }
@@ -8435,7 +8437,7 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyFixConstraint(
   }
 
   case FixKind::AllowTupleTypeMismatch: {
-    if (!(type1->is<TupleType>() && type2->is<TupleType>())) {
+    if (fix->getAs<AllowTupleTypeMismatch>()->isElementMismatch()) {
       auto *locator = fix->getLocator();
       if (recordFix(fix, /*impact*/locator->isForContextualType() ? 5 : 1))
         return SolutionKind::Error;