---

yaml
---
r: 326007
b: refs/heads/master-next
c: 93b39c9
h: refs/heads/master
i:
  326005: b5ea6b1
  326003: 4e41ece
  325999: f70de4b

Author: xedin

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: e052da7d8886fa0439677852e8f7830b20c2e1da
-refs/heads/master-next: 1a57fc403a4ccdc194d2a0d501632422b9e2e70a
+refs/heads/master-next: 93b39c9c2324f853e4c8515d1f9ce9071bc0e625
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-b: 66d897bfcf64a82cb9a87f5e663d889189d06d07

branches/master-next/lib/Sema/CSDiag.cpp

@@ -4080,23 +4080,22 @@ bool FailureDiagnosis::visitApplyExpr(ApplyExpr *callExpr) {
                                      callExpr->getLoc()))
       return true;
 
+    // TODO(diagnostics): There are still cases not yet handled by new
+    // diagnostics framework e.g.
+    //
+    // var tuple = (1, 2, 3)
+    // switch tuple {
+    //   case (let (_, _, _)) + 1: break
+    // }
     if (callExpr->isImplicit() && overloadName == "~=") {
-      // This binop was synthesized when typechecking an expression pattern.
-      auto diag = lhsType->is<UnresolvedType>()
-        ? diagnose(lhsExpr->getLoc(),
-                   diag::cannot_match_unresolved_expr_pattern_with_value,
-                   rhsType)
-        : diagnose(lhsExpr->getLoc(),
-                   diag::cannot_match_expr_pattern_with_value,
-                   lhsType, rhsType);
-      diag.highlight(lhsExpr->getSourceRange());
-      diag.highlight(rhsExpr->getSourceRange());
-      if (auto optUnwrappedType = rhsType->getOptionalObjectType()) {
-        if (lhsType->isEqual(optUnwrappedType)) {
-          diag.fixItInsertAfter(lhsExpr->getEndLoc(), "?");
-        }
-      }
-      return true;
+      auto *locator =
+          CS.getConstraintLocator(callExpr,
+                                  {ConstraintLocator::ApplyArgument,
+                                   LocatorPathElt::ApplyArgToParam(0, 0)},
+                                  /*summaryFlags=*/0);
+
+      ArgumentMismatchFailure failure(expr, CS, lhsType, rhsType, locator);
+      return failure.diagnosePatternMatchingMismatch();
     }
 
     // Diagnose attempts to compare reference equality of certain types.

branches/master-next/lib/Sema/CSDiagnostics.cpp

