Merge pull request #60370 from slavapestov/cleaner-conformance-collapse

slavapestov · web-flow · commit 182946e6be9b · 2022-08-05T07:20:32.000-04:00
Cleaner conformance collapsing
diff --git a/include/swift/AST/ASTContext.h b/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
diff --git a/include/swift/AST/ProtocolConformance.h b/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);
diff --git a/include/swift/AST/RequirementEnvironment.h b/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 {
diff --git a/lib/AST/ASTContext.cpp b/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;
@@ -2456,6 +2436,14 @@ ASTContext::getSpecializedConformance(Type type,
 
 InheritedProtocolConformance *
 ASTContext::getInheritedConformance(Type type, ProtocolConformance *inherited) {
+  // Collapse multiple levels of inherited conformance.
+  while (auto *otherInherited = dyn_cast<InheritedProtocolConformance>(inherited))
+    inherited = otherInherited->getInheritedConformance();
+
+  assert(isa<SpecializedProtocolConformance>(inherited) ||
+         isa<NormalProtocolConformance>(inherited) ||
+         isa<BuiltinProtocolConformance>(inherited));
+
   llvm::FoldingSetNodeID id;
   InheritedProtocolConformance::Profile(id, type, inherited);
 
diff --git a/lib/AST/Module.cpp b/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);
     }
   }
diff --git a/lib/AST/ProtocolConformance.cpp b/lib/AST/ProtocolConformance.cpp
@@ -347,46 +347,19 @@ GenericSignature ProtocolConformance::getGenericSignature() const {
 }
 
 SubstitutionMap ProtocolConformance::getSubstitutions(ModuleDecl *M) const {
-  // Walk down to the base NormalProtocolConformance.
-  SubstitutionMap subMap;
-  const ProtocolConformance *parent = this;
-  while (!isa<RootProtocolConformance>(parent)) {
-    switch (parent->getKind()) {
-    case ProtocolConformanceKind::Normal:
-    case ProtocolConformanceKind::Self:
-    case ProtocolConformanceKind::Builtin:
-      llvm_unreachable("should have exited the loop?!");
-    case ProtocolConformanceKind::Inherited:
-      parent =
-          cast<InheritedProtocolConformance>(parent)->getInheritedConformance();
-      break;
-    case ProtocolConformanceKind::Specialized: {
-      auto SC = cast<SpecializedProtocolConformance>(parent);
-      parent = SC->getGenericConformance();
-      assert(subMap.empty() && "multiple conformance specializations?!");
-      subMap = SC->getSubstitutionMap();
-      break;
-    }
-    }
-  }
+  const ProtocolConformance *conformance = this;
 
-  // Found something; we're done!
-  if (!subMap.empty())
-    return subMap;
+  if (auto *inheritedC = dyn_cast<InheritedProtocolConformance>(conformance))
+    conformance = inheritedC->getInheritedConformance();
 
-  // If the normal conformance is for a generic type, and we didn't hit a
-  // specialized conformance, collect the substitutions from the generic type.
-  // FIXME: The AST should do this for us.
-  const NormalProtocolConformance *normalC =
-      dyn_cast<NormalProtocolConformance>(parent);
-  if (!normalC)
-    return SubstitutionMap();
+  if (auto *specializedC = dyn_cast<SpecializedProtocolConformance>(conformance))
+    return specializedC->getSubstitutionMap();
 
-  if (!normalC->getType()->isSpecialized())
-    return SubstitutionMap();
+  auto *rootC = cast<RootProtocolConformance>(conformance);
+  if (auto genericSig = rootC->getGenericSignature())
+    return genericSig->getIdentitySubstitutionMap();
 
-  auto *DC = normalC->getDeclContext();
-  return normalC->getType()->getContextSubstitutionMap(M, DC);
+  return SubstitutionMap();
 }
 
 bool RootProtocolConformance::isInvalid() const {
@@ -957,14 +930,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?
@@ -1133,22 +1103,12 @@ ProtocolConformance::getRootNormalConformance() const {
 const RootProtocolConformance *
 ProtocolConformance::getRootConformance() const {
   const ProtocolConformance *C = this;
-  while (true) {
-    switch (C->getKind()) {
-    case ProtocolConformanceKind::Normal:
-    case ProtocolConformanceKind::Self:
-    case ProtocolConformanceKind::Builtin:
-      return cast<RootProtocolConformance>(C);
-    case ProtocolConformanceKind::Inherited:
-      C = cast<InheritedProtocolConformance>(C)
-          ->getInheritedConformance();
-      break;
-    case ProtocolConformanceKind::Specialized:
-      C = cast<SpecializedProtocolConformance>(C)
-        ->getGenericConformance();
-      break;
-    }
-  }
+  if (auto *inheritedC = dyn_cast<InheritedProtocolConformance>(C))
+    C = inheritedC->getInheritedConformance();
+  if (auto *specializedC = dyn_cast<SpecializedProtocolConformance>(C))
+    return specializedC->getGenericConformance();
+
+  return cast<RootProtocolConformance>(C);
 }
 
 bool ProtocolConformance::isVisibleFrom(const DeclContext *dc) const {
@@ -1181,9 +1141,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 +1622,8 @@ ProtocolConformance *ProtocolConformance::getCanonicalConformance() {
     auto genericConformance = spec->getGenericConformance();
     return Ctx.getSpecializedConformance(
                                 getType()->getCanonicalType(),
-                                genericConformance->getCanonicalConformance(),
+                                cast<RootProtocolConformance>(
+                                    genericConformance->getCanonicalConformance()),
                                 spec->getSubstitutionMap().getCanonical());
   }
   }
diff --git a/lib/AST/RequirementEnvironment.cpp b/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();
 
diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp
@@ -3134,7 +3134,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);
diff --git a/lib/SIL/Parser/ParseSIL.cpp b/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);
   }
 
