[Sema] Renaming missing component key path fix and failure

Author: LucianoPAlmeida

lib/Sema/CSBindings.cpp

@@ -1227,7 +1227,7 @@ bool TypeVariableBinding::attempt(ConstraintSystem &cs) const {
         // If we recorded a invalid key path fix, let's skip this root fix
         // because it wouldn't produce a useful diagnostic.
         auto *kpLocator = cs.getConstraintLocator(srcLocator->getAnchor());
-        if (cs.hasFixFor(kpLocator, FixKind::AllowKeyPathMissingComponent))
+        if (cs.hasFixFor(kpLocator, FixKind::AllowKeyPathWithoutComponents))
           return true;
 
         fix = SpecifyKeyPathRootType::create(cs, dstLocator);

lib/Sema/CSDiagnostics.cpp

@@ -6761,7 +6761,7 @@ void TrailingClosureRequiresExplicitLabel::fixIt(
                          isExpr<SubscriptExpr>(anchor) ? "]" : ")");
 }
 
-bool AllowKeyPathMissingComponentFailure::diagnoseAsError() {
+bool InvalidEmptyKeyPathFailure::diagnoseAsError() {
   auto *KPE = getAsExpr<KeyPathExpr>(getAnchor());
   assert(KPE && KPE->hasSingleInvalidComponent() &&
          "Expected a malformed key path expression");

lib/Sema/CSDiagnostics.h

@@ -2253,10 +2253,10 @@ class TrailingClosureRequiresExplicitLabel final : public FailureDiagnostic {
 /// \code
 /// let _ : KeyPath<A, B> = \A
 /// \endcode
-class AllowKeyPathMissingComponentFailure final : public FailureDiagnostic {
+class InvalidEmptyKeyPathFailure final : public FailureDiagnostic {
 public:
-  AllowKeyPathMissingComponentFailure(const Solution &solution,
-                                      ConstraintLocator *locator)
+  InvalidEmptyKeyPathFailure(const Solution &solution,
+                             ConstraintLocator *locator)
       : FailureDiagnostic(solution, locator) {}
 
   bool diagnoseAsError() override;

lib/Sema/CSFix.cpp

@@ -1540,14 +1540,14 @@ SpecifyLabelToAssociateTrailingClosure::create(ConstraintSystem &cs,
       SpecifyLabelToAssociateTrailingClosure(cs, locator);
 }
 
-bool AllowKeyPathMissingComponent::diagnose(const Solution &solution,
-                                            bool asNote) const {
-  AllowKeyPathMissingComponentFailure failure(solution, getLocator());
+bool AllowKeyPathWithoutComponents::diagnose(const Solution &solution,
+                                             bool asNote) const {
+  InvalidEmptyKeyPathFailure failure(solution, getLocator());
   return failure.diagnose(asNote);
 }
 
-AllowKeyPathMissingComponent *
-AllowKeyPathMissingComponent::create(ConstraintSystem &cs,
-                                     ConstraintLocator *locator) {
-  return new (cs.getAllocator()) AllowKeyPathMissingComponent(cs, locator);
+AllowKeyPathWithoutComponents *
+AllowKeyPathWithoutComponents::create(ConstraintSystem &cs,
+                                      ConstraintLocator *locator) {
+  return new (cs.getAllocator()) AllowKeyPathWithoutComponents(cs, locator);
 }

lib/Sema/CSFix.h

@@ -275,7 +275,7 @@ enum class FixKind : uint8_t {
   SpecifyLabelToAssociateTrailingClosure,
 
   /// Allow key path expressions missing component.
-  AllowKeyPathMissingComponent,
+  AllowKeyPathWithoutComponents,
 };
 
 class ConstraintFix {
@@ -1966,17 +1966,18 @@ class SpecifyLabelToAssociateTrailingClosure final : public ConstraintFix {
 /// \code
 /// let _ : KeyPath<A, B> = \A
 /// \endcode
-class AllowKeyPathMissingComponent final : public ConstraintFix {
-  AllowKeyPathMissingComponent(ConstraintSystem &cs, ConstraintLocator *locator)
-      : ConstraintFix(cs, FixKind::AllowKeyPathMissingComponent, locator) {}
+class AllowKeyPathWithoutComponents final : public ConstraintFix {
+  AllowKeyPathWithoutComponents(ConstraintSystem &cs,
+                                ConstraintLocator *locator)
+      : ConstraintFix(cs, FixKind::AllowKeyPathWithoutComponents, locator) {}
 
 public:
   std::string getName() const override { return "key path missing component"; }
 
   bool diagnose(const Solution &solution, bool asNote = false) const override;
 
-  static AllowKeyPathMissingComponent *create(ConstraintSystem &cs,
-                                              ConstraintLocator *locator);
+  static AllowKeyPathWithoutComponents *create(ConstraintSystem &cs,
+                                               ConstraintLocator *locator);
 };
 
 } // end namespace constraints

lib/Sema/CSSimplify.cpp

@@ -8130,7 +8130,7 @@ ConstraintSystem::simplifyKeyPathConstraint(
     // If we have a malformed KeyPathExpr e.g. let _: KeyPath<A, C> = \A
     // let's record a AllowKeyPathMissingComponent fix.
     if (keyPath->hasSingleInvalidComponent()) {
-      auto *fix = AllowKeyPathMissingComponent::create(
+      auto *fix = AllowKeyPathWithoutComponents::create(
           *this, getConstraintLocator(locator));
       return recordFix(fix) ? SolutionKind::Error : SolutionKind::Solved;
     }
@@ -9997,7 +9997,7 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyFixConstraint(
   case FixKind::AllowCoercionToForceCast:
   case FixKind::SpecifyKeyPathRootType:
   case FixKind::SpecifyLabelToAssociateTrailingClosure:
-  case FixKind::AllowKeyPathMissingComponent: {
+  case FixKind::AllowKeyPathWithoutComponents: {
     return recordFix(fix) ? SolutionKind::Error : SolutionKind::Solved;
   }