Merge pull request #58412 from CodaFi/remote-work

[Remote AST] Support Parameterized Existential Types

Author: CodaFi

include/swift/ABI/GenericContext.h

@@ -58,7 +58,7 @@ struct TargetGenericContextDescriptorHeader {
   /// Key arguments include generic parameters and conformance
   /// requirements which are part of the identity of the context.
   ///
-  /// The key area of the argument layout considers of a sequence
+  /// The key area of the argument layout consists of a sequence
   /// of type metadata pointers (in the same order as the parameter
   /// descriptors, for those parameters which satisfy hasKeyArgument())
   /// followed by a sequence of witness table pointers (in the same
@@ -191,25 +191,48 @@ using GenericRequirementDescriptor =
 extern const GenericParamDescriptor
 ImplicitGenericParamDescriptors[MaxNumImplicitGenericParamDescriptors];
 
+inline const GenericParamDescriptor *
+externalTargetImplicitGenericParamDescriptors() {
+  static const GenericParamDescriptor
+      buffer[MaxNumImplicitGenericParamDescriptors] = {
+#define D GenericParamDescriptor::implicit()
+          D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D,
+          D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D,
+          D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D
+#undef D
+      };
+  return buffer;
+}
+
+template <class Runtime>
+const GenericParamDescriptor *targetImplicitGenericParamDescriptors() {
+  return externalTargetImplicitGenericParamDescriptors();
+}
+template <>
+inline const GenericParamDescriptor *targetImplicitGenericParamDescriptors<InProcess>() {
+  return ImplicitGenericParamDescriptors;
+}
+
 /// A runtime description of a generic signature.
+template<typename Runtime>
 class RuntimeGenericSignature {
-  GenericContextDescriptorHeader Header;
+  TargetGenericContextDescriptorHeader<Runtime> Header;
   const GenericParamDescriptor *Params;
-  const GenericRequirementDescriptor *Requirements;
+  const TargetGenericRequirementDescriptor<Runtime> *Requirements;
 public:
   RuntimeGenericSignature()
     : Header{0, 0, 0, 0}, Params(nullptr), Requirements(nullptr) {}
 
-  RuntimeGenericSignature(const GenericContextDescriptorHeader &header,
+  RuntimeGenericSignature(const TargetGenericContextDescriptorHeader<Runtime> &header,
                           const GenericParamDescriptor *params,
-                          const GenericRequirementDescriptor *requirements)
+                          const TargetGenericRequirementDescriptor<Runtime> *requirements)
     : Header(header), Params(params), Requirements(requirements) {}
 
   llvm::ArrayRef<GenericParamDescriptor> getParams() const {
     return llvm::makeArrayRef(Params, Header.NumParams);
   }
 
-  llvm::ArrayRef<GenericRequirementDescriptor> getRequirements() const {
+  llvm::ArrayRef<TargetGenericRequirementDescriptor<Runtime>> getRequirements() const {
     return llvm::makeArrayRef(Requirements, Header.NumRequirements);
   }
 
@@ -375,8 +398,8 @@ class TrailingGenericContextObjects<TargetSelf<Runtime>,
              * sizeof(StoredPointer);
   }
 
-  RuntimeGenericSignature getGenericSignature() const {
-    if (!asSelf()->isGeneric()) return RuntimeGenericSignature();
+  RuntimeGenericSignature<Runtime> getGenericSignature() const {
+    if (!asSelf()->isGeneric()) return RuntimeGenericSignature<Runtime>();
     return {getGenericContextHeader(),
             getGenericParams().data(),
             getGenericRequirements().data()};

include/swift/ABI/Metadata.h

@@ -1735,6 +1735,12 @@ struct TargetExistentialTypeMetadata
 using ExistentialTypeMetadata
   = TargetExistentialTypeMetadata<InProcess>;
 
+template<typename Runtime>
+struct TargetExistentialTypeExpression {
+  /// The type expression.
+  TargetRelativeDirectPointer<Runtime, const char, /*nullable*/ false> name;
+};
+
 /// A description of the shape of an existential type.
 ///
 /// An existential type has the general form:
@@ -1791,7 +1797,7 @@ struct TargetExtendedExistentialTypeShape
       // Optional generalization signature header
       TargetGenericContextDescriptorHeader<Runtime>,
       // Optional type subexpression
-      TargetRelativeDirectPointer<Runtime, const char, /*nullable*/ false>,
+      TargetExistentialTypeExpression<Runtime>,
       // Optional suggested value witnesses
       TargetRelativeIndirectablePointer<Runtime, const TargetValueWitnessTable<Runtime>,
                                         /*nullable*/ false>,
@@ -1802,8 +1808,6 @@ struct TargetExtendedExistentialTypeShape
       // for generalization signature
       TargetGenericRequirementDescriptor<Runtime>> {
 private:
-  using RelativeStringPointer =
-    TargetRelativeDirectPointer<Runtime, const char, /*nullable*/ false>;
   using RelativeValueWitnessTablePointer =
     TargetRelativeIndirectablePointer<Runtime,
                                       const TargetValueWitnessTable<Runtime>,
@@ -1812,7 +1816,7 @@ struct TargetExtendedExistentialTypeShape
     swift::ABI::TrailingObjects<
       TargetExtendedExistentialTypeShape<Runtime>,
       TargetGenericContextDescriptorHeader<Runtime>,
-      RelativeStringPointer,
+      TargetExistentialTypeExpression<Runtime>,
       RelativeValueWitnessTablePointer,
       GenericParamDescriptor,
       TargetGenericRequirementDescriptor<Runtime>>;
@@ -1825,7 +1829,7 @@ struct TargetExtendedExistentialTypeShape
     return Flags.hasGeneralizationSignature();
   }
 
-  size_t numTrailingObjects(OverloadToken<RelativeStringPointer>) const {
+  size_t numTrailingObjects(OverloadToken<TargetExistentialTypeExpression<Runtime>>) const {
     return Flags.hasTypeExpression();
   }
 
@@ -1879,12 +1883,13 @@ struct TargetExtendedExistentialTypeShape
   /// we nonetheless distinguish at compile time.  Storing this also
   /// allows us to far more easily produce a formal type from this
   /// shape reflectively.
-  RelativeStringPointer ExistentialType;
+  TargetRelativeDirectPointer<Runtime, const char, /*nullable*/ false>
+      ExistentialType;
 
   /// The header describing the requirement signature of the existential.
   TargetGenericContextDescriptorHeader<Runtime> ReqSigHeader;
 
-  RuntimeGenericSignature getRequirementSignature() const {
+  RuntimeGenericSignature<Runtime> getRequirementSignature() const {
     return {ReqSigHeader, getReqSigParams(), getReqSigRequirements()};
   }
 
@@ -1894,8 +1899,8 @@ struct TargetExtendedExistentialTypeShape
 
   const GenericParamDescriptor *getReqSigParams() const {
     return Flags.hasImplicitReqSigParams()
-             ? ImplicitGenericParamDescriptors
-             : this->template getTrailingObjects<GenericParamDescriptor>();
+               ? swift::targetImplicitGenericParamDescriptors<Runtime>()
+               : this->template getTrailingObjects<GenericParamDescriptor>();
   }
 
   unsigned getNumReqSigRequirements() const {
@@ -1911,10 +1916,11 @@ struct TargetExtendedExistentialTypeShape
   /// The type expression of the existential, as a symbolic mangled type
   /// string.  Must be null if the header is just the (single)
   /// requirement type parameter.
-  TargetPointer<Runtime, const char> getTypeExpression() const {
+  const TargetExistentialTypeExpression<Runtime> *getTypeExpression() const {
     return Flags.hasTypeExpression()
-      ? this->template getTrailingObjects<RelativeStringPointer>()->get()
-      : nullptr;
+               ? this->template getTrailingObjects<
+                     TargetExistentialTypeExpression<Runtime>>()
+               : nullptr;
   }
 
   bool isTypeExpressionOpaque() const {
@@ -1961,8 +1967,8 @@ struct TargetExtendedExistentialTypeShape
     return Flags.hasGeneralizationSignature();
   }
 
-  RuntimeGenericSignature getGeneralizationSignature() const {
-    if (!hasGeneralizationSignature()) return RuntimeGenericSignature();
+  RuntimeGenericSignature<Runtime> getGeneralizationSignature() const {
+    if (!hasGeneralizationSignature()) return RuntimeGenericSignature<Runtime>();
     return {*getGenSigHeader(), getGenSigParams(), getGenSigRequirements()};
   }
 
@@ -1974,7 +1980,7 @@ struct TargetExtendedExistentialTypeShape
   const GenericParamDescriptor *getGenSigParams() const {
     assert(hasGeneralizationSignature());
     if (Flags.hasImplicitGenSigParams())
-      return ImplicitGenericParamDescriptors;
+      return swift::targetImplicitGenericParamDescriptors<Runtime>();
     auto base = this->template getTrailingObjects<GenericParamDescriptor>();
     if (!Flags.hasImplicitReqSigParams())
       base += getNumReqSigParams();
@@ -2086,6 +2092,8 @@ struct TargetExtendedExistentialTypeMetadata
     swift::ABI::TrailingObjects<
       TargetExtendedExistentialTypeMetadata<Runtime>,
       ConstTargetPointer<Runtime, void>> {
+  using StoredSize = typename Runtime::StoredSize;
+
 private:
   using TrailingObjects =
     swift::ABI::TrailingObjects<
@@ -2097,9 +2105,12 @@ struct TargetExtendedExistentialTypeMetadata
   using OverloadToken = typename TrailingObjects::template OverloadToken<T>;
 
   size_t numTrailingObjects(OverloadToken<ConstTargetPointer<Runtime, void>>) const {
-    return Shape->getGenSigLayoutSizeInWords();
+    return Shape->getGenSigArgumentLayoutSizeInWords();
   }
 
+public:
+  static constexpr StoredSize OffsetToArguments = sizeof(TargetMetadata<Runtime>);
+
 public:
   explicit constexpr
   TargetExtendedExistentialTypeMetadata(const ExtendedExistentialTypeShape *shape)
@@ -2113,6 +2124,11 @@ struct TargetExtendedExistentialTypeMetadata
   ConstTargetPointer<Runtime, void> const *getGeneralizationArguments() const {
     return this->template getTrailingObjects<ConstTargetPointer<Runtime, void>>();
   }
+
+public:
+  static bool classof(const TargetMetadata<Runtime> *metadata) {
+    return metadata->getKind() == MetadataKind::ExtendedExistential;
+  }
 };
 using ExtendedExistentialTypeMetadata
   = TargetExtendedExistentialTypeMetadata<InProcess>;

include/swift/AST/ASTDemangler.h

@@ -59,6 +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; }
@@ -112,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,
@@ -134,7 +141,6 @@ class ASTBuilder {
   Type createSILBoxType(Type base);
   using BuiltSILBoxField = llvm::PointerIntPair<Type, 1>;
   using BuiltSubstitution = std::pair<Type, Type>;
-  using BuiltRequirement = swift::Requirement;
   using BuiltLayoutConstraint = swift::LayoutConstraint;
   Type createSILBoxTypeWithLayout(ArrayRef<BuiltSILBoxField> Fields,
                                   ArrayRef<BuiltSubstitution> Substitutions,
@@ -167,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

@@ -464,6 +464,9 @@ class TypeDecoder {
   using BuiltSubstitution = typename BuilderType::BuiltSubstitution;
   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;