diff --git a/lib/SILGen/SILGenLazyConformance.cpp b/lib/SILGen/SILGenLazyConformance.cpp
@@ -37,17 +37,18 @@ void SILGenModule::useConformance(ProtocolConformanceRef conformanceRef) {
   if (auto *inherited = dyn_cast<InheritedProtocolConformance>(conformance))
     conformance = inherited->getInheritedConformance();
 
+  // Emit any conformances implied by conditional requirements.
+  if (auto *specialized = dyn_cast<SpecializedProtocolConformance>(conformance)) {
+    useConformancesFromSubstitutions(specialized->getSubstitutionMap());
+    conformance = specialized->getGenericConformance();
+  }
+
   // Get the normal conformance. If we don't have one, this is a self
   // conformance, which we can ignore.
-  auto normal = dyn_cast<NormalProtocolConformance>(
-      conformance->getRootConformance());
+  auto normal = dyn_cast<NormalProtocolConformance>(conformance);
   if (normal == nullptr)
     return;
 
-  // Emit any conformances implied by conditional requirements.
-  if (auto *specialized = dyn_cast<SpecializedProtocolConformance>(conformance))
-    useConformancesFromSubstitutions(specialized->getSubstitutionMap());
-
   // If this conformance was not synthesized by the ClangImporter, we're not
   // going to be emitting it lazily either, so we can avoid doing anything
   // below.
diff --git a/lib/Sema/TypeCheckProtocol.cpp b/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()) {
diff --git a/lib/Sema/TypeCheckProtocol.h b/lib/Sema/TypeCheckProtocol.h
@@ -1254,7 +1254,7 @@ RequirementMatch matchWitness(
 
 RequirementMatch
 matchWitness(WitnessChecker::RequirementEnvironmentCache &reqEnvCache,
-             ProtocolDecl *proto, ProtocolConformance *conformance,
+             ProtocolDecl *proto, RootProtocolConformance *conformance,
              DeclContext *dc, ValueDecl *req, ValueDecl *witness);
 
 /// If the given type is a direct reference to an associated type of
diff --git a/lib/Serialization/Deserialization.cpp b/lib/Serialization/Deserialization.cpp
@@ -553,11 +553,11 @@ ProtocolConformanceDeserializer::readSpecializedProtocolConformance(
   PrettyStackTraceDecl traceTo("... to", genericConformance.getRequirement());
   ++NumNormalProtocolConformancesLoaded;
 
-  assert(genericConformance.isConcrete() && "Abstract generic conformance?");
+  auto *rootConformance = cast<RootProtocolConformance>(
+      genericConformance.getConcrete());
+
   auto conformance =
-         ctx.getSpecializedConformance(conformingType,
-                                       genericConformance.getConcrete(),
-                                       subMap);
+         ctx.getSpecializedConformance(conformingType, rootConformance, subMap);
   return conformance;
 }
 

Original file line number	Diff line number	Diff line change
`@@ -1447,7 +1447,8 @@ LookupConformanceInModuleRequest::evaluate(`
`1447`	`1447`	`auto subMap = type->getContextSubstitutionMap(mod, explicitConformanceDC);`
`1448`	`1448`
`1449`	`1449`	`// Create the specialized conformance entry.`
`1450`		`- auto result = ctx.getSpecializedConformance(type, conformance, subMap);`
	`1450`	`+ auto result = ctx.getSpecializedConformance(type,`
	`1451`	`+ cast<RootProtocolConformance>(conformance), subMap);`
`1451`	`1452`	`return ProtocolConformanceRef(result);`
`1452`	`1453`	`}`
`1453`	`1454`	`}`