Sema: Port member access on existentials diagnostic to new diagnostic framework

Author: sl

lib/Sema/CSDiag.cpp

@@ -754,12 +754,8 @@ void FailureDiagnosis::diagnoseUnviableLookupResults(
     case MemberLookupResult::UR_WritableKeyPathOnReadOnlyMember:
     case MemberLookupResult::UR_ReferenceWritableKeyPathOnMutatingMember:
     case MemberLookupResult::UR_KeyPathWithAnyObjectRootType:
-      break;
     case MemberLookupResult::UR_UnavailableInExistential:
-      diagnose(loc, diag::could_not_use_member_on_existential,
-               instanceTy, memberName)
-        .highlight(baseRange).highlight(nameLoc.getSourceRange());
-      return;
+      break;
     case MemberLookupResult::UR_InstanceMemberOnType:
     case MemberLookupResult::UR_TypeMemberOnInstance: {
       auto locatorKind = isa<SubscriptExpr>(E)
@@ -6671,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

@@ -1961,6 +1961,30 @@ bool MissingMemberFailure::diagnoseAsError() {
   return true;
 }
 
+bool AllowProtocolTypeMemberFailure::diagnoseAsError() {
+  auto *anchor = getRawAnchor();
+  
+  Expr *baseExpr = getAnchor();
+  DeclNameLoc nameLoc;
+  if (auto *UDE = dyn_cast<UnresolvedDotExpr>(anchor)) {
+    baseExpr = UDE->getBase();
+    nameLoc = UDE->getNameLoc();
+  } else if (auto *UME = dyn_cast<UnresolvedMemberExpr>(anchor)) {
+    nameLoc = UME->getNameLoc();
+  } else if (auto *SE = dyn_cast<SubscriptExpr>(anchor)) {
+    baseExpr = SE->getBase();
+  } else if (auto *call = dyn_cast<CallExpr>(anchor)) {
+    baseExpr = call->getFn();
+  }
+  
+  emitDiagnostic(getAnchor()->getLoc(),
+                  diag::could_not_use_member_on_existential,
+                  getBaseType(), getName())
+      .highlight(nameLoc.getSourceRange())
+      .highlight(baseExpr->getSourceRange());
+  return true;
+}
+
 bool AllowTypeOrInstanceMemberFailure::diagnoseAsError() {
   auto loc = getAnchor()->getLoc();
   auto &cs = getConstraintSystem();

lib/Sema/CSDiagnostics.h

@@ -789,6 +789,39 @@ class MissingMemberFailure final : public FailureDiagnostic {
                                           DeclName memberName);
 };
 
+/// Diagnose cases where a member only accessible on generic constraints
+/// requiring conformance to a protocol is used on a value of the
+/// existential protocol type e.g.
+///
+/// ```swift
+/// 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; }
+};
+
 /// Diagnose situations when we use an instance member on a type
 /// or a type member on an instance
 ///

lib/Sema/CSFix.cpp

@@ -283,6 +283,19 @@ DefineMemberBasedOnUse::create(ConstraintSystem &cs, Type baseType,
       DefineMemberBasedOnUse(cs, baseType, member, locator);
 }
 
+AllowProtocolTypeMember *
+AllowProtocolTypeMember::create(ConstraintSystem &cs, Type baseType,
+                                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());
+  return failure.diagnose(asNote);
+}
+
 bool AllowTypeOrInstanceMember::diagnose(Expr *root, bool asNote) const {
   auto failure = AllowTypeOrInstanceMemberFailure(
       root, getConstraintSystem(), BaseType, Member, UsedName, getLocator());

lib/Sema/CSFix.h

@@ -124,6 +124,11 @@ 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.
+  AllowProtocolTypeMember,
 
   /// If there are fewer arguments than parameters, let's fix that up
   /// by adding new arguments to the list represented as type variables.
@@ -592,6 +597,32 @@ class DefineMemberBasedOnUse final : public ConstraintFix {
                                         DeclName member,
                                         ConstraintLocator *locator);
 };
+
+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);
+};
 
 class AllowTypeOrInstanceMember final : public ConstraintFix {
   Type BaseType;

lib/Sema/CSSimplify.cpp

@@ -4528,11 +4528,17 @@ 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;
+    }
 
     case MemberLookupResult::UR_MutatingMemberOnRValue:
     case MemberLookupResult::UR_MutatingGetterOnRValue:
     case MemberLookupResult::UR_LabelMismatch:
-    case MemberLookupResult::UR_UnavailableInExistential:
     // TODO(diagnostics): Add a new fix that is suggests to
     // add `subscript(dynamicMember: {Writable}KeyPath<T, U>)`
     // overload here, that would help if such subscript has
@@ -6637,6 +6643,7 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyFixConstraint(
   case FixKind::RelabelArguments:
   case FixKind::RemoveUnwrap:
   case FixKind::DefineMemberBasedOnUse:
+  case FixKind::AllowProtocolTypeMember:
   case FixKind::AllowTypeOrInstanceMember:
   case FixKind::AllowInvalidPartialApplication:
   case FixKind::AllowInvalidInitRef: