[ConstraintSystem] Switch "missing conformance" fix/diagnostic to use protocol type

Switch type allows "missing conformance" diagnostic to be
used not only for protocols by for protocol compositions as well.

Author: xedin

lib/Sema/CSDiagnostics.h

@@ -324,14 +324,15 @@ class RequirementFailure : public FailureDiagnostic {
 /// ```
 class MissingConformanceFailure final : public RequirementFailure {
   Type NonConformingType;
-  ProtocolDecl *Protocol;
+  Type ProtocolType;
 
 public:
   MissingConformanceFailure(Expr *expr, ConstraintSystem &cs,
                             ConstraintLocator *locator,
-                            std::pair<Type, ProtocolDecl *> conformance)
+                            std::pair<Type, Type> conformance)
       : RequirementFailure(cs, expr, RequirementKind::Conformance, locator),
-        NonConformingType(conformance.first), Protocol(conformance.second) {}
+        NonConformingType(conformance.first), ProtocolType(conformance.second) {
+  }
 
   bool diagnoseAsError() override;
 
@@ -341,7 +342,7 @@ class MissingConformanceFailure final : public RequirementFailure {
   Type getLHS() const override { return NonConformingType; }
 
   /// The protocol generic requirement expected associated type to conform to.
-  Type getRHS() const override { return Protocol->getDeclaredType(); }
+  Type getRHS() const override { return ProtocolType; }
 
 protected:
   DiagOnDecl getDiagnosticOnDecl() const override {

lib/Sema/CSFix.cpp

@@ -161,15 +161,15 @@ RelabelArguments::create(ConstraintSystem &cs,
 
 bool MissingConformance::diagnose(Expr *root, bool asNote) const {
   MissingConformanceFailure failure(root, getConstraintSystem(), getLocator(),
-                                    {NonConformingType, Protocol});
+                                    {NonConformingType, ProtocolType});
   return failure.diagnose(asNote);
 }
 
 MissingConformance *MissingConformance::create(ConstraintSystem &cs, Type type,
-                                               ProtocolDecl *protocol,
+                                               Type protocolType,
                                                ConstraintLocator *locator) {
   return new (cs.getAllocator())
-      MissingConformance(cs, type, protocol, locator);
+      MissingConformance(cs, type, protocolType, locator);
 }
 
 bool SkipSameTypeRequirement::diagnose(Expr *root, bool asNote) const {

lib/Sema/CSFix.h

@@ -364,12 +364,13 @@ class RelabelArguments final
 /// Add a new conformance to the type to satisfy a requirement.
 class MissingConformance final : public ConstraintFix {
   Type NonConformingType;
-  ProtocolDecl *Protocol;
+  // This could either be a protocol or protocol composition.
+  Type ProtocolType;
 
-  MissingConformance(ConstraintSystem &cs, Type type, ProtocolDecl *protocol,
+  MissingConformance(ConstraintSystem &cs, Type type, Type protocolType,
                      ConstraintLocator *locator)
       : ConstraintFix(cs, FixKind::AddConformance, locator),
-        NonConformingType(type), Protocol(protocol) {}
+        NonConformingType(type), ProtocolType(protocolType) {}
 
 public:
   std::string getName() const override {
@@ -379,12 +380,12 @@ class MissingConformance final : public ConstraintFix {
   bool diagnose(Expr *root, bool asNote = false) const override;
 
   static MissingConformance *create(ConstraintSystem &cs, Type type,
-                                    ProtocolDecl *protocol,
+                                    Type protocolType,
                                     ConstraintLocator *locator);
 
   Type getNonConformingType() { return NonConformingType; }
 
-  ProtocolDecl *getProtocol() { return Protocol; }
+  Type getProtocolType() { return ProtocolType; }
 };
 
 /// Skip same-type generic requirement constraint,

lib/Sema/CSSimplify.cpp

@@ -3352,8 +3352,9 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyConformsToConstraint(
           return SolutionKind::Error;
       }
 
-      auto *fix = MissingConformance::create(*this, type, protocol,
-                                             getConstraintLocator(locator));
+      auto *fix =
+          MissingConformance::create(*this, type, protocol->getDeclaredType(),
+                                     getConstraintLocator(locator));
       if (!recordFix(fix))
         return SolutionKind::Solved;
     }

lib/Sema/TypeCheckProtocol.cpp

@@ -710,7 +710,7 @@ static Optional<RequirementMatch> findMissingGenericRequirementForSolutionFix(
     auto missingConform = (MissingConformance *)fix;
     requirementKind = RequirementKind::Conformance;
     type = missingConform->getNonConformingType();
-    missingType = missingConform->getProtocol()->getDeclaredType();
+    missingType = missingConform->getProtocolType();
     break;
   }
   case FixKind::SkipSameTypeRequirement: {