Add Substitution Machinery to Builders

Add requirements to the Builder concept to construct generic signatures and substitution maps. Then introduce a `subst` requirement that uses the substitution map to call through to the builder's notion of type (ref) substitution.

This infrastructure is sufficient to model the notion of a RuntimeGenericSignature.

Author: CodaFi

include/swift/AST/ASTDemangler.h

@@ -59,8 +59,11 @@ class ASTBuilder {
   using BuiltType = swift::Type;
   using BuiltTypeDecl = swift::GenericTypeDecl *; // nominal or type alias
   using BuiltProtocolDecl = swift::ProtocolDecl *;
+  using BuiltGenericSignature = swift::GenericSignature;
   using BuiltGenericTypeParam = swift::GenericTypeParamType *;
   using BuiltRequirement = swift::Requirement;
+  using BuiltSubstitutionMap = swift::SubstitutionMap;
+
   explicit ASTBuilder(ASTContext &ctx) : Ctx(ctx) {}
 
   ASTContext &getASTContext() { return Ctx; }
@@ -114,6 +117,8 @@ class ASTBuilder {
                                      bool isClassBound,
                                      bool forRequirement = true);
 
+  Type createProtocolTypeFromDecl(ProtocolDecl *protocol);
+
   Type createParameterizedProtocolType(Type base, ArrayRef<Type> args);
 
   Type createExistentialMetatypeType(Type instance,
@@ -168,6 +173,15 @@ class ASTBuilder {
 
   Type createParenType(Type base);
 
+  BuiltGenericSignature
+  createGenericSignature(ArrayRef<BuiltType> params,
+                         ArrayRef<BuiltRequirement> requirements);
+
+  BuiltSubstitutionMap createSubstitutionMap(BuiltGenericSignature sig,
+                                             ArrayRef<BuiltType> replacements);
+
+  Type subst(Type subject, const BuiltSubstitutionMap &Subs) const;
+
   LayoutConstraint getLayoutConstraint(LayoutConstraintKind kind);
   LayoutConstraint getLayoutConstraintWithSizeAlign(LayoutConstraintKind kind,
                                                     unsigned size,

include/swift/Demangling/TypeDecoder.h

@@ -465,6 +465,8 @@ class TypeDecoder {
   using BuiltRequirement = typename BuilderType::BuiltRequirement;
   using BuiltLayoutConstraint = typename BuilderType::BuiltLayoutConstraint;
   using BuiltGenericTypeParam = typename BuilderType::BuiltGenericTypeParam;
+  using BuiltGenericSignature = typename BuilderType::BuiltGenericSignature;
+  using BuiltSubstitutionMap = typename BuilderType::BuiltSubstitutionMap;
   using NodeKind = Demangle::Node::Kind;
 
   BuilderType &Builder;

include/swift/Reflection/TypeRef.h

@@ -741,6 +741,37 @@ class DependentMemberTypeRef final : public TypeRef {
   }
 };
 
+/// A representation of a dynamically-constructed generic signature.
+///
+/// \note This class is not a \c TypeRef.
+class GenericSignatureRef final {
+  std::vector<const GenericTypeParameterTypeRef *> Params;
+  std::vector<TypeRefRequirement> Requirements;
+
+public:
+  GenericSignatureRef(
+      llvm::ArrayRef<const GenericTypeParameterTypeRef *> Params,
+      llvm::ArrayRef<TypeRefRequirement> Requirements)
+      : Params(Params.begin(), Params.end()),
+        Requirements(Requirements.begin(), Requirements.end()) {}
+
+  template <typename Allocator>
+  static const GenericSignatureRef *
+  create(Allocator &A,
+         llvm::ArrayRef<const GenericTypeParameterTypeRef *> Params,
+         llvm::ArrayRef<TypeRefRequirement> Requirements) {
+    return A.template makeGenericSignatureRef(Params, Requirements);
+  }
+
+  const llvm::ArrayRef<const GenericTypeParameterTypeRef *> getParams() const {
+    return Params;
+  }
+
+  const llvm::ArrayRef<TypeRefRequirement> getRequirements() const {
+    return Requirements;
+  }
+};
+
 class ForeignClassTypeRef final : public TypeRef {
   std::string Name;
 

include/swift/Reflection/TypeRefBuilder.h

@@ -360,6 +360,8 @@ class TypeRefBuilder {
   using BuiltRequirement = TypeRefRequirement;
   using BuiltLayoutConstraint = TypeRefLayoutConstraint;
   using BuiltGenericTypeParam = const GenericTypeParameterTypeRef *;
+  using BuiltGenericSignature = const GenericSignatureRef *;
+  using BuiltSubstitutionMap = llvm::DenseMap<DepthAndIndex, const TypeRef *>;
 
   TypeRefBuilder(const TypeRefBuilder &other) = delete;
   TypeRefBuilder &operator=(const TypeRefBuilder &other) = delete;
@@ -378,6 +380,8 @@ class TypeRefBuilder {
   /// Cache for field info lookups.
   std::unordered_map<std::string, RemoteRef<FieldDescriptor>> FieldTypeInfoCache;
 
+  std::vector<std::unique_ptr<const GenericSignatureRef>> SignatureRefPool;
+
   TypeConverter TC;
   MetadataSourceBuilder MSB;
 
@@ -394,6 +398,13 @@ class TypeRefBuilder {
     return TR;
   }
 
+  template <typename... Args>
+  const GenericSignatureRef *makeGenericSignatureRef(Args... args) {
+    const auto TR = new GenericSignatureRef(::std::forward<Args>(args)...);
+    SignatureRefPool.push_back(std::unique_ptr<const GenericSignatureRef>(TR));
+    return TR;
+  }
+
   Demangle::NodeFactory &getNodeFactory() { return Dem; }
 
   void clearNodeFactory() { Dem.clear(); }
@@ -599,6 +610,14 @@ class TypeRefBuilder {
         *this, {}, result, funcFlags, diffKind, nullptr);
   }
 
+  BuiltType createProtocolTypeFromDecl(BuiltProtocolDecl protocol) {
+    if (protocol->second) {
+      return llvm::cast<TypeRef>(createObjCProtocolType(protocol->first));
+    } else {
+      return llvm::cast<TypeRef>(createNominalType(protocol->first));
+    }
+  }
+
   const ProtocolCompositionTypeRef *
   createProtocolCompositionType(llvm::ArrayRef<BuiltProtocolDecl> protocols,
                                 BuiltType superclass, bool isClassBound,
@@ -608,10 +627,10 @@ class TypeRefBuilder {
       if (!protocol)
         continue;
 
-      if (protocol->second)
-        protocolRefs.push_back(createObjCProtocolType(protocol->first));
-      else
-        protocolRefs.push_back(createNominalType(protocol->first));
+      auto protocolType = createProtocolTypeFromDecl(*protocol);
+      if (!protocolType)
+        continue;
+      protocolRefs.push_back(protocolType);
     }
 
     return ProtocolCompositionTypeRef::create(*this, protocolRefs, superclass,
@@ -720,8 +739,7 @@ class TypeRefBuilder {
     return createObjCClassType(name);
   }
 
-  const ObjCProtocolTypeRef *
-  createObjCProtocolType(const std::string &name) {
+  const ObjCProtocolTypeRef *createObjCProtocolType(const std::string &name) {
     return ObjCProtocolTypeRef::create(*this, name);
   }
 
@@ -739,6 +757,41 @@ class TypeRefBuilder {
     return OpaqueTypeRef::get();
   }
 
+  BuiltGenericSignature
+  createGenericSignature(llvm::ArrayRef<BuiltType> builtParams,
+                         llvm::ArrayRef<BuiltRequirement> requirements) {
+    std::vector<BuiltGenericTypeParam> params;
+    for (auto &builtParam : builtParams) {
+      auto *genericRef =
+          llvm::dyn_cast<GenericTypeParameterTypeRef>(builtParam);
+      if (!genericRef)
+        return nullptr;
+      params.push_back(genericRef);
+    }
+    return GenericSignatureRef::create(*this, params, requirements);
+  }
+
+  BuiltSubstitutionMap
+  createSubstitutionMap(BuiltGenericSignature sig,
+                        llvm::ArrayRef<BuiltType> replacements) {
+    assert(sig->getParams().size() == replacements.size() &&
+           "Not enough replacement parameters!");
+    if (sig->getParams().size() != replacements.size())
+      return BuiltSubstitutionMap{};
+
+    BuiltSubstitutionMap map{};
+    for (unsigned paramIdx : indices(sig->getParams())) {
+      const auto *param = sig->getParams()[paramIdx];
+      auto replacement = replacements[paramIdx];
+      map[{param->getDepth(), param->getIndex()}] = replacement;
+    }
+    return map;
+  }
+
+  BuiltType subst(BuiltType subject, const BuiltSubstitutionMap &Subs) {
+    return subject->subst(*this, Subs);
+  }
+
   ///
   /// Parsing reflection metadata
   ///

include/swift/Remote/MetadataReader.h

@@ -166,7 +166,9 @@ class MetadataReader {
   using BuiltProtocolDecl = typename BuilderType::BuiltProtocolDecl;
   using BuiltRequirement = typename BuilderType::BuiltRequirement;
   using BuiltSubstitution = typename BuilderType::BuiltSubstitution;
+  using BuiltSubstitutionMap = typename BuilderType::BuiltSubstitutionMap;
   using BuiltGenericTypeParam = typename BuilderType::BuiltGenericTypeParam;
+  using BuiltGenericSignature = typename BuilderType::BuiltGenericSignature;
   using StoredPointer = typename Runtime::StoredPointer;
   using StoredSignedPointer = typename Runtime::StoredSignedPointer;
   using StoredSize = typename Runtime::StoredSize;

lib/AST/ASTDemangler.cpp

@@ -595,6 +595,10 @@ Type ASTBuilder::createProtocolCompositionType(
   return ExistentialType::get(composition);
 }
 
+Type ASTBuilder::createProtocolTypeFromDecl(ProtocolDecl *protocol) {
+  return protocol->getDeclaredInterfaceType();
+}
+
 static MetatypeRepresentation
 getMetatypeRepresentation(ImplMetatypeRepresentation repr) {
   switch (repr) {
@@ -794,6 +798,29 @@ Type ASTBuilder::createParenType(Type base) {
   return ParenType::get(Ctx, base);
 }
 
+GenericSignature
+ASTBuilder::createGenericSignature(ArrayRef<BuiltType> builtParams,
+                                   ArrayRef<BuiltRequirement> requirements) {
+  std::vector<BuiltGenericTypeParam> params;
+  for (auto &param : builtParams) {
+    auto paramTy = param->getAs<GenericTypeParamType>();
+    if (!paramTy)
+      return GenericSignature();
+    params.push_back(paramTy);
+  }
+  return GenericSignature::get(params, requirements);
+}
+
+SubstitutionMap
+ASTBuilder::createSubstitutionMap(BuiltGenericSignature sig,
+                                  ArrayRef<BuiltType> replacements) {
+  return SubstitutionMap::get(sig, replacements, {});
+}
+
+Type ASTBuilder::subst(Type subject, const BuiltSubstitutionMap &Subs) const {
+  return subject.subst(Subs);
+}
+
 bool ASTBuilder::validateParentType(TypeDecl *decl, Type parent) {
   auto parentDecl = decl->getDeclContext()->getSelfNominalTypeDecl();
 

stdlib/public/runtime/MetadataLookup.cpp

@@ -1322,7 +1322,9 @@ class DecodedMetadataBuilder {
   using BuiltType = const Metadata *;
   using BuiltTypeDecl = const ContextDescriptor *;
   using BuiltProtocolDecl = ProtocolDescriptorRef;
+  using BuiltGenericSignature = const Metadata *;
   using BuiltSubstitution = std::pair<BuiltType, BuiltType>;
+  using BuiltSubstitutionMap = llvm::ArrayRef<BuiltSubstitution>;
   using BuiltGenericTypeParam = const Metadata *;
 
   BuiltType decodeMangledType(NodePointer node,
@@ -1647,7 +1649,6 @@ class DecodedMetadataBuilder {
   }
 
   using BuiltSILBoxField = llvm::PointerIntPair<BuiltType, 1>;
-  using BuiltSubstitution = std::pair<BuiltType, BuiltType>;
   struct BuiltLayoutConstraint {
     bool operator==(BuiltLayoutConstraint rhs) const { return true; }
     operator bool() const { return true; }