Sema: Change DerivedConformance::derivesProtocolConformance() to take the conformance

Author: slavapestov

lib/Sema/AssociatedTypeInference.cpp

@@ -2653,12 +2653,11 @@ AssociatedTypeInference::computeDerivedTypeWitness(
     return std::make_pair(Type(), nullptr);
 
   // Can we derive conformances for this protocol and adoptee?
-  NominalTypeDecl *derivingTypeDecl = dc->getSelfNominalTypeDecl();
-  if (!DerivedConformance::derivesProtocolConformance(dc, derivingTypeDecl,
-                                                      proto))
+  if (!DerivedConformance::derivesProtocolConformance(conformance))
     return std::make_pair(Type(), nullptr);
 
   // Try to derive the type witness.
+  NominalTypeDecl *derivingTypeDecl = dc->getSelfNominalTypeDecl();
   auto result = deriveTypeWitness(conformance, derivingTypeDecl, assocType);
   if (!result.first)
     return std::make_pair(Type(), nullptr);

lib/Sema/DerivedConformance/DerivedConformance.cpp

@@ -72,9 +72,10 @@ Type DerivedConformance::getProtocolType() const {
   return Protocol->getDeclaredInterfaceType();
 }
 
-bool DerivedConformance::derivesProtocolConformance(DeclContext *DC,
-                                                    NominalTypeDecl *Nominal,
-                                                    ProtocolDecl *Protocol) {
+bool DerivedConformance::derivesProtocolConformance(
+      NormalProtocolConformance *Conformance) {
+  auto *Protocol = Conformance->getProtocol();
+
   const auto derivableKind = Protocol->getKnownDerivableProtocolKind();
   if (!derivableKind)
     return false;
@@ -85,6 +86,9 @@ bool DerivedConformance::derivesProtocolConformance(DeclContext *DC,
     return false;
   }
 
+  auto *DC = Conformance->getDeclContext();
+  auto *Nominal = DC->getSelfNominalTypeDecl();
+
   if (*derivableKind == KnownDerivableProtocolKind::Hashable) {
     // We can always complete a partial Hashable implementation, and we can
     // synthesize a full Hashable implementation for structs and enums with
@@ -299,10 +303,10 @@ ValueDecl *DerivedConformance::getDerivableRequirement(NominalTypeDecl *nominal,
 
     auto conformance = lookupConformance(
         nominal->getDeclaredInterfaceType(), proto);
-    if (conformance) {
-      auto DC = conformance.getConcrete()->getDeclContext();
+    if (conformance.isConcrete()) {
       // Check whether this nominal type derives conformances to the protocol.
-      if (!DerivedConformance::derivesProtocolConformance(DC, nominal, proto))
+      if (!DerivedConformance::derivesProtocolConformance(
+            conformance.getConcrete()->getRootNormalConformance()))
         return nullptr;
     }
 

lib/Sema/DerivedConformance/DerivedConformance.h

@@ -95,16 +95,11 @@ class DerivedConformance {
   /// declarations for requirements of the protocol that are not satisfied by
   /// the type's explicit members.
   ///
-  /// \param nominal The nominal type for which we are determining whether to
-  /// derive a witness.
-  ///
-  /// \param protocol The protocol whose requirements are being derived.
+  /// \param conformance The conformance.
   ///
   /// \return True if the type can implicitly derive a conformance for the
   /// given protocol.
-  static bool derivesProtocolConformance(DeclContext *DC,
-                                         NominalTypeDecl *nominal,
-                                         ProtocolDecl *protocol);
+  static bool derivesProtocolConformance(NormalProtocolConformance *conformance);
 
   /// Diagnose problems, if any, preventing automatic derivation of protocol
   /// requirements

lib/Sema/TypeCheckProtocol.cpp

@@ -4730,9 +4730,8 @@ ResolveWitnessResult ConformanceChecker::resolveWitnessViaDerivation(
 
   // Find the declaration that derives the protocol conformance.
   NominalTypeDecl *derivingTypeDecl = nullptr;
-  auto *nominal = DC->getSelfNominalTypeDecl();
-  if (DerivedConformance::derivesProtocolConformance(DC, nominal, Proto))
-    derivingTypeDecl = nominal;
+  if (DerivedConformance::derivesProtocolConformance(Conformance))
+    derivingTypeDecl = DC->getSelfNominalTypeDecl();
 
   if (!derivingTypeDecl) {
     return ResolveWitnessResult::Missing;
@@ -6890,16 +6889,22 @@ void TypeChecker::checkConformancesInContext(IterableDeclContext *idc) {
     // is implied for enums which already declare a raw type.
     if (auto enumDecl = dyn_cast<EnumDecl>(existingDecl)) {
       if (diag.Protocol->isSpecificProtocol(
-              KnownProtocolKind::RawRepresentable) &&
-          DerivedConformance::derivesProtocolConformance(dc, enumDecl,
-                                                         diag.Protocol) &&
-          enumDecl->hasRawType() &&
-          enumDecl->getInherited().getStartLoc().isValid()) {
-        auto inheritedLoc = enumDecl->getInherited().getStartLoc();
-        Context.Diags.diagnose(
-            inheritedLoc, diag::enum_declares_rawrep_with_raw_type,
-            dc->getDeclaredInterfaceType(), enumDecl->getRawType());
-        continue;
+              KnownProtocolKind::RawRepresentable)) {
+        auto conformance = lookupConformance(
+            enumDecl->getDeclaredInterfaceType(), diag.Protocol);
+        if (!conformance.isConcrete())
+          continue;
+
+        if (DerivedConformance::derivesProtocolConformance(
+              conformance.getConcrete()->getRootNormalConformance()) &&
+            enumDecl->hasRawType() &&
+            enumDecl->getInherited().getStartLoc().isValid()) {
+          auto inheritedLoc = enumDecl->getInherited().getStartLoc();
+          Context.Diags.diagnose(
+              inheritedLoc, diag::enum_declares_rawrep_with_raw_type,
+              dc->getDeclaredInterfaceType(), enumDecl->getRawType());
+          continue;
+        }
       }
     }