Sema: Removed unnecessary ValueDecl from AllowProtocolTypeMember

Additionally removed the same unnecessary ValueDecl from
AllowProtocolTypeMemberFailure allowing it to extend MissingMemberFailure.

Author: sl

lib/Sema/CSDiag.cpp

@@ -6667,7 +6667,7 @@ bool FailureDiagnosis::diagnoseMemberFailures(
       locator = simplifyLocator(CS, locator, memberRange);
 
     BaseLoc = baseExpr->getLoc();
-    NameLoc =   DeclNameLoc(memberRange.Start);
+    NameLoc = DeclNameLoc(memberRange.Start);
 
     // Retypecheck the anchor type, which is the base of the member expression.
     baseExpr =

lib/Sema/CSDiagnostics.cpp

@@ -1963,7 +1963,7 @@ bool MissingMemberFailure::diagnoseAsError() {
 
 bool AllowProtocolTypeMemberFailure::diagnoseAsError() {
   auto *anchor = getRawAnchor();
-  
+
   Expr *baseExpr = getAnchor();
   DeclNameLoc nameLoc;
   if (auto *UDE = dyn_cast<UnresolvedDotExpr>(anchor)) {
@@ -1976,10 +1976,10 @@ bool AllowProtocolTypeMemberFailure::diagnoseAsError() {
   } else if (auto *call = dyn_cast<CallExpr>(anchor)) {
     baseExpr = call->getFn();
   }
-  
+
   emitDiagnostic(getAnchor()->getLoc(),
-                  diag::could_not_use_member_on_existential,
-                  getBaseType(), getName())
+                 diag::could_not_use_member_on_existential, getBaseType(),
+                 getName())
       .highlight(nameLoc.getSourceRange())
       .highlight(baseExpr->getSourceRange());
   return true;

lib/Sema/CSDiagnostics.h

@@ -771,7 +771,7 @@ class SubscriptMisuseFailure final : public FailureDiagnostic {
 ///   let _: Int = s.foo(1, 2) // expected type is `(Int, Int) -> Int`
 /// }
 /// ```
-class MissingMemberFailure final : public FailureDiagnostic {
+class MissingMemberFailure : public FailureDiagnostic {
   Type BaseType;
   DeclName Name;
 
@@ -787,6 +787,10 @@ class MissingMemberFailure final : public FailureDiagnostic {
   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
@@ -797,29 +801,19 @@ class MissingMemberFailure final : public FailureDiagnostic {
 /// protocol P {
 ///   var foo: Self { get }
 /// }
-/// 
+///
 /// func bar<X : P>(p: X) {
 ///   p.foo
 /// }
 /// ```
-class AllowProtocolTypeMemberFailure final : public FailureDiagnostic {
-  Type BaseType;
-  ValueDecl *Member;
-  DeclName Name;
-  
-  public:
-    AllowProtocolTypeMemberFailure(Expr *root, ConstraintSystem &cs,
-                                   Type baseType, ValueDecl *member, DeclName memberName,
-                                   ConstraintLocator *locator)
-            : FailureDiagnostic(root, cs, locator), BaseType(baseType),
-              Member(member), Name(memberName) {}
-  
-    bool diagnoseAsError() override;
-    
-  private:
-    Type getBaseType() const { return BaseType; }
-    ValueDecl *getMember() const { return Member; }
-    DeclName getName() const { return Name; }
+class AllowProtocolTypeMemberFailure final : public MissingMemberFailure {
+public:
+  AllowProtocolTypeMemberFailure(Expr *root, ConstraintSystem &cs,
+                                 Type baseType, DeclName memberName,
+                                 ConstraintLocator *locator)
+      : MissingMemberFailure(root, cs, baseType, memberName, locator) {}
+
+  bool diagnoseAsError() override;
 };
 
 /// Diagnose situations when we use an instance member on a type

lib/Sema/CSFix.cpp

@@ -285,14 +285,15 @@ DefineMemberBasedOnUse::create(ConstraintSystem &cs, Type baseType,
 
 AllowProtocolTypeMember *
 AllowProtocolTypeMember::create(ConstraintSystem &cs, Type baseType,
-                                ValueDecl *member, DeclName memberName, ConstraintLocator *locator) {
+                                ValueDecl *member, DeclName memberName,
+                                ConstraintLocator *locator) {
   return new (cs.getAllocator())
       AllowProtocolTypeMember(cs, baseType, memberName, member, locator);
 }
 
 bool AllowProtocolTypeMember::diagnose(Expr *root, bool asNote) const {
   auto failure = AllowProtocolTypeMemberFailure(root, getConstraintSystem(),
-                                                BaseType, Member, Name, getLocator());
+                                                BaseType, Name, getLocator());
   return failure.diagnose(asNote);
 }
 

lib/Sema/CSFix.h

@@ -124,7 +124,7 @@ enum class FixKind : uint8_t {
   /// derived (rather than an arbitrary value of metatype type) or the
   /// referenced constructor must be required.
   AllowInvalidInitRef,
-  
+
   /// 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.
@@ -600,30 +600,29 @@ class DefineMemberBasedOnUse final : public ConstraintFix {
 
 class AllowProtocolTypeMember final : public ConstraintFix {
   Type BaseType;
-  ValueDecl *Member;
   DeclName Name;
-  
+
   AllowProtocolTypeMember(ConstraintSystem &cs, Type baseType,
                           DeclName memberName, ValueDecl *member,
                           ConstraintLocator *locator)
-          : ConstraintFix(cs, FixKind::AllowProtocolTypeMember,
-                          locator), BaseType(baseType), Member(member), Name(memberName) {}
-  
-  public:
-    std::string getName() const override {
-      llvm::SmallVector<char, 16> scratch;
-      auto memberName = Name.getString(scratch);
-      return "allow access to invalid member '" + memberName.str() +
-            "' on value of protocol type";
-    }
-    
-    bool diagnose(Expr *root, bool asNote = false) const override;
-    
-    static AllowProtocolTypeMember *create(ConstraintSystem &cs,
-                                           Type baseType, ValueDecl *member, DeclName memberName,
-                                           ConstraintLocator *locator);
+      : ConstraintFix(cs, FixKind::AllowProtocolTypeMember, locator),
+        BaseType(baseType), Name(memberName) {}
+
+public:
+  std::string getName() const override {
+    llvm::SmallVector<char, 16> scratch;
+    auto memberName = Name.getString(scratch);
+    return "allow access to invalid member '" + memberName.str() +
+           "' on value of protocol type";
+  }
+
+  bool diagnose(Expr *root, bool asNote = false) const override;
+
+  static AllowProtocolTypeMember *create(ConstraintSystem &cs, Type baseType,
+                                         ValueDecl *member, DeclName memberName,
+                                         ConstraintLocator *locator);
 };
-	
+
 class AllowTypeOrInstanceMember final : public ConstraintFix {
   Type BaseType;
   ValueDecl *Member;

lib/Sema/CSSimplify.cpp

@@ -4528,12 +4528,12 @@ fixMemberRef(ConstraintSystem &cs, Type baseTy,
     case MemberLookupResult::UR_Inaccessible:
       assert(choice.isDecl());
       return AllowInaccessibleMember::create(cs, choice.getDecl(), locator);
-      
+
     case MemberLookupResult::UR_UnavailableInExistential: {
       return choice.isDecl()
-             ? AllowProtocolTypeMember::create(
-                    cs, baseTy, choice.getDecl(), memberName, locator)
-             : nullptr;
+                 ? AllowProtocolTypeMember::create(cs, baseTy, choice.getDecl(),
+                                                   memberName, locator)
+                 : nullptr;
     }
 
     case MemberLookupResult::UR_MutatingMemberOnRValue: