[ConstraintSystem] Port tuple type mismatches to the new framework

Author: hborla

include/swift/AST/DiagnosticsSema.def

@@ -956,9 +956,6 @@ ERROR(tuple_types_not_convertible_nelts,none,
       "%0 is not convertible to %1, "
       "tuples have a different number of elements", (Type, Type))
 
-ERROR(tuple_types_not_convertible,none,
-      "tuple type %0 is not convertible to tuple %1", (Type, Type))
-
 ERROR(invalid_force_unwrap,none,
       "cannot force unwrap value of non-optional type %0", (Type))
 ERROR(invalid_optional_chain,none,

lib/Sema/CSDiag.cpp

@@ -255,8 +255,7 @@ class FailureDiagnosis :public ASTVisitor<FailureDiagnosis, /*exprresult*/bool>{
   bool visitExpr(Expr *E);
   bool visitIdentityExpr(IdentityExpr *E);
   bool visitTryExpr(TryExpr *E);
-  bool visitTupleExpr(TupleExpr *E);
-  
+
   bool visitUnresolvedMemberExpr(UnresolvedMemberExpr *E);
   bool visitUnresolvedDotExpr(UnresolvedDotExpr *UDE);
   bool visitArrayExpr(ArrayExpr *E);
@@ -2936,58 +2935,6 @@ bool FailureDiagnosis::visitUnresolvedDotExpr(UnresolvedDotExpr *UDE) {
                                 locator);
 }
 
-/// A TupleExpr propagate contextual type information down to its children and
-/// can be erroneous when there is a label mismatch etc.
-bool FailureDiagnosis::visitTupleExpr(TupleExpr *TE) {
-  // If we know the requested argType to use, use computeTupleShuffle to produce
-  // the shuffle of input arguments to destination values.  It requires a
-  // TupleType to compute the mapping from argExpr.  Conveniently, it doesn't
-  // care about the actual types though, so we can just use 'void' for them.
-  if (!CS.getContextualType() || !CS.getContextualType()->is<TupleType>())
-    return visitExpr(TE);
-
-  auto contextualTT = CS.getContextualType()->castTo<TupleType>();
-
-  SmallVector<TupleTypeElt, 4> ArgElts;
-  auto voidTy = CS.getASTContext().TheEmptyTupleType;
-
-  for (unsigned i = 0, e = TE->getNumElements(); i != e; ++i)
-    ArgElts.push_back({ voidTy, TE->getElementName(i) });
-  auto TEType = TupleType::get(ArgElts, CS.getASTContext());
-
-  if (!TEType->is<TupleType>())
-    return visitExpr(TE);
-
-  SmallVector<unsigned, 4> sources;
-  
-  // If the shuffle is invalid, then there is a type error.  We could diagnose
-  // it specifically here, but the general logic does a fine job so we let it
-  // do it.
-  if (computeTupleShuffle(TEType->castTo<TupleType>()->getElements(),
-                          contextualTT->getElements(), sources))
-    return visitExpr(TE);
-
-  // If we got a correct shuffle, we can perform the analysis of all of
-  // the input elements, with their expected types.
-  for (unsigned i = 0, e = sources.size(); i != e; ++i) {
-    // Otherwise, it must match the corresponding expected argument type.
-    unsigned inArgNo = sources[i];
-
-    TCCOptions options;
-    if (contextualTT->getElement(i).isInOut())
-      options |= TCC_AllowLValue;
-
-    auto actualType = contextualTT->getElementType(i);
-    auto exprResult =
-        typeCheckChildIndependently(TE->getElement(inArgNo), actualType,
-                                    CS.getContextualTypePurpose(), options);
-    // If there was an error type checking this argument, then we're done.
-    if (!exprResult) return true;
-  }
-  
-  return false;
-}
-
 /// An IdentityExpr doesn't change its argument, but it *can* propagate its
 /// contextual type information down.
 bool FailureDiagnosis::visitIdentityExpr(IdentityExpr *E) {

lib/Sema/CSDiagnostics.cpp

@@ -131,9 +131,7 @@ FailureDiagnostic::getChoiceFor(ConstraintLocator *locator) const {
   return getOverloadChoiceIfAvailable(cs.getCalleeLocator(locator));
 }
 
-Type FailureDiagnostic::resolveInterfaceType(Type type,
-                                             bool reconstituteSugar) const {
-  auto &cs = getConstraintSystem();
+static Type resolveInterfaceType(ConstraintSystem &cs, Type type) {
   auto resolvedType = type.transform([&](Type type) -> Type {
     if (auto *tvt = type->getAs<TypeVariableType>()) {
       // If this type variable is for a generic parameter, return that.
@@ -142,13 +140,13 @@ Type FailureDiagnostic::resolveInterfaceType(Type type,
 
       // Otherwise resolve its fixed type, mapped out of context.
       if (auto fixed = cs.getFixedType(tvt))
-        return resolveInterfaceType(fixed->mapTypeOutOfContext());
+        return resolveInterfaceType(cs, fixed->mapTypeOutOfContext());
 
       return cs.getRepresentative(tvt);
     }
     if (auto *dmt = type->getAs<DependentMemberType>()) {
       // For a dependent member, first resolve the base.
-      auto newBase = resolveInterfaceType(dmt->getBase());
+      auto newBase = resolveInterfaceType(cs, dmt->getBase());
 
       // Then reconstruct using its associated type.
       assert(dmt->getAssocType());
@@ -158,8 +156,7 @@ Type FailureDiagnostic::resolveInterfaceType(Type type,
   });
 
   assert(!resolvedType->hasArchetype());
-  return reconstituteSugar ? resolvedType->reconstituteSugar(/*recursive*/ true)
-                           : resolvedType;
+  return resolvedType;
 }
 
 /// Given an apply expr, returns true if it is expected to have a direct callee
@@ -192,8 +189,8 @@ static bool shouldHaveDirectCalleeOverload(const CallExpr *callExpr) {
 }
 
 Optional<FunctionArgApplyInfo>
-FailureDiagnostic::getFunctionArgApplyInfo(ConstraintLocator *locator) const {
-  auto &cs = getConstraintSystem();
+FailureDiagnostic::getFunctionArgApplyInfo(ConstraintSystem &cs,
+                                           ConstraintLocator *locator) {
   auto *anchor = locator->getAnchor();
   auto path = locator->getPath();
 
@@ -225,7 +222,8 @@ FailureDiagnostic::getFunctionArgApplyInfo(ConstraintLocator *locator) const {
 
   Optional<OverloadChoice> choice;
   Type rawFnType;
-  if (auto overload = getChoiceFor(argLocator)) {
+  auto *calleeLocator = cs.getCalleeLocator(argLocator);
+  if (auto overload = cs.findSelectedOverloadFor(calleeLocator)) {
     // If we have resolved an overload for the callee, then use that to get the
     // function type and callee.
     choice = overload->choice;
@@ -249,7 +247,8 @@ FailureDiagnostic::getFunctionArgApplyInfo(ConstraintLocator *locator) const {
 
   // Try to resolve the function type by loading lvalues and looking through
   // optional types, which can occur for expressions like `fn?(5)`.
-  auto *fnType = resolveType(rawFnType)
+  auto *fnType = cs.simplifyType(rawFnType)
+                     ->getRValueType()
                      ->lookThroughAllOptionalTypes()
                      ->getAs<FunctionType>();
   if (!fnType)
@@ -280,13 +279,14 @@ FailureDiagnostic::getFunctionArgApplyInfo(ConstraintLocator *locator) const {
       (void)fn;
     }
   } else {
-    fnInterfaceType = resolveInterfaceType(rawFnType);
+    fnInterfaceType = resolveInterfaceType(cs, rawFnType);
   }
 
   auto argIdx = applyArgElt->getArgIdx();
   auto paramIdx = applyArgElt->getParamIdx();
 
-  return FunctionArgApplyInfo(cs, argExpr, argIdx, getType(argExpr),
+  return FunctionArgApplyInfo(cs, argExpr, argIdx,
+                              cs.simplifyType(cs.getType(argExpr)),
                               paramIdx, fnInterfaceType, fnType, callee);
 }
 
@@ -929,7 +929,8 @@ bool NoEscapeFuncToTypeConversionFailure::diagnoseParameterUse() const {
     // Let's check whether this is a function parameter passed
     // as an argument to another function which accepts @escaping
     // function at that position.
-    if (auto argApplyInfo = getFunctionArgApplyInfo(getLocator())) {
+    auto &cs = getConstraintSystem();
+    if (auto argApplyInfo = getFunctionArgApplyInfo(cs, getLocator())) {
       auto paramInterfaceTy = argApplyInfo->getParamInterfaceType();
       if (paramInterfaceTy->isTypeParameter()) {
         auto diagnoseGenericParamFailure = [&](GenericTypeParamDecl *decl) {
@@ -1137,7 +1138,8 @@ void MissingOptionalUnwrapFailure::offerDefaultValueUnwrapFixIt(
   if (isa<InOutExpr>(anchor))
     return;
 
-  if (auto argApplyInfo = getFunctionArgApplyInfo(getLocator()))
+  auto &cs = getConstraintSystem();
+  if (auto argApplyInfo = getFunctionArgApplyInfo(cs, getLocator()))
     if (argApplyInfo->getParameterFlags().isInOut())
       return;
 
@@ -2963,8 +2965,12 @@ ContextualFailure::getDiagnosticFor(ContextualTypePurpose context,
 bool TupleContextualFailure::diagnoseAsError() {
   auto diagnostic = isNumElementsMismatch()
                         ? diag::tuple_types_not_convertible_nelts
-                        : diag::tuple_types_not_convertible;
-  emitDiagnostic(getAnchor()->getLoc(), diagnostic, getFromType(), getToType());
+                        : getDiagnosticFor(getContextualTypePurpose(),
+                                           /*forProtocol=*/false);
+  if (!diagnostic)
+    return false;
+
+  emitDiagnostic(getAnchor()->getLoc(), *diagnostic, getFromType(), getToType());
   return true;
 }
 
@@ -3796,7 +3802,7 @@ bool MissingArgumentsFailure::diagnoseAsError() {
   // foo(bar) // `() -> Void` vs. `(Int) -> Void`
   // ```
   if (locator->isLastElement<LocatorPathElt::ApplyArgToParam>()) {
-    auto info = *getFunctionArgApplyInfo(locator);
+    auto info = *getFunctionArgApplyInfo(cs, locator);
 
     auto *argExpr = info.getArgExpr();
     emitDiagnostic(argExpr->getLoc(), diag::cannot_convert_argument_value,
@@ -4012,7 +4018,7 @@ bool MissingArgumentsFailure::diagnoseClosure(ClosureExpr *closure) {
   auto *locator = getLocator();
   if (locator->isForContextualType()) {
     funcType = cs.getContextualType()->getAs<FunctionType>();
-  } else if (auto info = getFunctionArgApplyInfo(locator)) {
+  } else if (auto info = getFunctionArgApplyInfo(cs, locator)) {
     funcType = info->getParamType()->getAs<FunctionType>();
   } else if (locator->isLastElement<LocatorPathElt::ClosureResult>()) {
     // Based on the locator we know this this is something like this:
@@ -4725,7 +4731,8 @@ SourceLoc InvalidUseOfAddressOf::getLoc() const {
 }
 
 bool InvalidUseOfAddressOf::diagnoseAsError() {
-  if (auto argApplyInfo = getFunctionArgApplyInfo(getLocator())) {
+  auto &cs = getConstraintSystem();
+  if (auto argApplyInfo = getFunctionArgApplyInfo(cs, getLocator())) {
     if (!argApplyInfo->getParameterFlags().isInOut()) {
       auto anchor = getAnchor();
       emitDiagnostic(anchor->getLoc(), diag::extra_address_of, getToType())
@@ -5245,18 +5252,19 @@ bool ThrowingFunctionConversionFailure::diagnoseAsError() {
 }
 
 bool InOutConversionFailure::diagnoseAsError() {
+  auto &cs = getConstraintSystem();
   auto *anchor = getAnchor();
   auto *locator = getLocator();
   auto path = locator->getPath();
 
   if (!path.empty() &&
       path.back().getKind() == ConstraintLocator::FunctionArgument) {
-    if (auto argApplyInfo = getFunctionArgApplyInfo(locator)) {
+    if (auto argApplyInfo = getFunctionArgApplyInfo(cs, locator)) {
       emitDiagnostic(anchor->getLoc(), diag::cannot_convert_argument_value,
           argApplyInfo->getArgType(), argApplyInfo->getParamType());
     } else {
       assert(locator->findLast<LocatorPathElt::ContextualType>());
-      auto contextualType = getConstraintSystem().getContextualType();
+      auto contextualType = cs.getContextualType();
       auto purpose = getContextualTypePurpose();
       auto diagnostic = getDiagnosticFor(purpose, /*forProtocol=*/false);
 

lib/Sema/CSDiagnostics.h

@@ -91,6 +91,13 @@ class FailureDiagnostic {
   Type getType(Expr *expr, bool wantRValue = true) const;
   Type getType(const TypeLoc &loc, bool wantRValue = true) const;
 
+  /// For a given locator describing a function argument conversion, or a
+  /// constraint within an argument conversion, returns information about the
+  /// application of the argument to its parameter. If the locator is not
+  /// for an argument conversion, returns \c None.
+  static Optional<FunctionArgApplyInfo>
+  getFunctionArgApplyInfo(ConstraintSystem &cs, ConstraintLocator *locator);
+
   /// Resolve type variables present in the raw type, if any.
   Type resolveType(Type rawType, bool reconstituteSugar = false,
                    bool wantRValue = true) const {
@@ -113,10 +120,6 @@ class FailureDiagnostic {
         });
   }
 
-  /// Resolve type variables present in the raw type, using generic parameter
-  /// types where possible.
-  Type resolveInterfaceType(Type type, bool reconstituteSugar = false) const;
-
   template <typename... ArgTypes>
   InFlightDiagnostic emitDiagnostic(ArgTypes &&... Args) const;
 
@@ -176,13 +179,6 @@ class FailureDiagnostic {
   /// of a given locator's anchor, or \c None if no such choice can be found.
   Optional<SelectedOverload> getChoiceFor(ConstraintLocator *) const;
 
-  /// For a given locator describing a function argument conversion, or a
-  /// constraint within an argument conversion, returns information about the
-  /// application of the argument to its parameter. If the locator is not
-  /// for an argument conversion, returns \c None.
-  Optional<FunctionArgApplyInfo>
-  getFunctionArgApplyInfo(ConstraintLocator *locator) const;
-
   /// \returns A new type with all of the type variables associated with
   /// generic parameters substituted back into being generic parameter type.
   Type restoreGenericParameters(
@@ -978,16 +974,17 @@ class InvalidUseOfAddressOf final : public ContextualFailure {
 /// Diagnose mismatches relating to tuple destructuring.
 class TupleContextualFailure final : public ContextualFailure {
 public:
-  TupleContextualFailure(ConstraintSystem &cs, Type lhs, Type rhs,
-                         ConstraintLocator *locator)
-      : ContextualFailure(cs, lhs, rhs, locator) {}
+  TupleContextualFailure(ConstraintSystem &cs, ContextualTypePurpose purpose,
+                         Type lhs, Type rhs, ConstraintLocator *locator)
+      : ContextualFailure(cs, purpose, lhs, rhs, locator) {
+    assert(getFromType()->is<TupleType>() && getToType()->is<TupleType>());
+  }
 
   bool diagnoseAsError() override;
 
   bool isNumElementsMismatch() const {
     auto lhsTy = getFromType()->castTo<TupleType>();
     auto rhsTy = getToType()->castTo<TupleType>();
-    assert(lhsTy && rhsTy);
     return lhsTy->getNumElements() != rhsTy->getNumElements();
   }
 };
@@ -1819,7 +1816,7 @@ class ArgumentMismatchFailure : public ContextualFailure {
   ArgumentMismatchFailure(ConstraintSystem &cs, Type argType,
                           Type paramType, ConstraintLocator *locator)
       : ContextualFailure(cs, argType, paramType, locator),
-        Info(getFunctionArgApplyInfo(getLocator())) {}
+        Info(getFunctionArgApplyInfo(cs, getLocator())) {}
 
   bool diagnoseAsError() override;
   bool diagnoseAsNote() override;

lib/Sema/CSFix.cpp

@@ -255,17 +255,51 @@ ContextualMismatch *ContextualMismatch::create(ConstraintSystem &cs, Type lhs,
   return new (cs.getAllocator()) ContextualMismatch(cs, lhs, rhs, locator);
 }
 
-bool AllowTupleTypeMismatch::diagnose(bool asNote) const {
-  auto failure = TupleContextualFailure(
-      getConstraintSystem(), getFromType(), getToType(), getLocator());
+bool AllowTupleTypeMismatch::coalesceAndDiagnose(
+    ArrayRef<ConstraintFix *> fixes, bool asNote) const {
+  auto &cs = getConstraintSystem();
+  auto *locator = getLocator();
+  auto purpose = cs.getContextualTypePurpose();
+  Type fromType;
+  Type toType;
+
+  if (getFromType()->is<TupleType>() && getToType()->is<TupleType>()) {
+    fromType = getFromType();
+    toType = getToType();
+  } else if (auto contextualType = cs.getContextualType()) {
+    auto *tupleExpr = simplifyLocatorToAnchor(locator);
+    if (!tupleExpr)
+      return false;
+    fromType = cs.getType(tupleExpr);
+    toType = contextualType;
+  } else if (auto argApplyInfo =
+                 FailureDiagnostic::getFunctionArgApplyInfo(cs, locator)) {
+    purpose = CTP_CallArgument;
+    fromType = argApplyInfo->getArgType();
+    toType = argApplyInfo->getParamType();
+  } else if (auto *coerceExpr = dyn_cast<CoerceExpr>(locator->getAnchor())) {
+    purpose = CTP_CoerceOperand;
+    fromType = cs.getType(coerceExpr->getSubExpr());
+    toType = cs.getType(coerceExpr);
+  } else if (auto *assignExpr = dyn_cast<AssignExpr>(locator->getAnchor())) {
+    purpose = CTP_AssignSource;
+    fromType = cs.getType(assignExpr->getSrc());
+    toType = cs.getType(assignExpr->getDest());
+  } else {
+    return false;
+  }
+
+  TupleContextualFailure failure(cs, purpose, fromType, toType, locator);
   return failure.diagnose(asNote);
 }
 
+bool AllowTupleTypeMismatch::diagnose(bool asNote) const {
+  return coalesceAndDiagnose({}, 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

@@ -963,10 +963,17 @@ class AllowTupleTypeMismatch final : public ContextualMismatch {
   static AllowTupleTypeMismatch *create(ConstraintSystem &cs, Type lhs,
                                         Type rhs, ConstraintLocator *locator);
 
+  static bool classof(const ConstraintFix *fix) {
+    return fix->getKind() == FixKind::AllowTupleTypeMismatch;
+  }
+
   std::string getName() const override {
     return "fix tuple mismatches in type and arity";
   }
 
+  bool coalesceAndDiagnose(ArrayRef<ConstraintFix *> secondaryFixes,
+                           bool asNote = false) const override;
+
   bool diagnose(bool asNote = false) const override;
 };