[CS] Have isLastElement take a locator path elt class

This makes it consistent with `getLastElementAs`
and `castLastElementTo`.

Author: hamishknight

lib/Sema/CSDiagnostics.cpp

@@ -767,8 +767,8 @@ void GenericArgumentsMismatchFailure::emitNoteForMismatch(int position) {
   // to parameter conversions, let's use parameter type as a source of
   // generic parameter information.
   auto paramSourceTy =
-      locator->isLastElement(ConstraintLocator::ApplyArgToParam) ? getRequired()
-                                                                 : getActual();
+      locator->isLastElement<LocatorPathElt::ApplyArgToParam>() ? getRequired()
+                                                                : getActual();
 
   auto genericTypeDecl = paramSourceTy->getAnyGeneric();
   auto param = genericTypeDecl->getGenericParams()->getParams()[position];
@@ -1246,7 +1246,7 @@ bool MissingOptionalUnwrapFailure::diagnoseAsError() {
   // r-value adjustment because base could be an l-value type.
   // We want to fix both cases by only diagnose one of them,
   // otherwise this is just going to result in a duplcate diagnostic.
-  if (getLocator()->isLastElement(ConstraintLocator::UnresolvedMember))
+  if (getLocator()->isLastElement<LocatorPathElt::UnresolvedMember>())
     return false;
 
   if (auto assignExpr = dyn_cast<AssignExpr>(anchor))
@@ -2035,7 +2035,7 @@ bool ContextualFailure::diagnoseConversionToNil() const {
 
   Optional<ContextualTypePurpose> CTP;
   // Easy case were failure has been identified as contextual already.
-  if (locator->isLastElement(ConstraintLocator::ContextualType)) {
+  if (locator->isLastElement<LocatorPathElt::ContextualType>()) {
     CTP = getContextualTypePurpose();
   } else {
     // Here we need to figure out where where `nil` is located.
@@ -3596,7 +3596,7 @@ bool MissingArgumentsFailure::diagnoseAsError() {
   //
   // foo(bar) // `() -> Void` vs. `(Int) -> Void`
   // ```
-  if (locator->isLastElement(ConstraintLocator::ApplyArgToParam)) {
+  if (locator->isLastElement<LocatorPathElt::ApplyArgToParam>()) {
     auto info = *getFunctionArgApplyInfo(locator);
 
     auto *argExpr = info.getArgExpr();
@@ -3612,7 +3612,7 @@ bool MissingArgumentsFailure::diagnoseAsError() {
   // func foo() {}
   // let _: (Int) -> Void = foo
   // ```
-  if (locator->isLastElement(ConstraintLocator::ContextualType)) {
+  if (locator->isLastElement<LocatorPathElt::ContextualType>()) {
     auto &cs = getConstraintSystem();
     emitDiagnostic(anchor->getLoc(), diag::cannot_convert_initializer_value,
                    getType(anchor), resolveType(cs.getContextualType()));
@@ -3885,7 +3885,7 @@ bool MissingArgumentsFailure::diagnoseClosure(ClosureExpr *closure) {
 
 bool MissingArgumentsFailure::diagnoseInvalidTupleDestructuring() const {
   auto *locator = getLocator();
-  if (!locator->isLastElement(ConstraintLocator::ApplyArgument))
+  if (!locator->isLastElement<LocatorPathElt::ApplyArgument>())
     return false;
 
   if (SynthesizedArgs.size() < 2)

lib/Sema/CSSimplify.cpp

@@ -995,7 +995,7 @@ ConstraintSystem::TypeMatchResult constraints::matchCallArguments(
   auto isSynthesizedArgument = [](const AnyFunctionType::Param &arg) -> bool {
     if (auto *typeVar = arg.getPlainType()->getAs<TypeVariableType>()) {
       auto *locator = typeVar->getImpl().getLocator();
-      return locator->isLastElement(ConstraintLocator::SynthesizedArgument);
+      return locator->isLastElement<LocatorPathElt::SynthesizedArgument>();
     }
 
     return false;
@@ -3233,7 +3233,7 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
           // TODO(diagnostics): Only binding here for function types, because
           // doing so for KeyPath types leaves the constraint system in an
           // unexpected state for key path diagnostics should we fail.
-          if (locator->isLastElement(ConstraintLocator::KeyPathType) &&
+          if (locator->isLastElement<LocatorPathElt::KeyPathType>() &&
               type2->is<AnyFunctionType>())
             return matchTypesBindTypeVar(typeVar1, type2, kind, flags, locator,
                                          formUnsolvedResult);

lib/Sema/ConstraintLocator.cpp

@@ -175,22 +175,16 @@ bool ConstraintLocator::isForKeyPathComponent() const {
   });
 }
 
-bool ConstraintLocator::isLastElement(
-    ConstraintLocator::PathElementKind expectedKind) const {
-  auto path = getPath();
-  return !path.empty() && path.back().getKind() == expectedKind;
-}
-
 bool ConstraintLocator::isForGenericParameter() const {
-  return isLastElement(ConstraintLocator::GenericParameter);
+  return isLastElement<LocatorPathElt::GenericParameter>();
 }
 
 bool ConstraintLocator::isForSequenceElementType() const {
-  return isLastElement(ConstraintLocator::SequenceElementType);
+  return isLastElement<LocatorPathElt::SequenceElementType>();
 }
 
 bool ConstraintLocator::isForContextualType() const {
-  return isLastElement(ConstraintLocator::ContextualType);
+  return isLastElement<LocatorPathElt::ContextualType>();
 }
 
 GenericTypeParamType *ConstraintLocator::getGenericParameter() const {

lib/Sema/ConstraintLocator.h

@@ -441,9 +441,13 @@ class ConstraintLocator : public llvm::FoldingSetNode {
     return path[0].castTo<T>();
   }
 
-  /// Check whether the last element in the path of this locator
-  /// is of a given kind.
-  bool isLastElement(ConstraintLocator::PathElementKind kind) const;
+  /// Check whether the last element in the path of this locator (if any)
+  /// is a given \c LocatorPathElt subclass.
+  template <class T>
+  bool isLastElement() const {
+    auto path = getPath();
+    return !path.empty() && path.back().is<T>();
+  }
 
   /// Attempts to cast the last path element of the locator to a specific
   /// \c LocatorPathElt subclass, returning \c None if either unsuccessful or