AST: The underlying conformance of a specialized conformance is always a root conformance

Author: slavapestov

include/swift/AST/ASTContext.h

@@ -105,6 +105,7 @@ namespace swift {
   class NormalProtocolConformance;
   class OpaqueTypeDecl;
   class InheritedProtocolConformance;
+  class RootProtocolConformance;
   class SelfProtocolConformance;
   class SpecializedProtocolConformance;
   enum class BuiltinConformanceKind;
@@ -1245,7 +1246,7 @@ class ASTContext final {
   /// specialized conformance from the generic conformance.
   ProtocolConformance *
   getSpecializedConformance(Type type,
-                            ProtocolConformance *generic,
+                            RootProtocolConformance *generic,
                             SubstitutionMap substitutions);
 
   /// Produce an inherited conformance, for subclasses of a type

include/swift/AST/ProtocolConformance.h

@@ -753,7 +753,7 @@ class SelfProtocolConformance : public RootProtocolConformance {
 class SpecializedProtocolConformance : public ProtocolConformance,
                                        public llvm::FoldingSetNode {
   /// The generic conformance from which this conformance was derived.
-  ProtocolConformance *GenericConformance;
+  RootProtocolConformance *GenericConformance;
 
   /// The substitutions applied to the generic conformance to produce this
   /// conformance.
@@ -772,15 +772,15 @@ class SpecializedProtocolConformance : public ProtocolConformance,
   friend class ASTContext;
 
   SpecializedProtocolConformance(Type conformingType,
-                                 ProtocolConformance *genericConformance,
+                                 RootProtocolConformance *genericConformance,
                                  SubstitutionMap substitutions);
 
   void computeConditionalRequirements() const;
 
 public:
   /// Get the generic conformance from which this conformance was derived,
   /// if there is one.
-  ProtocolConformance *getGenericConformance() const {
+  RootProtocolConformance *getGenericConformance() const {
     return GenericConformance;
   }
 
@@ -866,7 +866,7 @@ class SpecializedProtocolConformance : public ProtocolConformance,
   }
 
   static void Profile(llvm::FoldingSetNodeID &ID, Type type,
-                      ProtocolConformance *genericConformance,
+                      RootProtocolConformance *genericConformance,
                       SubstitutionMap subs) {
     ID.AddPointer(type.getPointer());
     ID.AddPointer(genericConformance);

include/swift/AST/RequirementEnvironment.h

@@ -22,6 +22,8 @@
 
 namespace swift {
 
+class RootProtocolConformance;
+
 /// Describes the environment of a requirement that will be used when
 /// matching witnesses against the requirement and to form the resulting
 /// \c Witness value.
@@ -99,7 +101,7 @@ class RequirementEnvironment {
                          GenericSignature reqSig,
                          ProtocolDecl *proto,
                          ClassDecl *covariantSelf,
-                         ProtocolConformance *conformance);
+                         RootProtocolConformance *conformance);
 
   /// Retrieve the generic signature of the requirement.
   GenericSignature getRequirementSignature() const {

lib/AST/ASTContext.cpp

@@ -2387,48 +2387,28 @@ ASTContext::getBuiltinConformance(
   return entry;
 }
 
-/// If one of the ancestor conformances already has a matching type, use
-/// that instead.
-static ProtocolConformance *collapseSpecializedConformance(
-                                             Type type,
-                                             ProtocolConformance *conformance,
-                                             SubstitutionMap substitutions) {
-  while (true) {
-    switch (conformance->getKind()) {
-    case ProtocolConformanceKind::Specialized:
-      conformance = cast<SpecializedProtocolConformance>(conformance)
-                      ->getGenericConformance();
-      break;
-
-    case ProtocolConformanceKind::Normal:
-    case ProtocolConformanceKind::Inherited:
-    case ProtocolConformanceKind::Self:
-    case ProtocolConformanceKind::Builtin:
-      // If the conformance matches, return it.
-      if (conformance->getType()->isEqual(type)) {
-        for (auto subConformance : substitutions.getConformances())
-          if (!subConformance.isAbstract())
-            return nullptr;
-
-        return conformance;
-      }
+static bool collapseSpecializedConformance(Type type,
+                                           RootProtocolConformance *conformance,
+                                           SubstitutionMap substitutions) {
+  if (!conformance->getType()->isEqual(type))
+    return false;
 
-      return nullptr;
-    }
+  for (auto subConformance : substitutions.getConformances()) {
+    if (!subConformance.isAbstract())
+      return false;
   }
+
+  return true;
 }
 
 ProtocolConformance *
 ASTContext::getSpecializedConformance(Type type,
-                                      ProtocolConformance *generic,
+                                      RootProtocolConformance *generic,
                                       SubstitutionMap substitutions) {
-  // If we are performing a substitution that would get us back to the
-  // a prior conformance (e.g., mapping into and then out of a conformance),
-  // return the existing conformance.
-  if (auto existing = collapseSpecializedConformance(type, generic,
-                                                     substitutions)) {
+  // If the specialization is a no-op, use the root conformance instead.
+  if (collapseSpecializedConformance(type, generic, substitutions)) {
     ++NumCollapsedSpecializedProtocolConformances;
-    return existing;
+    return generic;
   }
 
   llvm::FoldingSetNodeID id;

lib/AST/Module.cpp

@@ -1447,7 +1447,8 @@ LookupConformanceInModuleRequest::evaluate(
       auto subMap = type->getContextSubstitutionMap(mod, explicitConformanceDC);
 
       // Create the specialized conformance entry.
-      auto result = ctx.getSpecializedConformance(type, conformance, subMap);
+      auto result = ctx.getSpecializedConformance(type,
+        cast<RootProtocolConformance>(conformance), subMap);
       return ProtocolConformanceRef(result);
     }
   }

lib/AST/ProtocolConformance.cpp

@@ -957,14 +957,11 @@ void NormalProtocolConformance::overrideWitness(ValueDecl *requirement,
 
 SpecializedProtocolConformance::SpecializedProtocolConformance(
     Type conformingType,
-    ProtocolConformance *genericConformance,
+    RootProtocolConformance *genericConformance,
     SubstitutionMap substitutions)
   : ProtocolConformance(ProtocolConformanceKind::Specialized, conformingType),
     GenericConformance(genericConformance),
-    GenericSubstitutions(substitutions)
-{
-  assert(genericConformance->getKind() != ProtocolConformanceKind::Specialized);
-}
+    GenericSubstitutions(substitutions) {}
 
 void SpecializedProtocolConformance::computeConditionalRequirements() const {
   // already computed?
@@ -1181,9 +1178,11 @@ ProtocolConformance::subst(TypeSubstitutionFn subs,
 
     auto subMap = SubstitutionMap::get(getGenericSignature(),
                                        subs, conformances);
+
+    auto *mutableThis = const_cast<ProtocolConformance *>(this);
     return substType->getASTContext()
         .getSpecializedConformance(substType,
-                                   const_cast<ProtocolConformance *>(this),
+                                   cast<NormalProtocolConformance>(mutableThis),
                                    subMap);
   }
   case ProtocolConformanceKind::Builtin: {
@@ -1660,7 +1659,8 @@ ProtocolConformance *ProtocolConformance::getCanonicalConformance() {
     auto genericConformance = spec->getGenericConformance();
     return Ctx.getSpecializedConformance(
                                 getType()->getCanonicalType(),
-                                genericConformance->getCanonicalConformance(),
+                                cast<RootProtocolConformance>(
+                                    genericConformance->getCanonicalConformance()),
                                 spec->getSubstitutionMap().getCanonical());
   }
   }

lib/AST/RequirementEnvironment.cpp

@@ -36,7 +36,7 @@ RequirementEnvironment::RequirementEnvironment(
                                            GenericSignature reqSig,
                                            ProtocolDecl *proto,
                                            ClassDecl *covariantSelf,
-                                           ProtocolConformance *conformance)
+                                           RootProtocolConformance *conformance)
     : reqSig(reqSig) {
   ASTContext &ctx = conformanceDC->getASTContext();
 

lib/AST/Type.cpp

@@ -3128,7 +3128,8 @@ getForeignRepresentable(Type type, ForeignLanguage language,
     if (result.getKind() == ForeignRepresentableKind::Bridged
         && !result.getConformance()->getType()->isEqual(type)) {
       auto specialized = type->getASTContext()
-        .getSpecializedConformance(type, result.getConformance(),
+        .getSpecializedConformance(type,
+             cast<RootProtocolConformance>(result.getConformance()),
              boundGenericType->getContextSubstitutionMap(dc->getParentModule(),
                                                  boundGenericType->getDecl()));
       result = ForeignRepresentationInfo::forBridged(specialized);

lib/SIL/Parser/ParseSIL.cpp

@@ -7089,8 +7089,10 @@ ProtocolConformanceRef SILParser::parseProtocolConformanceHelper(
     if (!subMap)
       return ProtocolConformanceRef();
 
+    auto *rootConform = cast<RootProtocolConformance>(
+        genericConform.getConcrete());
     auto result = P.Context.getSpecializedConformance(
-        ConformingTy, genericConform.getConcrete(), subMap);
+        ConformingTy, rootConform, subMap);
     return ProtocolConformanceRef(result);
   }
 

lib/Sema/TypeCheckProtocol.cpp

@@ -874,7 +874,7 @@ swift::matchWitness(
 static const RequirementEnvironment &getOrCreateRequirementEnvironment(
     WitnessChecker::RequirementEnvironmentCache &reqEnvCache,
     DeclContext *dc, GenericSignature reqSig, ProtocolDecl *proto,
-    ClassDecl *covariantSelf, ProtocolConformance *conformance) {
+    ClassDecl *covariantSelf, RootProtocolConformance *conformance) {
   WitnessChecker::RequirementEnvironmentCacheKey cacheKey(reqSig.getPointer(),
                                                           covariantSelf);
   auto cacheIter = reqEnvCache.find(cacheKey);
@@ -992,7 +992,7 @@ static PossibleEffects getEffects(ValueDecl *value) {
 
 RequirementMatch
 swift::matchWitness(WitnessChecker::RequirementEnvironmentCache &reqEnvCache,
-                    ProtocolDecl *proto, ProtocolConformance *conformance,
+                    ProtocolDecl *proto, RootProtocolConformance *conformance,
                     DeclContext *dc, ValueDecl *req, ValueDecl *witness) {
   using namespace constraints;
 
@@ -6834,7 +6834,7 @@ swift::findWitnessedObjCRequirements(const ValueDecl *witness,
         if (accessorKind)
           witnessToMatch = cast<AccessorDecl>(witness)->getStorage();
 
-        if (matchWitness(reqEnvCache, proto, *conformance,
+        if (matchWitness(reqEnvCache, proto, normal,
                          witnessToMatch->getDeclContext(), req,
                          const_cast<ValueDecl *>(witnessToMatch))
               .isWellFormed()) {