[Diagnostics] Tweak some diagnostics code to allow diagnosing a fix

anchored at a TypeRepr rather than an Expr.

Author: hborla

lib/Sema/CSDiagnostics.cpp

@@ -414,7 +414,7 @@ void RequirementFailure::emitRequirementNote(const Decl *anchor, Type lhs,
 }
 
 bool MissingConformanceFailure::diagnoseAsError() {
-  auto *anchor = castToExpr(getAnchor());
+  auto anchor = getAnchor();
   auto nonConformingType = getLHS();
   auto protocolType = getRHS();
 
@@ -423,8 +423,9 @@ bool MissingConformanceFailure::diagnoseAsError() {
   // with it and if so skip conformance error, otherwise we'd
   // produce an unrelated `<type> doesn't conform to Equatable protocol`
   // diagnostic.
-  if (isPatternMatchingOperator(const_cast<Expr *>(anchor))) {
-    if (auto *binaryOp = dyn_cast_or_null<BinaryExpr>(findParentExpr(anchor))) {
+  if (isPatternMatchingOperator(anchor)) {
+    auto *expr = castToExpr(anchor);
+    if (auto *binaryOp = dyn_cast_or_null<BinaryExpr>(findParentExpr(expr))) {
       auto *caseExpr = binaryOp->getArg()->getElement(0);
 
       llvm::SmallPtrSet<Expr *, 4> anchors;
@@ -452,6 +453,7 @@ bool MissingConformanceFailure::diagnoseAsError() {
   // says that conformances for enums with associated values can't be
   // synthesized.
   if (isStandardComparisonOperator(anchor)) {
+    auto *expr = castToExpr(anchor);
     auto isEnumWithAssociatedValues = [](Type type) -> bool {
       if (auto *enumType = type->getAs<EnumType>())
         return !enumType->getDecl()->hasOnlyCasesWithoutAssociatedValues();
@@ -464,7 +466,7 @@ bool MissingConformanceFailure::diagnoseAsError() {
         (protocol->isSpecificProtocol(KnownProtocolKind::Equatable) ||
          protocol->isSpecificProtocol(KnownProtocolKind::Comparable))) {
       if (RequirementFailure::diagnoseAsError()) {
-        auto opName = getOperatorName(anchor);
+        auto opName = getOperatorName(expr);
         emitDiagnostic(diag::no_binary_op_overload_for_enum_with_payload,
                        opName->str());
         return true;
@@ -4998,8 +5000,15 @@ bool MissingGenericArgumentsFailure::diagnoseAsError() {
         scopedParameters[base].push_back(GP);
       });
 
-  if (!isScoped)
-    return diagnoseForAnchor(castToExpr(getAnchor()), Parameters);
+  // FIXME: this code should be generalized now that we can anchor the
+  // fixes on the TypeRepr with the missing generic arg.
+  if (!isScoped) {
+    assert(getAnchor().is<Expr *>() || getAnchor().is<TypeRepr *>());
+    if (auto *expr = getAsExpr(getAnchor()))
+      return diagnoseForAnchor(expr, Parameters);
+
+    return diagnoseForAnchor(getAnchor().get<TypeRepr *>(), Parameters);
+  }
 
   bool diagnosed = false;
   for (const auto &scope : scopedParameters)

lib/Sema/CSDiagnostics.h

@@ -265,8 +265,9 @@ class RequirementFailure : public FailureDiagnostic {
     assert(getGenericContext() &&
            "Affected decl not within a generic context?");
 
-    if (auto *parentExpr = findParentExpr(getRawAnchor().get<Expr *>()))
-      Apply = dyn_cast<ApplyExpr>(parentExpr);
+    if (auto *expr = getAsExpr(getRawAnchor()))
+      if (auto *parentExpr = findParentExpr(expr))
+        Apply = dyn_cast<ApplyExpr>(parentExpr);
   }
 
   unsigned getRequirementIndex() const {

lib/Sema/ConstraintSystem.cpp

@@ -4249,11 +4249,17 @@ Optional<Identifier> constraints::getOperatorName(Expr *expr) {
   return None;
 }
 
-bool constraints::isPatternMatchingOperator(Expr *expr) {
+bool constraints::isPatternMatchingOperator(ASTNode node) {
+  auto *expr = getAsExpr(node);
+  if (!expr) return false;
+
   return isOperator(expr, "~=");
 }
 
-bool constraints::isStandardComparisonOperator(Expr *expr) {
+bool constraints::isStandardComparisonOperator(ASTNode node) {
+  auto *expr = getAsExpr(node);
+  if (!expr) return false;
+
   if (auto opName = getOperatorName(expr)) {
     return opName->is("==") || opName->is("!=") || opName->is("===") ||
            opName->is("!==") || opName->is("<") || opName->is(">") ||

lib/Sema/ConstraintSystem.h

@@ -5224,13 +5224,13 @@ bool isArgumentOfPatternMatchingOperator(ConstraintLocator *locator);
 /// associated with `===` and `!==` operators.
 bool isArgumentOfReferenceEqualityOperator(ConstraintLocator *locator);
 
-/// Determine whether given expression is a reference to a
+/// Determine whether the given AST node is a reference to a
 /// pattern-matching operator `~=`
-bool isPatternMatchingOperator(Expr *expr);
+bool isPatternMatchingOperator(ASTNode node);
 
-/// Determine whether given expression is a reference to a
+/// Determine whether the given AST node is a reference to a
 /// "standard" comparison operator such as "==", "!=", ">" etc.
-bool isStandardComparisonOperator(Expr *expr);
+bool isStandardComparisonOperator(ASTNode node);
 
 /// If given expression references operator overlaod(s)
 /// extract and produce name of the operator.