AST: The generic conformance of a specialized conformance is always normal

Author: slavapestov

include/swift/AST/ASTContext.h

@@ -1302,15 +1302,17 @@ class ASTContext final {
   /// specialized conformance from the generic conformance.
   ProtocolConformance *
   getSpecializedConformance(Type type,
-                            RootProtocolConformance *generic,
+                            NormalProtocolConformance *generic,
                             SubstitutionMap substitutions);
 
-  /// Produce an inherited conformance, for subclasses of a type
-  /// that already conforms to a protocol.
+  /// Produce an inherited conformance, which forwards all operations to a
+  /// base conformance, except for getType(), which must return some subclass
+  /// of the base conformance's conforming type. This models the case where a
+  /// subclass conforms to a protocol because its superclass already conforms.
   ///
   /// \param type The type for which we are retrieving the conformance.
   ///
-  /// \param inherited The inherited conformance.
+  /// \param inherited A normal or specialized conformance.
   ProtocolConformance *
   getInheritedConformance(Type type, ProtocolConformance *inherited);
 

include/swift/AST/ProtocolConformance.h

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

lib/AST/ASTContext.cpp

@@ -2592,7 +2592,7 @@ ASTContext::getBuiltinConformance(Type type, ProtocolDecl *protocol,
 }
 
 static bool collapseSpecializedConformance(Type type,
-                                           RootProtocolConformance *conformance,
+                                           NormalProtocolConformance *conformance,
                                            SubstitutionMap substitutions) {
   if (!conformance->getType()->isEqual(type))
     return false;
@@ -2607,7 +2607,7 @@ static bool collapseSpecializedConformance(Type type,
 
 ProtocolConformance *
 ASTContext::getSpecializedConformance(Type type,
-                                      RootProtocolConformance *generic,
+                                      NormalProtocolConformance *generic,
                                       SubstitutionMap substitutions) {
   // If the specialization is a no-op, use the root conformance instead.
   if (collapseSpecializedConformance(type, generic, substitutions)) {

lib/AST/ConformanceLookup.cpp

@@ -643,8 +643,12 @@ LookupConformanceInModuleRequest::evaluate(
       ExpandExtensionMacros{nominal},
       { });
 
-  // Find the (unspecialized) conformance.
+  // Find the root conformance in the nominal type declaration's
+  // conformance lookup table.
   SmallVector<ProtocolConformance *, 2> conformances;
+
+  // If the conformance lookup table produced nothing, we try to derive the
+  // conformance for a few special protocol kinds.
   if (!nominal->lookupConformance(protocol, conformances)) {
     if (protocol->isSpecificProtocol(KnownProtocolKind::Sendable)) {
       // Try to infer Sendable conformance.
@@ -706,6 +710,8 @@ LookupConformanceInModuleRequest::evaluate(
     }
   }
 
+  // We should have at least one conformance by now, or we would have returned
+  // above.
   assert(!conformances.empty());
 
   // If we have multiple conformances, first try to filter out any that are
@@ -754,27 +760,32 @@ LookupConformanceInModuleRequest::evaluate(
     return ProtocolConformanceRef(conformance);
   }
 
-  // If the type is specialized, find the conformance for the generic type.
+  // We now have a root conformance for the nominal's declared interface type.
+  // If our type is specialized, apply a substitution map to the root
+  // conformance.
   if (type->isSpecialized()) {
-    // Figure out the type that's explicitly conforming to this protocol.
-    Type explicitConformanceType = conformance->getType();
-    DeclContext *explicitConformanceDC = conformance->getDeclContext();
-
-    // If the explicit conformance is associated with a type that is different
-    // from the type we're checking, retrieve generic conformance.
-    if (!explicitConformanceType->isEqual(type)) {
-      // Gather the substitutions we need to map the generic conformance to
-      // the specialized conformance.
-      auto subMap = type->getContextSubstitutionMap(mod, explicitConformanceDC);
-
-      // Create the specialized conformance entry.
-      auto result = ctx.getSpecializedConformance(type,
-        cast<RootProtocolConformance>(conformance), subMap);
-      return ProtocolConformanceRef(result);
+    if (!conformance->getType()->isEqual(type)) {
+      // We use a builtin conformance for unconditional Copyable and Escapable
+      // conformances. Avoid building a substitution map and just return the
+      // correct builtin conformance for the specialized type.
+      if (auto *builtinConf = dyn_cast<BuiltinProtocolConformance>(conformance)) {
+        return ProtocolConformanceRef(
+            ctx.getBuiltinConformance(type, protocol,
+                                      builtinConf->getBuiltinConformanceKind()));
+      }
+
+      // Otherwise, we have a normal conformance, so we're going to build a
+      // specialized conformance from the context substitution map of the
+      // specialized type.
+      auto *normalConf = cast<NormalProtocolConformance>(conformance);
+      auto *conformanceDC = normalConf->getDeclContext();
+      auto subMap = type->getContextSubstitutionMap(mod, conformanceDC);
+      return ProtocolConformanceRef(
+          ctx.getSpecializedConformance(type, normalConf, subMap));
     }
   }
 
-  // Record and return the simple conformance.
+  // Return the root conformance.
   return ProtocolConformanceRef(conformance);
 }
 

lib/AST/ProtocolConformance.cpp

@@ -731,7 +731,7 @@ void NormalProtocolConformance::overrideWitness(ValueDecl *requirement,
 
 SpecializedProtocolConformance::SpecializedProtocolConformance(
     Type conformingType,
-    RootProtocolConformance *genericConformance,
+    NormalProtocolConformance *genericConformance,
     SubstitutionMap substitutions)
   : ProtocolConformance(ProtocolConformanceKind::Specialized, conformingType),
     GenericConformance(genericConformance),
@@ -917,7 +917,7 @@ ProtocolConformance::subst(TypeSubstitutionFn subs,
 
 /// Check if the replacement is a one-element pack with a scalar type.
 static bool isVanishingTupleConformance(
-    RootProtocolConformance *generic,
+    NormalProtocolConformance *generic,
     SubstitutionMap substitutions) {
   if (!isa<BuiltinTupleDecl>(generic->getDeclContext()->getSelfNominalTypeDecl()))
     return false;
@@ -1515,7 +1515,7 @@ ProtocolConformance *ProtocolConformance::getCanonicalConformance() {
     auto genericConformance = spec->getGenericConformance();
     return Ctx.getSpecializedConformance(
                                 getType()->getCanonicalType(),
-                                cast<RootProtocolConformance>(
+                                cast<NormalProtocolConformance>(
                                     genericConformance->getCanonicalConformance()),
                                 spec->getSubstitutionMap().getCanonical());
   }

lib/AST/RequirementEnvironment.cpp

@@ -131,7 +131,8 @@ RequirementEnvironment::RequirementEnvironment(
             substConcreteType->getContextSubstitutionMap(
               conformanceDC->getParentModule(), conformanceDC);
           specialized =
-            ctx.getSpecializedConformance(substConcreteType, conformance,
+            ctx.getSpecializedConformance(substConcreteType,
+                                          cast<NormalProtocolConformance>(conformance),
                                           concreteSubs);
         }
 

lib/AST/Type.cpp

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

lib/SIL/Parser/ParseSIL.cpp

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

lib/SILGen/SILGen.h

@@ -85,7 +85,7 @@ class LLVM_LIBRARY_VISIBILITY SILGenModule : public ASTVisitor<SILGenModule> {
 
   /// The conformance for any DistributedActor to the Actor protocol,
   /// used only by the `distributedActorAsAnyActor` builtin.
-  RootProtocolConformance *distributedActorAsActorConformance = nullptr;
+  NormalProtocolConformance *distributedActorAsActorConformance = nullptr;
 
   size_t anonymousSymbolCounter = 0;
 

lib/Serialization/Deserialization.cpp

@@ -846,7 +846,7 @@ ProtocolConformanceDeserializer::readSpecializedProtocolConformance(
   PrettyStackTraceDecl traceTo("... to", genericConformance.getRequirement());
   ++NumNormalProtocolConformancesLoaded;
 
-  auto *rootConformance = cast<RootProtocolConformance>(
+  auto *rootConformance = cast<NormalProtocolConformance>(
       genericConformance.getConcrete());
 
   auto conformance =