Diagnostics: Changed tuple mismatch fix constraint generation to use matchTupleTypes

Author: sl

lib/Sema/CSDiag.cpp

@@ -1149,8 +1149,7 @@ bool FailureDiagnosis::diagnoseGeneralConversionFailure(Constraint *constraint){
       if (fromTT->getNumElements() != toTT->getNumElements()) {
         auto failure = TupleContextualFailure(anchor, CS, fromTT, toTT,
                                               CS.getConstraintLocator(expr));
-        failure.diagnoseAsError();
-        return true;
+        return failure.diagnoseAsError();
       }
 
       SmallVector<TupleTypeElt, 4> FromElts;
@@ -1168,8 +1167,7 @@ bool FailureDiagnosis::diagnoseGeneralConversionFailure(Constraint *constraint){
                               toTT->getElements(), sources)) {
         auto failure = TupleContextualFailure(anchor, CS, fromTT, toTT,
                                               CS.getConstraintLocator(expr));
-        failure.diagnoseAsError();
-        return true;
+        return failure.diagnoseAsError();
       }
     }
 

lib/Sema/CSDiagnostics.h

@@ -769,10 +769,10 @@ class TupleContextualFailure final : public ContextualFailure {
   bool diagnoseAsError() override;
 
   bool isNumElementsMismatch() const {
-    auto lhsTy = dyn_cast<TupleType>(getFromType().getPointer());
-    auto rhsTy = dyn_cast<TupleType>(getToType().getPointer());
+    auto lhsTy = getFromType()->castTo<TupleType>();
+    auto rhsTy = getToType()->castTo<TupleType>();
     assert(lhsTy && rhsTy);
-    return lhsTy->getElements().size() != rhsTy->getElements().size();
+    return lhsTy->getNumElements() != rhsTy->getNumElements();
   }
 };
 

lib/Sema/CSFix.cpp

@@ -230,14 +230,16 @@ ContextualMismatch *ContextualMismatch::create(ConstraintSystem &cs, Type lhs,
 }
 
 bool AllowTupleTypeMismatch::diagnose(Expr *root, bool asNote) const {
-  auto failure = TupleContextualFailure(root, getConstraintSystem(), LHS, RHS,
-                                        getLocator());
+  auto failure = TupleContextualFailure(
+      root, getConstraintSystem(), getFromType(), getToType(), getLocator());
   return failure.diagnose(asNote);
 }
 
 AllowTupleTypeMismatch *
 AllowTupleTypeMismatch::create(ConstraintSystem &cs, Type lhs, Type rhs,
                                ConstraintLocator *locator) {
+  assert(lhs->is<TupleType>() && rhs->is<TupleType>() &&
+         "lhs and rhs must be tuple types");
   return new (cs.getAllocator()) AllowTupleTypeMismatch(cs, lhs, rhs, locator);
 }
 

lib/Sema/CSFix.h

@@ -136,8 +136,8 @@ enum class FixKind : uint8_t {
   /// referenced constructor must be required.
   AllowInvalidInitRef,
 
-  /// Allow a tuple to be destructured with a mismatched number of
-  /// elements, or mismatched types.
+  /// Allow a tuple to be destructured with mismatched arity, or mismatched
+  /// types.
   AllowTupleTypeMismatch,
 
   /// Allow an invalid member access on a value of protocol type as if
@@ -498,6 +498,9 @@ class ContextualMismatch : public ConstraintFix {
                      ConstraintLocator *locator)
       : ConstraintFix(cs, FixKind::ContextualMismatch, locator), LHS(lhs),
         RHS(rhs) {}
+  ContextualMismatch(ConstraintSystem &cs, FixKind kind, Type lhs, Type rhs,
+                     ConstraintLocator *locator)
+      : ConstraintFix(cs, kind, locator), LHS(lhs), RHS(rhs) {}
 
 public:
   std::string getName() const override { return "fix contextual mismatch"; }
@@ -866,20 +869,18 @@ class AllowInvalidInitRef final : public ConstraintFix {
                                      ConstraintLocator *locator);
 };
 