@@ -4455,6 +4455,9 @@ bool ArgumentMismatchFailure::diagnoseAsError() {
   if (diagnoseArchetypeMismatch())
     return true;
 
+  if (diagnosePatternMatchingMismatch())
+    return true;
+
   auto argType = getFromType();
   auto paramType = getToType();
 
@@ -4488,17 +4491,46 @@ bool ArgumentMismatchFailure::diagnoseAsNote() {
   auto argToParam = locator->findFirst<LocatorPathElt::ApplyArgToParam>();
   assert(argToParam);
 
-  if (auto overload = getChoiceFor(getRawAnchor())) {
-    if (auto *decl = overload->choice.getDeclOrNull()) {
-      emitDiagnostic(decl, diag::candidate_has_invalid_argument_at_position,
-                     getToType(), argToParam->getParamIdx());
-      return true;
-    }
+  if (auto *decl = getDecl()) {
+    emitDiagnostic(decl, diag::candidate_has_invalid_argument_at_position,
+                   getToType(), argToParam->getParamIdx());
+    return true;
   }
 
   return false;
 }
 
+bool ArgumentMismatchFailure::diagnosePatternMatchingMismatch() const {
+  if (!isArgumentOfPatternMatchingOperator(getLocator()))
+    return false;
+
+  auto *op = cast<BinaryExpr>(getRawAnchor());
+  auto *lhsExpr = op->getArg()->getElement(0);
+  auto *rhsExpr = op->getArg()->getElement(1);
+
+  auto lhsType = getType(lhsExpr)->getRValueType();
+  auto rhsType = getType(rhsExpr)->getRValueType();
+
+  auto diagnostic =
+      lhsType->is<UnresolvedType>()
+          ? emitDiagnostic(
+                getLoc(), diag::cannot_match_unresolved_expr_pattern_with_value,
+                rhsType)
+          : emitDiagnostic(getLoc(), diag::cannot_match_expr_pattern_with_value,
+                           lhsType, rhsType);
+
+  diagnostic.highlight(lhsExpr->getSourceRange());
+  diagnostic.highlight(rhsExpr->getSourceRange());
+
+  if (auto optUnwrappedType = rhsType->getOptionalObjectType()) {
+    if (lhsType->isEqual(optUnwrappedType)) {
+      diagnostic.fixItInsertAfter(lhsExpr->getEndLoc(), "?");
+    }
+  }
+
+  return true;
+}
+
 bool ArgumentMismatchFailure::diagnoseArchetypeMismatch() const {
   auto *argTy = getFromType()->getAs<ArchetypeType>();
   auto *paramTy = getToType()->getAs<ArchetypeType>();

branches/master-next/lib/Sema/CSDiagnostics.h

@@ -1619,8 +1619,20 @@ class ArgumentMismatchFailure : public ContextualFailure {
   /// produce a special diagnostic in case their names match.
   bool diagnoseArchetypeMismatch() const;
 
+  /// Tailored diagnostic for pattern matching with `~=` operator.
+  bool diagnosePatternMatchingMismatch() const;
+
 protected:
   SourceLoc getLoc() const { return getAnchor()->getLoc(); }
+
+  ValueDecl *getDecl() const {
+    auto selectedOverload = getChoiceFor(getRawAnchor());
+    if (!selectedOverload)
+      return nullptr;
+
+    auto choice = selectedOverload->choice;
+    return choice.getDeclOrNull();
+  }
 };
 
 /// Provides information about the application of a function argument to a

branches/master-next/lib/Sema/CSSimplify.cpp

@@ -2400,7 +2400,10 @@ bool ConstraintSystem::repairFailures(
     if (repairByInsertingExplicitCall(lhs, rhs))
       break;
 
-    if (repairViaBridgingCast(*this, lhs, rhs, conversionsOrFixes, locator))
+    bool isPatternMatching = isArgumentOfPatternMatchingOperator(loc);
+    // Let's not suggest force downcasts in pattern-matching context.
+    if (!isPatternMatching &&
+        repairViaBridgingCast(*this, lhs, rhs, conversionsOrFixes, locator))
       break;
 
     // Argument is a r-value but parameter expects an l-value e.g.
@@ -2580,6 +2583,13 @@ bool ConstraintSystem::repairFailures(
     if (hasConversionOrRestriction(ConversionRestrictionKind::DeepEquality))
       break;
 
+    // If this is a ~= operator implicitly generated by pattern matching
+    // let's not try to fix right-hand side of the operator because it's
+    // a correct contextual type.
+    if (isPatternMatching &&
+        elt.castTo<LocatorPathElt::ApplyArgToParam>().getParamIdx() == 1)
+      break;
+
     conversionsOrFixes.push_back(AllowArgumentMismatch::create(
         *this, lhs, rhs, getConstraintLocator(locator)));
     break;

branches/master-next/lib/Sema/ConstraintSystem.cpp

@@ -2898,3 +2898,35 @@ bool constraints::isKnownKeyPathDecl(ASTContext &ctx, ValueDecl *decl) {
          decl == ctx.getReferenceWritableKeyPathDecl() ||
          decl == ctx.getPartialKeyPathDecl() || decl == ctx.getAnyKeyPathDecl();
 }
+
+bool constraints::isArgumentOfPatternMatchingOperator(
+    ConstraintLocator *locator) {
+  Expr *anchor = nullptr;
+  if (locator->findLast<LocatorPathElt::ApplyArgToParam>()) {
+    anchor = locator->getAnchor();
+  } else {
+    return false;
+  }
+
+  auto *binaryOp = dyn_cast_or_null<BinaryExpr>(anchor);
+  if (!(binaryOp && binaryOp->isImplicit()))
+    return false;
+
+  auto *fnExpr = binaryOp->getFn()->getSemanticsProvidingExpr();
+
+  ValueDecl *choice = nullptr;
+  if (auto *ODRE = dyn_cast<OverloadedDeclRefExpr>(fnExpr)) {
+    choice = ODRE->getDecls().front();
+  } else if (auto *DRE = dyn_cast<DeclRefExpr>(fnExpr)) {
+    choice = DRE->getDecl();
+  } else {
+    return false;
+  }
+
+  if (auto *FD = dyn_cast_or_null<AbstractFunctionDecl>(choice)) {
+    auto name = FD->getBaseName().userFacingName();
+    return name == "~=";
+  }
+
+  return false;
+}

branches/master-next/lib/Sema/ConstraintSystem.h

@@ -3987,6 +3987,10 @@ Expr *simplifyLocatorToAnchor(ConstraintLocator *locator);
 /// wasn't of one of the kinds listed above.
 Expr *getArgumentExpr(Expr *expr, unsigned index);
 
+/// Determine whether given locator points to one of the arguments
+/// associated with implicit `~=` (pattern-matching) operator
+bool isArgumentOfPatternMatchingOperator(ConstraintLocator *locator);
+
 // Check whether argument of the call at given position refers to
 // parameter marked as `@autoclosure`. This function is used to
 // maintain source compatibility with Swift versions < 5,