AST: Add ProtocolConformanceRef::subst()

Extract this from Substitution::subst(), which is going away.

Author: slavapestov

include/swift/AST/ProtocolConformanceRef.h

@@ -91,6 +91,11 @@ class ProtocolConformanceRef {
   /// conformance represents.
   ProtocolConformanceRef getInherited(ProtocolDecl *parent) const;
 
+  /// Apply a substitution to the conforming type.
+  ProtocolConformanceRef subst(Type origType,
+                               TypeSubstitutionFn subs,
+                               LookupConformanceFn conformances) const;
+
   void dump() const;
   void dump(llvm::raw_ostream &out, unsigned indent = 0) const;
 

lib/AST/ProtocolConformance.cpp

@@ -95,6 +95,67 @@ ProtocolConformanceRef::getInherited(ProtocolDecl *parent) const {
   llvm_unreachable("unhandled ProtocolConformanceRef");
 }
 
+ProtocolConformanceRef
+ProtocolConformanceRef::subst(Type origType,
+                              TypeSubstitutionFn subs,
+                              LookupConformanceFn conformances) const {
+  auto substType = origType.subst(subs, conformances,
+                                  SubstFlags::UseErrorType);
+
+  if (substType->isOpenedExistential())
+    return *this;
+
+  // If we have a concrete conformance, we need to substitute the
+  // conformance to apply to the new type.
+  if (isConcrete())
+    return ProtocolConformanceRef(
+      getConcrete()->subst(substType, subs, conformances));
+
+  auto *proto = getRequirement();
+
+  // If the original type was an archetype, check the conformance map.
+  if (origType->is<SubstitutableType>()
+      || origType->is<DependentMemberType>()) {
+    if (auto result = conformances(origType->getCanonicalType(),
+                                   substType,
+                                   proto->getDeclaredType())) {
+      return *result;
+    }
+  }
+
+  // If that didn't find anything, we can still synthesize AnyObject
+  // conformances from thin air.  FIXME: gross.
+  if (proto->isSpecificProtocol(KnownProtocolKind::AnyObject)) {
+    if (substType->isExistentialType())
+      return *this;
+
+    ClassDecl *classDecl = nullptr;
+    auto archetype = substType->getAs<ArchetypeType>();
+
+    if (archetype) {
+      if (archetype->getSuperclass())
+        classDecl = archetype->getSuperclass()->getClassOrBoundGenericClass();
+
+      // A class-constrained archetype without a superclass constraint
+      // conforms to AnyObject abstractly.
+      if (!classDecl && archetype->requiresClass())
+        return ProtocolConformanceRef(proto);
+    } else {
+      classDecl = substType->getClassOrBoundGenericClass();
+    }
+
+    assert(classDecl);
+
+    // Create a concrete conformance based on the conforming class.
+    SmallVector<ProtocolConformance *, 1> lookupResults;
+    classDecl->lookupConformance(classDecl->getParentModule(), proto,
+                                 lookupResults);
+    return ProtocolConformanceRef(lookupResults.front());
+  }
+
+  llvm_unreachable("Invalid conformance substitution");
+}
+
 Type
 ProtocolConformanceRef::getTypeWitnessByName(Type type,
                                              ProtocolConformanceRef conformance,

lib/AST/Substitution.cpp

@@ -68,59 +68,10 @@ Substitution Substitution::subst(TypeSubstitutionFn subs,
   substConformances.reserve(Conformance.size());
 
   for (auto c : Conformance) {
-    // If we have a concrete conformance, we need to substitute the
-    // conformance to apply to the new type.
-    if (c.isConcrete()) {
-      auto substC = c.getConcrete()->subst(substReplacement,
-                                           subs, conformances);
-      substConformances.push_back(ProtocolConformanceRef(substC));
-      if (c != substConformances.back())
-        conformancesChanged = true;
-      continue;
-    }
-
-    // Otherwise, we may need to fill in the conformance.
-    ProtocolDecl *proto = c.getAbstract();
-    Optional<ProtocolConformanceRef> conformance;
-
-    // If the original type was an archetype, check the conformance map.
-    if (Replacement->is<SubstitutableType>()
-        || Replacement->is<DependentMemberType>()) {
-      conformance = conformances(Replacement->getCanonicalType(),
-                                 substReplacement,
-                                 proto->getDeclaredType());
-    }
-
-    // If that didn't find anything, we can still synthesize AnyObject
-    // conformances from thin air.  FIXME: gross.
-    if (!conformance &&
-        proto->isSpecificProtocol(KnownProtocolKind::AnyObject)) {
-      auto archetype =
-        dyn_cast<ArchetypeType>(substReplacement->getCanonicalType());
-      // If classDecl is not nullptr, it is a concrete class.
-      auto classDecl = substReplacement->getClassOrBoundGenericClass();
-      if (!classDecl && archetype->getSuperclass()) {
-        // Replacement type is an archetype with a superclass constraint.
-        classDecl = archetype->getSuperclass()->getClassOrBoundGenericClass();
-        assert(classDecl);
-      }
-      if (classDecl) {
-        // Create a concrete conformance based on the conforming class.
-        SmallVector<ProtocolConformance *, 1> lookupResults;
-        classDecl->lookupConformance(classDecl->getParentModule(), proto,
-                                     lookupResults);
-        conformance = ProtocolConformanceRef(lookupResults.front());
-      } else if (archetype && archetype->requiresClass()) {
-        // Replacement type is an archetype with a class constraint.
-        // Create an abstract conformance.
-        conformance = ProtocolConformanceRef(proto);
-      }
-    }
-
-    assert(conformance);
-    if (conformance->isConcrete())
+    auto newC = c.subst(Replacement, subs, conformances);
+    if (c != newC)
       conformancesChanged = true;
-    substConformances.push_back(*conformance);
+    substConformances.push_back(newC);
   }
   assert(substConformances.size() == Conformance.size());