-class AllowTupleTypeMismatch final : public ConstraintFix {
-  Type LHS, RHS;
-
+class AllowTupleTypeMismatch final : public ContextualMismatch {
   AllowTupleTypeMismatch(ConstraintSystem &cs, Type lhs, Type rhs,
                          ConstraintLocator *locator)
-      : ConstraintFix(cs, FixKind::AllowTupleTypeMismatch, locator), LHS(lhs),
-        RHS(rhs) {}
+      : ContextualMismatch(cs, FixKind::AllowTupleTypeMismatch, lhs, rhs,
+                           locator) {}
 
 public:
   static AllowTupleTypeMismatch *create(ConstraintSystem &cs, Type lhs,
                                         Type rhs, ConstraintLocator *locator);
 
   std::string getName() const override {
-    return "allow invalid tuple destructuring";
+    return "fix tuple mismatches in type and arity";
   }
 
   bool diagnose(Expr *root, bool asNote = false) const override;

lib/Sema/CSSimplify.cpp

@@ -6964,29 +6964,42 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyFixConstraint(
   }
 
   case FixKind::AllowTupleTypeMismatch: {
-    auto lhs = dyn_cast<TupleType>(type1.getPointer());
-    auto rhs = dyn_cast<TupleType>(type2.getPointer());
-    auto lhsLarger = lhs->getElements().size() >= rhs->getElements().size();
+    auto lhs = type1->castTo<TupleType>();
+    auto rhs = type2->castTo<TupleType>();
+    // Create a new tuple type the size of the smaller tuple with elements
+    // from the larger tuple whenever either side contains a type variable.
+    // For example (A, $0, B, $2) and (X, Y, $1) produces: (X, $0, B).
+    // This allows us to guarentee that the types will match, and all
+    // type variables will get bound to something as long as we default
+    // excess types in the larger tuple to Any. In the prior example,
+    // when the tuples (X, Y, $1) and (X, $0, B) get matched, $0 is equated
+    // to Y, $1 is equated to B, and $2 is defaulted to Any.
+    auto lhsLarger = lhs->getNumElements() >= rhs->getNumElements();
     auto larger = lhsLarger ? lhs : rhs;
     auto smaller = lhsLarger ? rhs : lhs;
-    if (lhs && rhs && getContextualTypePurpose() == CTP_Initialization) {
-      // Match up the tuple type elements, and match any
-      for (unsigned i = 0; i < larger->getElements().size(); ++i) {
-        auto largerTy = larger->getElement(i).getType();
-        if (i < smaller->getElements().size()) {
-          auto smallerTy = smaller->getElement(i).getType();
-          if (smallerTy->isTypeVariableOrMember() ||
-              largerTy->isTypeVariableOrMember())
-            addConstraint(ConstraintKind::Bind, largerTy, smallerTy,
-                          getConstraintLocator(locator));
-        } else {
-          addConstraint(ConstraintKind::Defaultable, largerTy,
+    llvm::SmallVector<TupleTypeElt, 4> newTupleTypes;
+
+    for (unsigned i = 0; i < larger->getNumElements(); ++i) {
+      auto largerElt = larger->getElement(i);
+      if (i < smaller->getNumElements()) {
+        auto smallerElt = smaller->getElement(i);
+        if (largerElt.getType()->isTypeVariableOrMember() ||
+            smallerElt.getType()->isTypeVariableOrMember())
+          newTupleTypes.push_back(largerElt);
+        else
+          newTupleTypes.push_back(smallerElt);
+      } else {
+        if (largerElt.getType()->isTypeVariableOrMember())
+          addConstraint(ConstraintKind::Defaultable, largerElt.getType(),
                         getASTContext().TheAnyType,
                         getConstraintLocator(locator));
-        }
       }
     }
-    return recordFix(fix) ? SolutionKind::Error : SolutionKind::Solved;
+    auto matchingType =
+        TupleType::get(newTupleTypes, getASTContext())->castTo<TupleType>();
+    if (recordFix(fix))
+      return SolutionKind::Error;
+    return matchTupleTypes(matchingType, smaller, matchKind, subflags, locator);
   }
 
   case FixKind::InsertCall: