Type utilities for working with opened existential types.

Swift SVN r27188

Author: DougGregor

include/swift/AST/Types.h

@@ -76,7 +76,7 @@ namespace swift {
 /// on structural types.
 class RecursiveTypeProperties {
 public:
-  enum { BitWidth = 5 };
+  enum { BitWidth = 6 };
 
   /// A single property.
   ///
@@ -99,6 +99,9 @@ class RecursiveTypeProperties {
     /// This type expression contains an LValueType and can be loaded to convert
     /// to an rvalue.
     IsLValue = 0x10,
+
+    /// This type expression contains an opened existential ArchetypeType.
+    HasOpenedExistential = 0x20,
   };
 
 private:
@@ -132,6 +135,10 @@ class RecursiveTypeProperties {
   /// Is a type with these properties an lvalue?
   bool isLValue() const { return Bits & IsLValue; }
 
+  /// Does a type with these properties structurally contain an
+  /// archetype?
+  bool hasOpenedExistential() const { return Bits & HasOpenedExistential; }
+
   /// Returns the set of properties present in either set.
   friend RecursiveTypeProperties operator+(Property lhs, Property rhs) {
     return RecursiveTypeProperties(lhs | rhs);
@@ -365,6 +372,29 @@ class alignas(1 << TypeAlignInBits) TypeBase {
     return getRecursiveProperties().hasArchetype();
   }
 
+  /// Determine whether the type involves an opened existential archetype.
+  bool hasOpenedExistential() const {
+    return getRecursiveProperties().hasOpenedExistential();
+  }
+
+  /// Determine whether the type involves the given opend existential
+  /// archetype.
+  bool hasOpenedExistential(ArchetypeType *opened);
+
+  /// Determine whether the type is an opened existential type.
+  ///
+  /// To determine whether there is an opened existential type
+  /// anywhere in the type, use \c hasOpenedExistential.
+  bool isOpenedExistential();
+
+  /// Retrieve the set of opened existential archetypes that occur
+  /// within this type.
+  void getOpenedExistentials(SmallVectorImpl<ArchetypeType *> &opened);
+
+  /// Erase the given opened existential type by replacing it with its
+  /// existential type throughout the given type.
+  Type eraseOpenedExistential(Module *module, ArchetypeType *opened);
+
   /// \brief Compute and return the set of type variables that occur within this
   /// type.
   ///
@@ -3486,7 +3516,9 @@ class ArchetypeType : public SubstitutableType {
                 ArrayRef<ProtocolDecl *> ConformsTo,
                 Type Superclass, bool isRecursive = false)
     : SubstitutableType(TypeKind::Archetype, &Ctx,
-                        RecursiveTypeProperties::HasArchetype),
+                        RecursiveTypeProperties(
+                          RecursiveTypeProperties::HasArchetype |
+                          RecursiveTypeProperties::HasOpenedExistential)),
       ConformsTo(ConformsTo), Superclass(Superclass),
       ParentOrOpened(Existential.getPointer()),
       isRecursive(isRecursive) { }
@@ -3901,6 +3933,16 @@ inline bool TypeBase::isClassExistentialType() {
   return false;
 }
 
+inline bool TypeBase::isOpenedExistential() {
+  if (!hasOpenedExistential())
+    return false;
+
+  CanType T = getCanonicalType();
+  if (auto archetype = dyn_cast<ArchetypeType>(T))
+    return !archetype->getOpenedExistentialType().isNull();
+  return false;
+}
+
 inline ClassDecl *TypeBase::getClassOrBoundGenericClass() {
   return getCanonicalType().getClassOrBoundGenericClass();
 }

lib/AST/ASTContext.cpp

@@ -2584,7 +2584,7 @@ GenericFunctionType::get(GenericSignature *sig,
   // always materializable.
   checkFunctionRecursiveProperties(input, output);
   RecursiveTypeProperties properties;
-  static_assert(RecursiveTypeProperties::BitWidth == 5,
+  static_assert(RecursiveTypeProperties::BitWidth == 6,
                 "revisit this if you add new recursive type properties");
 
   auto result = new (mem) GenericFunctionType(sig, input, output, info,
@@ -2739,7 +2739,7 @@ CanSILFunctionType SILFunctionType::get(GenericSignature *genericSig,
   // FIXME: If we ever have first-class polymorphic values, we'll need to
   // revisit this.
   RecursiveTypeProperties properties;
-  static_assert(RecursiveTypeProperties::BitWidth == 5,
+  static_assert(RecursiveTypeProperties::BitWidth == 6,
                 "revisit this if you add new recursive type properties");
   if (!genericSig) {
     // Nongeneric SIL functions are dependent if they have dependent argument

lib/AST/Type.cpp

@@ -388,6 +388,53 @@ bool TypeBase::isUnspecializedGeneric() {
   llvm_unreachable("bad TypeKind");
 }
 
+bool TypeBase::hasOpenedExistential(ArchetypeType *opened) {
+  assert(opened->getOpenedExistentialType() &&
+         "not an opened existential type");
+
+  if (!hasOpenedExistential())
+    return false;
+
+  return getCanonicalType().findIf([&](Type type) -> bool {
+    return opened == dyn_cast<ArchetypeType>(type.getPointer());
+  });
+}
+
+void TypeBase::getOpenedExistentials(
+       SmallVectorImpl<ArchetypeType *> &opened) {
+  if (!hasOpenedExistential())
+    return;
+
+  SmallPtrSet<ArchetypeType *, 4> known;
+  getCanonicalType().findIf([&](Type type) -> bool {
+    auto archetype = dyn_cast<ArchetypeType>(type.getPointer());
+    if (!archetype)
+      return false;
+
+    if (!archetype->getOpenedExistentialType())
+      return false;
+
+    if (known.insert(archetype).second)
+      opened.push_back(archetype);
+
+    return false;
+  });
+}
+
+Type TypeBase::eraseOpenedExistential(Module *module,
+                                      ArchetypeType *opened) {
+  assert(opened->getOpenedExistentialType() &&
+         "Not an opened existential type?");
+
+  if (!hasOpenedExistential())
+    return Type(this);
+
+  TypeSubstitutionMap substitutions;
+  substitutions[opened] = opened->getOpenedExistentialType();
+  return Type(this).subst(module, substitutions, false,
+                          getASTContext().getLazyResolver());
+}
+
 void
 TypeBase::getTypeVariables(SmallVectorImpl<TypeVariableType *> &typeVariables) {
   // If we know we don't have any type variables, we're done.