Add an OpaqueTypeArchetypeType subclass.

Author: jckarter

include/swift/AST/GenericSignature.h

@@ -307,6 +307,10 @@ class alignas(1 << TypeAlignInBits) GenericSignature final
   ///   <t_0_0, t_0_1, t_1_0>
   /// then this will return 0 for t_0_0, 1 for t_0_1, and 2 for t_1_0.
   unsigned getGenericParamOrdinal(GenericTypeParamType *param);
+      
+  /// Get a substitution map that maps all of the generic signature's
+  /// generic parameters to themselves.
+  SubstitutionMap getIdentitySubstitutionMap() const;
 
   static void Profile(llvm::FoldingSetNodeID &ID,
                       TypeArrayView<GenericTypeParamType> genericParams,

include/swift/AST/TypeNodes.def

@@ -133,6 +133,7 @@ TYPE(DynamicSelf, Type)
 ABSTRACT_TYPE(Substitutable, Type)
   ABSTRACT_TYPE(Archetype, SubstitutableType)
     ALWAYS_CANONICAL_TYPE(PrimaryArchetype, ArchetypeType)
+    ALWAYS_CANONICAL_TYPE(OpaqueTypeArchetype, ArchetypeType)
     ALWAYS_CANONICAL_TYPE(OpenedArchetype, ArchetypeType)
     ALWAYS_CANONICAL_TYPE(NestedArchetype, ArchetypeType)
     TYPE_RANGE(Archetype, PrimaryArchetype, NestedArchetype)

include/swift/AST/Types.h

@@ -53,8 +53,10 @@ namespace swift {
   class GenericTypeParamType;
   class GenericParamList;
   class GenericSignature;
+  class GenericSignatureBuilder;
   class Identifier;
   class InOutType;
+  class OpaqueTypeDecl;
   class OpenedArchetypeType;
   enum class ReferenceCounting : uint8_t;
   enum class ResilienceExpansion : unsigned;
@@ -4728,6 +4730,65 @@ class PrimaryArchetypeType final : public ArchetypeType,
 BEGIN_CAN_TYPE_WRAPPER(PrimaryArchetypeType, ArchetypeType)
 END_CAN_TYPE_WRAPPER(PrimaryArchetypeType, ArchetypeType)
 
+/// An archetype that represents an opaque type.
+class OpaqueTypeArchetypeType final : public ArchetypeType,
+    public llvm::FoldingSetNode,
+    private ArchetypeTrailingObjects<OpaqueTypeArchetypeType>
+{
+  friend TrailingObjects;
+  friend ArchetypeType;
+  friend GenericSignatureBuilder;
+
+  /// The declaration that defines the opaque type.
+  OpaqueTypeDecl *OpaqueDecl;
+  /// The substitutions into the interface signature of the opaque type.
+  SubstitutionMap Substitutions;
+  
+  /// The generic signature used to build out this archetype, and its
+  /// nested archetypes.
+  GenericSignature *BoundSignature;
+  
+public:
+  /// Get an opaque archetype representing the underlying type of the given
+  /// opaque type decl.
+  static OpaqueTypeArchetypeType *
+  get(OpaqueTypeDecl *Decl,
+      SubstitutionMap Substitutions);
+  
+  OpaqueTypeDecl *getOpaqueDecl() const {
+    return OpaqueDecl;
+  }
+  SubstitutionMap getSubstitutions() const {
+    return Substitutions;
+  }
+  
+  /// Get the underlying type of the opaque type, if it's known.
+  Type getUnderlyingType() const;
+  
+  static bool classof(const TypeBase *T) {
+    return T->getKind() == TypeKind::OpaqueTypeArchetype;
+  }
+  
+  static void Profile(llvm::FoldingSetNodeID &ID,
+                      OpaqueTypeDecl *OpaqueDecl,
+                      SubstitutionMap Substitutions);
+  
+  void Profile(llvm::FoldingSetNodeID &ID) {
+    Profile(ID, getOpaqueDecl(), getSubstitutions());
+  };
+  
+private:
+  OpaqueTypeArchetypeType(OpaqueTypeDecl *OpaqueDecl,
+                          SubstitutionMap Substitutions,
+                          RecursiveTypeProperties Props,
+                          GenericSignature *BoundSignature,
+                          Type InterfaceType,
+                          ArrayRef<ProtocolDecl*> ConformsTo,
+                          Type Superclass, LayoutConstraint Layout);
+};
+BEGIN_CAN_TYPE_WRAPPER(OpaqueTypeArchetypeType, ArchetypeType)
+END_CAN_TYPE_WRAPPER(OpaqueTypeArchetypeType, ArchetypeType)
+  
 /// An archetype that represents the dynamic type of an opened existential.
 class OpenedArchetypeType final : public ArchetypeType,
     private ArchetypeTrailingObjects<OpenedArchetypeType>
@@ -4834,6 +4895,9 @@ const Type *ArchetypeType::getSubclassTrailingObjects() const {
   if (auto contextTy = dyn_cast<PrimaryArchetypeType>(this)) {
     return contextTy->getTrailingObjects<Type>();
   }
+  if (auto opaqueTy = dyn_cast<OpaqueTypeArchetypeType>(this)) {
+    return opaqueTy->getTrailingObjects<Type>();
+  }
   if (auto openedTy = dyn_cast<OpenedArchetypeType>(this)) {
     return openedTy->getTrailingObjects<Type>();
   }

lib/AST/ASTContext.cpp

@@ -323,6 +323,7 @@ FOR_KNOWN_FOUNDATION_TYPES(CACHE_FOUNDATION_DECL)
     llvm::FoldingSet<BoundGenericType> BoundGenericTypes;
     llvm::FoldingSet<ProtocolCompositionType> ProtocolCompositionTypes;
     llvm::FoldingSet<LayoutConstraintInfo> LayoutConstraints;
+    llvm::FoldingSet<OpaqueTypeArchetypeType> OpaqueArchetypes;
 
     /// The set of function types.
     llvm::FoldingSet<FunctionType> FunctionTypes;
@@ -4177,6 +4178,132 @@ DependentMemberType *DependentMemberType::get(Type base,
   return known;
 }
 
+OpaqueTypeArchetypeType *
+OpaqueTypeArchetypeType::get(OpaqueTypeDecl *Decl,
+                             SubstitutionMap Substitutions) {
+  // TODO: We could attempt to preserve type sugar in the substitution map.
+  Substitutions = Substitutions.getCanonical();
+  
+  // TODO: Eventually an opaque archetype ought to be arbitrarily substitutable
+  // into any generic environment. However, there isn't currently a good way to
+  // do this with GenericSignatureBuilder; in a situation like this:
+  //
+  // __opaque_type Foo<t_0_0: P>: Q // internal signature <t_0_0: P, t_1_0: Q>
+  //
+  // func bar<t_0_0, t_0_1, t_0_2: P>() -> Foo<t_0_2>
+  //
+  // we'd want to feed the GSB constraints to form:
+  //
+  // <t_0_0: P, t_1_0: Q where t_0_0 == t_0_2>
+  //
+  // even though t_0_2 isn't *in* this generic signature; it represents a type
+  // bound elsewhere from some other generic context. If we knew the generic
+  // environment `t_0_2` came from, then maybe we could map it into that context,
+  // but currently we have no way to know that with certainty.
+  //
+  // For now, opaque types cannot propagate across decls; every declaration
+  // with an opaque type has a unique opaque decl. Therefore, the only
+  // expressions involving opaque types ought to be contextualized inside
+  // function bodies, and the only time we need an opaque interface type should
+  // be for the opaque decl itself and the originating decl with the opaque
+  // result type, in which case the interface type mapping is identity and
+  // this problem can be temporarily avoided.
+#ifndef NDEBUG
+  for (unsigned i : indices(Substitutions.getReplacementTypes())) {
+    auto replacement = Substitutions.getReplacementTypes()[i];
+    
+    if (!replacement->hasTypeParameter())
+      continue;
+    
+    auto replacementParam = replacement->getAs<GenericTypeParamType>();
+    if (!replacementParam)
+      llvm_unreachable("opaque types cannot currently be parameterized by non-identity type parameter mappings");
+    
+    assert(i == Decl->getGenericSignature()->getGenericParamOrdinal(replacementParam)
+           && "opaque types cannot currently be parameterized by non-identity type parameter mappings");
+  }
+#endif
+  
+  llvm::FoldingSetNodeID id;
+  Profile(id, Decl, Substitutions);
+  
+  auto &ctx = Decl->getASTContext();
+
+  // An opaque type isn't contextually dependent like other archetypes, so
+  // by itself, it doesn't impose the "Has Archetype" recursive property,
+  // but the substituted types might.
+  RecursiveTypeProperties properties = {};
+  for (auto type : Substitutions.getReplacementTypes()) {
+    properties |= type->getRecursiveProperties();
+  }
+  
+  auto arena = getArena(properties);
+  
+  llvm::FoldingSet<OpaqueTypeArchetypeType> &set
+    = ctx.getImpl().getArena(arena).OpaqueArchetypes;
+  
+  {
+    void *insertPos; // Discarded because the work below may invalidate the
+                     // insertion point inside the folding set
+    if (auto existing = set.FindNodeOrInsertPos(id, insertPos)) {
+      return existing;
+    }
+  }
+  
+  // Create a new opaque archetype.
+  // It lives in an environment in which the interface generic arguments of the
+  // decl have all been same-type-bound to the arguments from our substitution
+  // map.
+  GenericSignatureBuilder builder(ctx);
+  builder.addGenericSignature(Decl->getOpaqueInterfaceGenericSignature());
+  // Same-type-constrain the arguments in the outer signature to their
+  // replacements in the substitution map.
+  if (auto outerSig = Decl->getGenericSignature()) {
+    for (auto outerParam : outerSig->getGenericParams()) {
+      auto boundType = Type(outerParam).subst(Substitutions);
+      builder.addSameTypeRequirement(Type(outerParam), boundType,
+         GenericSignatureBuilder::FloatingRequirementSource::forAbstract(),
+         GenericSignatureBuilder::UnresolvedHandlingKind::GenerateConstraints,
+         [](Type, Type) { llvm_unreachable("error?"); });
+    }
+  }
+  
+  auto signature = std::move(builder)
+    .computeGenericSignature(SourceLoc());
+  
+  auto opaqueInterfaceTy = Decl->getUnderlyingInterfaceType();
+  auto layout = signature->getLayoutConstraint(opaqueInterfaceTy);
+  auto superclass = signature->getSuperclassBound(opaqueInterfaceTy);
+  SmallVector<ProtocolDecl*, 4> protos;
+  for (auto proto : signature->getConformsTo(opaqueInterfaceTy)) {
+    protos.push_back(proto);
+  }
+  
+  auto mem = ctx.Allocate(
+    OpaqueTypeArchetypeType::totalSizeToAlloc<ProtocolDecl *, Type, LayoutConstraint>(
+      protos.size(), superclass ? 1 : 0, layout ? 1 : 0),
+      alignof(OpaqueTypeArchetypeType),
+      arena);
+  
+  auto newOpaque = ::new (mem) OpaqueTypeArchetypeType(Decl, Substitutions,
+                                                    properties,
+                                                    signature,
+                                                    opaqueInterfaceTy,
+                                                    protos, superclass, layout);
+  
+  // Look up the insertion point in the folding set again in case something
+  // invalidated it above.
+  {
+    void *insertPos;
+    auto existing = set.FindNodeOrInsertPos(id, insertPos);
+    (void)existing;
+    assert(!existing && "race to create opaque archetype?!");
+    set.InsertNode(newOpaque, insertPos);
+  }
+  
+  return newOpaque;
+}
+
 CanOpenedArchetypeType OpenedArchetypeType::get(Type existential,
                                                 Optional<UUID> knownID) {
   auto &ctx = existential->getASTContext();

lib/AST/ASTDumper.cpp

@@ -3460,6 +3460,20 @@ namespace {
       printArchetypeNestedTypes(T);
       PrintWithColorRAII(OS, ParenthesisColor) << ')';
     }
+    void visitOpaqueTypeArchetypeType(OpaqueTypeArchetypeType *T,
+                                      StringRef label) {
+      printArchetypeCommon(T, "opaque_type", label);
+      printField("decl", T->getOpaqueDecl()->getNamingDecl()->printRef());
+      if (!T->getSubstitutions().empty()) {
+        OS << '\n';
+        SmallPtrSet<const ProtocolConformance *, 4> Dumped;
+        dumpSubstitutionMapRec(T->getSubstitutions(), OS,
+                               SubstitutionMap::DumpStyle::Full,
+                               Indent + 2, Dumped);
+      }
+      printArchetypeNestedTypes(T);
+      PrintWithColorRAII(OS, ParenthesisColor) << ')';
+    }
 
     void visitGenericTypeParamType(GenericTypeParamType *T, StringRef label) {
       printCommon(label, "generic_type_param_type");

lib/AST/ASTMangler.cpp

@@ -955,6 +955,10 @@ void ASTMangler::appendType(Type type) {
     case TypeKind::NestedArchetype:
       llvm_unreachable("Cannot mangle free-standing archetypes");
 
+    case TypeKind::OpaqueTypeArchetype:
+#warning "todo"
+      llvm_unreachable("TODO");
+      
     case TypeKind::DynamicSelf: {
       auto dynamicSelf = cast<DynamicSelfType>(tybase);
       if (dynamicSelf->getSelfType()->getAnyNominal()) {

lib/AST/ASTPrinter.cpp

@@ -4140,6 +4140,20 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
   void visitPrimaryArchetypeType(PrimaryArchetypeType *T) {
     printArchetypeCommon(T);
   }
+  
+  void visitOpaqueTypeArchetypeType(OpaqueTypeArchetypeType *T) {
+#warning "todo"
+    Printer << "(__opaque " << T->getOpaqueDecl()->getNamingDecl()->printRef();
+    if (!T->getSubstitutions().empty()) {
+      Printer << '<';
+      auto replacements = T->getSubstitutions().getReplacementTypes();
+      interleave(replacements.begin(), replacements.end(),
+                 [&](Type t) { visit(t); },
+                 [&] { Printer << ", "; });
+      Printer << '>';
+    }
+    Printer << ')';
+  }
 
   void visitGenericTypeParamType(GenericTypeParamType *T) {
     if (T->getDecl() == nullptr) {

lib/AST/GenericSignature.cpp

@@ -1029,6 +1029,14 @@ unsigned GenericParamKey::findIndexIn(
   return genericParams.size();
 }
 
+SubstitutionMap GenericSignature::getIdentitySubstitutionMap() const {
+  return SubstitutionMap::get(const_cast<GenericSignature*>(this),
+                              [](SubstitutableType *t) -> Type {
+                                return Type(cast<GenericTypeParamType>(t));
+                              },
+                              MakeAbstractConformanceForGenericType());
+}
+
 unsigned GenericSignature::getGenericParamOrdinal(GenericTypeParamType *param) {
   return GenericParamKey(param->getDepth(), param->getIndex())
     .findIndexIn(getGenericParams());