Sema: Renamed invalid member ref on existential fix, and refactored inheritance

sl · sl · commit 147280ac3b70 · 2019-05-30T18:48:58.000-04:00
diff --git a/lib/Sema/CSDiag.cpp b/lib/Sema/CSDiag.cpp
@@ -757,8 +757,8 @@ void FailureDiagnosis::diagnoseUnviableLookupResults(
       break;
 
     case MemberLookupResult::UR_UnavailableInExistential: {
-      AllowProtocolTypeMemberFailure failure(baseExpr, CS, instanceTy, memberName,
-                                             CS.getConstraintLocator(E));
+      InvalidMemberRefOnExistential failure(baseExpr, CS, instanceTy, memberName,
+                                            CS.getConstraintLocator(E));
       failure.diagnoseAsError();
       return;
     }
diff --git a/lib/Sema/CSDiagnostics.cpp b/lib/Sema/CSDiagnostics.cpp
@@ -1844,7 +1844,7 @@ bool MissingMemberFailure::diagnoseAsError() {
   if (!anchor || !baseExpr)
     return false;
 
-  if (auto *typeVar = BaseType->getAs<TypeVariableType>()) {
+  if (auto *typeVar = getBaseType()->getAs<TypeVariableType>()) {
     auto &CS = getConstraintSystem();
     auto *memberLoc = typeVar->getImpl().getLocator();
     // Don't try to diagnose anything besides first missing
@@ -1856,7 +1856,7 @@ bool MissingMemberFailure::diagnoseAsError() {
       return false;
   }
 
-  auto baseType = resolveType(BaseType)->getWithoutSpecifierType();
+  auto baseType = resolveType(getBaseType())->getWithoutSpecifierType();
 
   DeclNameLoc nameLoc(anchor->getStartLoc());
   if (auto *UDE = dyn_cast<UnresolvedDotExpr>(anchor)) {
@@ -1876,22 +1876,22 @@ bool MissingMemberFailure::diagnoseAsError() {
     if (baseType->is<TupleType>())
       diagnostic = diag::could_not_find_tuple_member;
 
-    emitDiagnostic(anchor->getLoc(), diagnostic, baseType, Name)
+    emitDiagnostic(anchor->getLoc(), diagnostic, baseType, getName())
         .highlight(baseExpr->getSourceRange())
         .highlight(nameLoc.getSourceRange());
   };
 
-  TypoCorrectionResults corrections(TC, Name, nameLoc);
+  TypoCorrectionResults corrections(TC, getName(), nameLoc);
   auto tryTypoCorrection = [&] {
     TC.performTypoCorrection(getDC(), DeclRefKind::Ordinary, baseType,
                              defaultMemberLookupOptions, corrections);
   };
 
-  if (Name.getBaseName().getKind() == DeclBaseName::Kind::Subscript) {
+  if (getName().getBaseName().getKind() == DeclBaseName::Kind::Subscript) {
     emitDiagnostic(anchor->getLoc(), diag::could_not_find_value_subscript,
                    baseType)
         .highlight(baseExpr->getSourceRange());
-  } else if (Name.getBaseName() == "deinit") {
+  } else if (getName().getBaseName() == "deinit") {
     // Specialised diagnostic if trying to access deinitialisers
     emitDiagnostic(anchor->getLoc(), diag::destructor_not_accessible)
         .highlight(baseExpr->getSourceRange());
@@ -1900,9 +1900,9 @@ bool MissingMemberFailure::diagnoseAsError() {
     tryTypoCorrection();
 
     if (DeclName rightName =
-            findCorrectEnumCaseName(instanceTy, corrections, Name)) {
+            findCorrectEnumCaseName(instanceTy, corrections, getName())) {
       emitDiagnostic(anchor->getLoc(), diag::could_not_find_enum_case,
-                     instanceTy, Name, rightName)
+                     instanceTy, getName(), rightName)
           .fixItReplace(nameLoc.getBaseNameLoc(),
                         rightName.getBaseIdentifier().str());
       return true;
@@ -1911,7 +1911,7 @@ bool MissingMemberFailure::diagnoseAsError() {
     if (auto correction = corrections.claimUniqueCorrection()) {
       auto diagnostic = emitDiagnostic(
           anchor->getLoc(), diag::could_not_find_type_member_corrected,
-          instanceTy, Name, correction->CorrectedName);
+          instanceTy, getName(), correction->CorrectedName);
       diagnostic.highlight(baseExpr->getSourceRange())
           .highlight(nameLoc.getSourceRange());
       correction->addFixits(diagnostic);
@@ -1920,14 +1920,14 @@ bool MissingMemberFailure::diagnoseAsError() {
     }
   } else if (auto moduleTy = baseType->getAs<ModuleType>()) {
     emitDiagnostic(baseExpr->getLoc(), diag::no_member_of_module,
-                   moduleTy->getModule()->getName(), Name)
+                   moduleTy->getModule()->getName(), getName())
         .highlight(baseExpr->getSourceRange())
         .highlight(nameLoc.getSourceRange());
     return true;
   } else {
     // Check for a few common cases that can cause missing members.
     auto *ED = baseType->getEnumOrBoundGenericEnum();
-    if (ED && Name.isSimpleName("rawValue")) {
+    if (ED && getName().isSimpleName("rawValue")) {
       auto loc = ED->getNameLoc();
       if (loc.isValid()) {
         emitBasicError(baseType);
@@ -1947,7 +1947,7 @@ bool MissingMemberFailure::diagnoseAsError() {
     if (auto correction = corrections.claimUniqueCorrection()) {
       auto diagnostic = emitDiagnostic(
           anchor->getLoc(), diag::could_not_find_value_member_corrected,
-          baseType, Name, correction->CorrectedName);
+          baseType, getName(), correction->CorrectedName);
       diagnostic.highlight(baseExpr->getSourceRange())
           .highlight(nameLoc.getSourceRange());
       correction->addFixits(diagnostic);
@@ -1961,7 +1961,7 @@ bool MissingMemberFailure::diagnoseAsError() {
   return true;
 }
 
-bool AllowProtocolTypeMemberFailure::diagnoseAsError() {
+bool InvalidMemberRefOnExistential::diagnoseAsError() {
   auto *anchor = getRawAnchor();
 
   Expr *baseExpr = getAnchor();
diff --git a/lib/Sema/CSDiagnostics.h b/lib/Sema/CSDiagnostics.h
@@ -762,6 +762,21 @@ class SubscriptMisuseFailure final : public FailureDiagnostic {
   bool diagnoseAsNote() override;
 };
 
+class InvalidMemberRefFailure : public FailureDiagnostic {
+  Type BaseType;
+  DeclName Name;
+  
+public:
+  InvalidMemberRefFailure(Expr *root, ConstraintSystem &cs, Type baseType,
+                          DeclName memberName, ConstraintLocator *locator)
+          : FailureDiagnostic(root, cs, locator),
+            BaseType(baseType), Name(memberName) {}
+            
+protected:
+  Type getBaseType() const { return BaseType; }
+  DeclName getName() const { return Name; }
+};
+
 /// Diagnose situations when member referenced by name is missing
 /// from the associated base type, e.g.
 ///
@@ -771,26 +786,18 @@ class SubscriptMisuseFailure final : public FailureDiagnostic {
 ///   let _: Int = s.foo(1, 2) // expected type is `(Int, Int) -> Int`
 /// }
 /// ```
-class MissingMemberFailure : public FailureDiagnostic {
-  Type BaseType;
-  DeclName Name;
-
+class MissingMemberFailure final : public InvalidMemberRefFailure {
 public:
   MissingMemberFailure(Expr *root, ConstraintSystem &cs, Type baseType,
                        DeclName memberName, ConstraintLocator *locator)
-      : FailureDiagnostic(root, cs, locator), BaseType(baseType),
-        Name(memberName) {}
+      : InvalidMemberRefFailure(root, cs, baseType, memberName, locator) {}
 
   bool diagnoseAsError() override;
 
 private:
   static DeclName findCorrectEnumCaseName(Type Ty,
                                           TypoCorrectionResults &corrections,
                                           DeclName memberName);
-
-protected:
-  Type getBaseType() const { return BaseType; }
-  DeclName getName() const { return Name; }
 };
 
 /// Diagnose cases where a member only accessible on generic constraints
@@ -806,12 +813,12 @@ class MissingMemberFailure : public FailureDiagnostic {
 ///   p.foo
 /// }
 /// ```
-class AllowProtocolTypeMemberFailure final : public MissingMemberFailure {
+class InvalidMemberRefOnExistential final : public InvalidMemberRefFailure {
 public:
-  AllowProtocolTypeMemberFailure(Expr *root, ConstraintSystem &cs,
-                                 Type baseType, DeclName memberName,
-                                 ConstraintLocator *locator)
-      : MissingMemberFailure(root, cs, baseType, memberName, locator) {}
+  InvalidMemberRefOnExistential(Expr *root, ConstraintSystem &cs,
+                                Type baseType, DeclName memberName,
+                                ConstraintLocator *locator)
+      : InvalidMemberRefFailure(root, cs, baseType, memberName, locator) {}
 
   bool diagnoseAsError() override;
 };
diff --git a/lib/Sema/CSFix.cpp b/lib/Sema/CSFix.cpp
@@ -283,17 +283,17 @@ DefineMemberBasedOnUse::create(ConstraintSystem &cs, Type baseType,
       DefineMemberBasedOnUse(cs, baseType, member, locator);
 }
 
-AllowProtocolTypeMember *
-AllowProtocolTypeMember::create(ConstraintSystem &cs, Type baseType,
+AllowMemberRefOnExistential *
+AllowMemberRefOnExistential::create(ConstraintSystem &cs, Type baseType,
                                 ValueDecl *member, DeclName memberName,
                                 ConstraintLocator *locator) {
   return new (cs.getAllocator())
-      AllowProtocolTypeMember(cs, baseType, memberName, member, locator);
+      AllowMemberRefOnExistential(cs, baseType, memberName, member, locator);
 }
 
-bool AllowProtocolTypeMember::diagnose(Expr *root, bool asNote) const {
-  auto failure = AllowProtocolTypeMemberFailure(root, getConstraintSystem(),
-                                                BaseType, Name, getLocator());
+bool AllowMemberRefOnExistential::diagnose(Expr *root, bool asNote) const {
+  auto failure = InvalidMemberRefOnExistential(root, getConstraintSystem(),
+                                               BaseType, Name, getLocator());
   return failure.diagnose(asNote);
 }
 
diff --git a/lib/Sema/CSFix.h b/lib/Sema/CSFix.h
@@ -128,7 +128,7 @@ enum class FixKind : uint8_t {
   /// Allow an invalid member access on a value of protocol type as if
   /// that protocol type were a generic constraint requiring conformance
   /// to that protocol.
-  AllowProtocolTypeMember,
+  AllowMemberRefOnExistential,
 
   /// If there are fewer arguments than parameters, let's fix that up
   /// by adding new arguments to the list represented as type variables.
@@ -598,14 +598,14 @@ class DefineMemberBasedOnUse final : public ConstraintFix {
                                         ConstraintLocator *locator);
 };
 
-class AllowProtocolTypeMember final : public ConstraintFix {
+class AllowMemberRefOnExistential final : public ConstraintFix {
   Type BaseType;
   DeclName Name;
 
-  AllowProtocolTypeMember(ConstraintSystem &cs, Type baseType,
+  AllowMemberRefOnExistential(ConstraintSystem &cs, Type baseType,
                           DeclName memberName, ValueDecl *member,
                           ConstraintLocator *locator)
-      : ConstraintFix(cs, FixKind::AllowProtocolTypeMember, locator),
+      : ConstraintFix(cs, FixKind::AllowMemberRefOnExistential, locator),
         BaseType(baseType), Name(memberName) {}
 
 public:
@@ -618,7 +618,7 @@ class AllowProtocolTypeMember final : public ConstraintFix {
 
   bool diagnose(Expr *root, bool asNote = false) const override;
 
-  static AllowProtocolTypeMember *create(ConstraintSystem &cs, Type baseType,
+  static AllowMemberRefOnExistential *create(ConstraintSystem &cs, Type baseType,
                                          ValueDecl *member, DeclName memberName,
                                          ConstraintLocator *locator);
 };
diff --git a/lib/Sema/CSSimplify.cpp b/lib/Sema/CSSimplify.cpp
@@ -4531,7 +4531,7 @@ fixMemberRef(ConstraintSystem &cs, Type baseTy,
 
     case MemberLookupResult::UR_UnavailableInExistential: {
       return choice.isDecl()
-                 ? AllowProtocolTypeMember::create(cs, baseTy, choice.getDecl(),
+                 ? AllowMemberRefOnExistential::create(cs, baseTy, choice.getDecl(),
                                                    memberName, locator)
                  : nullptr;
     }
@@ -6643,7 +6643,7 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyFixConstraint(
   case FixKind::RelabelArguments:
   case FixKind::RemoveUnwrap:
   case FixKind::DefineMemberBasedOnUse:
-  case FixKind::AllowProtocolTypeMember:
+  case FixKind::AllowMemberRefOnExistential:
   case FixKind::AllowTypeOrInstanceMember:
   case FixKind::AllowInvalidPartialApplication:
   case FixKind::AllowInvalidInitRef:
