AST: Introduce ReplaceExistentialArchetypesWithConcreteTypes

Author: slavapestov

include/swift/AST/Types.h

@@ -7082,6 +7082,32 @@ class ReplaceOpaqueTypesWithUnderlyingTypes {
   bool isWholeModule() const { return inContextAndIsWholeModule.getInt(); }
 };
 
+/// A function object that can be used as a \c TypeSubstitutionFn and
+/// \c LookupConformanceFn for \c Type::subst style APIs to map existential
+/// archetypes in the given generic environment to known concrete types from
+/// the given substitution map.
+class ReplaceExistentialArchetypesWithConcreteTypes {
+private:
+  GenericEnvironment *env;
+  SubstitutionMap subs;
+
+  Type getInterfaceType(ExistentialArchetypeType *type) const;
+
+public:
+  ReplaceExistentialArchetypesWithConcreteTypes(GenericEnvironment *env,
+                                                SubstitutionMap subs)
+      : env(env), subs(subs) {}
+
+  /// TypeSubstitutionFn
+  Type operator()(SubstitutableType *type) const;
+
+  /// LookupConformanceFn
+  ProtocolConformanceRef operator()(CanType origType,
+                                    Type substType,
+                                    ProtocolDecl *protocol) const;
+
+};
+
 /// An archetype that's only valid in a portion of a local context.
 class LocalArchetypeType : public ArchetypeType {
 protected:

lib/AST/TypeSubstitution.cpp

@@ -1200,3 +1200,35 @@ operator()(CanType maybeOpaqueType, Type replacementType,
   }
   return substRef;
 }
+
+Type ReplaceExistentialArchetypesWithConcreteTypes::getInterfaceType(
+    ExistentialArchetypeType *type) const {
+  return type->getInterfaceType().transformRec(
+    [&](TypeBase *type) -> std::optional<Type> {
+      if (isa<GenericTypeParamType>(type))
+        return type->getASTContext().TheSelfType;
+      return std::nullopt;
+    });
+}
+
+Type ReplaceExistentialArchetypesWithConcreteTypes::operator()(
+    SubstitutableType *type) const {
+  auto *existentialArchetype = dyn_cast<ExistentialArchetypeType>(type);
+  if (!existentialArchetype ||
+      existentialArchetype->getGenericEnvironment() != env)
+    return type;
+
+  auto interfaceType = getInterfaceType(existentialArchetype);
+  return interfaceType.subst(subs);
+}
+
+ProtocolConformanceRef ReplaceExistentialArchetypesWithConcreteTypes::operator()(
+    CanType origType, Type substType, ProtocolDecl *proto) const {
+  auto existentialArchetype = dyn_cast<ExistentialArchetypeType>(origType);
+  if (!existentialArchetype ||
+      existentialArchetype->getGenericEnvironment() != env)
+    return ProtocolConformanceRef::forAbstract(substType, proto);
+
+  return subs.lookupConformance(
+      getInterfaceType(existentialArchetype)->getCanonicalType(), proto);
+}