[CSFix] Switch ConstraintFix::getAnchor to return TypedNode

Author: xedin

lib/Sema/CSFix.cpp

@@ -34,7 +34,7 @@ using namespace constraints;
 
 ConstraintFix::~ConstraintFix() {}
 
-Expr *ConstraintFix::getAnchor() const { return getLocator()->getAnchor(); }
+TypedNode ConstraintFix::getAnchor() const { return getLocator()->getAnchor(); }
 
 void ConstraintFix::print(llvm::raw_ostream &Out) const {
   Out << "[fix: ";
@@ -135,10 +135,10 @@ CoerceToCheckedCast *CoerceToCheckedCast::attempt(ConstraintSystem &cs,
   if (fromType->hasTypeVariable() || toType->hasTypeVariable())
     return nullptr;
 
-  auto *expr = locator->getAnchor();
-  if (auto *assignExpr = dyn_cast<AssignExpr>(expr))
-    expr = assignExpr->getSrc();
-  auto *coerceExpr = dyn_cast<CoerceExpr>(expr);
+  auto anchor = locator->getAnchor();
+  if (auto *assignExpr = getAsExpr<AssignExpr>(anchor))
+    anchor = assignExpr->getSrc();
+  auto *coerceExpr = getAsExpr<CoerceExpr>(anchor);
   if (!coerceExpr)
     return nullptr;
 
@@ -189,7 +189,8 @@ bool MissingConformance::diagnose(const Solution &solution, bool asNote) const {
 
   if (IsContextual) {
     auto &cs = solution.getConstraintSystem();
-    auto context = cs.getContextualTypePurpose(locator->getAnchor());
+    auto context =
+        cs.getContextualTypePurpose(locator->getAnchor().get<const Expr *>());
     MissingContextualConformanceFailure failure(
         solution, context, NonConformingType, ProtocolType, locator);
     return failure.diagnose(asNote);
@@ -264,7 +265,7 @@ getStructuralTypeContext(const Solution &solution, ConstraintLocator *locator) {
            locator->isLastElement<LocatorPathElt::FunctionArgument>());
 
     auto &cs = solution.getConstraintSystem();
-    auto *anchor = locator->getAnchor();
+    auto *anchor = locator->getAnchor().get<const Expr *>();
     auto contextualType = cs.getContextualType(anchor);
     auto exprType = cs.getType(anchor);
     return std::make_tuple(cs.getContextualTypePurpose(anchor), exprType,
@@ -273,15 +274,15 @@ getStructuralTypeContext(const Solution &solution, ConstraintLocator *locator) {
     return std::make_tuple(CTP_CallArgument,
                            argApplyInfo->getArgType(),
                            argApplyInfo->getParamType());
-  } else if (auto *coerceExpr = dyn_cast<CoerceExpr>(locator->getAnchor())) {
+  } else if (auto *coerceExpr = getAsExpr<CoerceExpr>(locator->getAnchor())) {
     return std::make_tuple(CTP_CoerceOperand,
                            solution.getType(coerceExpr->getSubExpr()),
                            solution.getType(coerceExpr));
-  } else if (auto *assignExpr = dyn_cast<AssignExpr>(locator->getAnchor())) {
+  } else if (auto *assignExpr = getAsExpr<AssignExpr>(locator->getAnchor())) {
     return std::make_tuple(CTP_AssignSource,
                            solution.getType(assignExpr->getSrc()),
                            solution.getType(assignExpr->getDest()));
-  } else if (auto *call = dyn_cast<CallExpr>(locator->getAnchor())) {
+  } else if (auto *call = getAsExpr<CallExpr>(locator->getAnchor())) {
     assert(isa<TypeExpr>(call->getFn()));
     return std::make_tuple(
         CTP_Initialization,
@@ -313,7 +314,8 @@ bool AllowTupleTypeMismatch::coalesceAndDiagnose(
   Type toType;
 
   if (getFromType()->is<TupleType>() && getToType()->is<TupleType>()) {
-    purpose = cs.getContextualTypePurpose(locator->getAnchor());
+    purpose =
+        cs.getContextualTypePurpose(locator->getAnchor().get<const Expr *>());
     fromType = getFromType();
     toType = getToType();
   } else if (auto contextualTypeInfo =
@@ -500,8 +502,9 @@ DefineMemberBasedOnUse::diagnoseForAmbiguity(CommonFixesArray commonFixes) const
       concreteBaseType = baseType;
 
     if (concreteBaseType->getCanonicalType() != baseType->getCanonicalType()) {
-      getConstraintSystem().getASTContext().Diags.diagnose(getAnchor()->getLoc(),
-          diag::unresolved_member_no_inference, Name);
+      auto &DE = getConstraintSystem().getASTContext().Diags;
+      DE.diagnose(getLoc(getAnchor()), diag::unresolved_member_no_inference,
+                  Name);
       return true;
     }
   }
@@ -655,7 +658,7 @@ bool RemoveExtraneousArguments::diagnose(const Solution &solution,
 
 bool RemoveExtraneousArguments::isMinMaxNameShadowing(
     ConstraintSystem &cs, ConstraintLocatorBuilder locator) {
-  auto *anchor = dyn_cast_or_null<CallExpr>(locator.getAnchor());
+  auto *anchor = getAsExpr<CallExpr>(locator.getAnchor());
   if (!anchor)
     return false;
 
@@ -1001,7 +1004,9 @@ IgnoreContextualType *IgnoreContextualType::create(ConstraintSystem &cs,
 bool IgnoreAssignmentDestinationType::diagnose(const Solution &solution,
                                                bool asNote) const {
   auto &cs = getConstraintSystem();
-  auto *AE = cast<AssignExpr>(getAnchor());
+  auto *AE = getAsExpr<AssignExpr>(getAnchor());
+
+  assert(AE);
 
   // Let's check whether this is a situation of chained assignment where
   // one of the steps in the chain is an assignment to self e.g.

lib/Sema/CSFix.h

@@ -17,6 +17,7 @@
 #ifndef SWIFT_SEMA_CSFIX_H
 #define SWIFT_SEMA_CSFIX_H
 
+#include "ConstraintLocator.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/Expr.h"
 #include "swift/AST/Identifier.h"
@@ -312,7 +313,7 @@ class ConstraintFix {
   /// Retrieve anchor expression associated with this fix.
   /// NOTE: such anchor comes directly from locator without
   /// any simplication attempts.
-  Expr *getAnchor() const;
+  TypedNode getAnchor() const;
   ConstraintLocator *getLocator() const { return Locator; }
 
 protected: