AST: Add new implementation of getOpenedExistentialSignature()

This will replace all existing usages of the old implementation.

Author: slavapestov

include/swift/AST/ASTContext.h

@@ -220,6 +220,30 @@ class MissingWitnessesBase {
   virtual ~MissingWitnessesBase();
 };
 
+/// Return value of ASTContext::getOpenedExistentialSignature().
+struct OpenedExistentialSignature {
+  /// The generalized existential type.
+  ///
+  /// The actual generic arguments of superclass and parameterized protocol
+  /// types become fresh generic parameters in the generalization signature.
+  CanType Shape;
+
+  /// A substitution map sending each generic parameter of the generalization
+  /// signature to the corresponding generic argument in the original
+  /// existential type. May contain type variables.
+  SubstitutionMap Generalization;
+
+  /// The opened existential signature derived from the generalization signature.
+  ///
+  /// This is the generalization signature with one more generic parameter
+  /// `Self` at the next highest depth, subject to the requirement
+  /// `Self: Shape`, where `Shape` is above.
+  CanGenericSignature OpenedSig;
+
+  /// The `Self` parameter in the opened existential signature.
+  CanType SelfType;
+};
+
 /// ASTContext - This object creates and owns the AST objects.
 /// However, this class does more than just maintain context within an AST.
 /// It is the closest thing to thread-local or compile-local storage in this
@@ -1435,6 +1459,18 @@ class ASTContext final {
   CanGenericSignature getOpenedExistentialSignature(Type type,
                                                     GenericSignature parentSig);
 
+  /// Retrieve a generic signature with a single type parameter conforming
+  /// to the given protocol or composition type, like <T: P>.
+  ///
+  /// The opened archetype may have a different set of conformances from the
+  /// corresponding existential. The opened archetype conformances are dictated
+  /// by the ABI for generic arguments, while the existential value conformances
+  /// are dictated by their layout (see \c Type::getExistentialLayout()). In
+  /// particular, the opened archetype signature does not have requirements for
+  /// conformances inherited from superclass constraints while existential
+  /// values do.
+  OpenedExistentialSignature getOpenedExistentialSignature(Type type);
+
   /// Get a generic signature where the generic parameter τ_d_i represents
   /// the element of the pack generic parameter τ_d_i… in \p baseGenericSig.
   ///

lib/AST/ASTContext.cpp

@@ -557,8 +557,11 @@ struct ASTContext::Implementation {
     llvm::FoldingSet<LayoutConstraintInfo> LayoutConstraints;
     llvm::DenseMap<std::pair<OpaqueTypeDecl *, SubstitutionMap>,
                    GenericEnvironment *> OpaqueArchetypeEnvironments;
-    llvm::DenseMap<OpenedExistentialKey, GenericEnvironment *>
-      OpenedExistentialEnvironments;
+
+    llvm::DenseMap<CanType,
+                   OpenedExistentialSignature> ExistentialSignatures;
+    llvm::DenseMap<OpenedExistentialKey,
+                   GenericEnvironment *> OpenedExistentialEnvironments;
 
     /// The set of function types.
     llvm::FoldingSet<FunctionType> FunctionTypes;
@@ -6156,12 +6159,58 @@ ASTContext::getOpenedExistentialSignature(Type type, GenericSignature parentSig)
 
   auto result = getImpl().ExistentialSignatures.insert(
       std::make_pair(key, genericSig));
-  assert(result.second);
-  (void) result;
+  ASSERT(result.second);
 
   return genericSig;
 }
 
+OpenedExistentialSignature
+ASTContext::getOpenedExistentialSignature(Type type) {
+  assert(type->isExistentialType());
+
+  if (auto existential = type->getAs<ExistentialType>())
+    type = existential->getConstraintType();
+
+  const CanType constraint = type->getCanonicalType();
+
+  // The constraint type might contain type variables.
+  auto properties = constraint->getRecursiveProperties();
+  auto arena = getArena(properties);
+
+  // Check the cache.
+  const auto &sigs = getImpl().getArena(arena).ExistentialSignatures;
+  auto found = sigs.find(constraint);
+  if (found != sigs.end())
+    return found->second;
+
+  OpenedExistentialSignature existentialSig;
+
+  // Generalize the existential type, to move type variables and primary
+  // archetypes into the substitution map.
+  auto gen = ExistentialTypeGeneralization::get(constraint);
+  existentialSig.Shape = gen.Shape->getCanonicalType();
+  existentialSig.Generalization = gen.Generalization;
+
+  // Now, we have an existential type written with type parameters only.
+  // Open the generalization signature by adding a new generic parameter
+  // for `Self`.
+  auto parentSig = gen.Generalization.getGenericSignature();
+  existentialSig.OpenedSig =
+      getOpenedExistentialSignature(gen.Shape, parentSig);
+
+  // Stash the `Self` type.
+  existentialSig.SelfType =
+      OpenedArchetypeType::getSelfInterfaceTypeFromContext(parentSig, *this)
+          ->getCanonicalType();
+
+  // Cache the result.
+  auto result = getImpl().getArena(arena).ExistentialSignatures.insert(
+      std::make_pair(constraint, existentialSig));
+  ASSERT(result.second);
+
+  return existentialSig;
+}
+
 CanGenericSignature
 ASTContext::getOpenedElementSignature(CanGenericSignature baseGenericSig,
                                       CanGenericTypeParamType shapeClass) {