AST: Introduce primitive AnyObject type

Add a 'hasExplicitAnyObject()' bit to ProtocolCompositionType
to represent canonical composition types containing '& AnyObject'.

Serialize this bit and take it into account when building
ExistentialLayouts.

Rename ProtocolCompositionType::getProtocols() to getMembers()
since it can contain classes now, and update a few usages that
need further attention with FIXMEs or asserts.

For now, nothing actually constructs these types, and they will
trigger arounds asserts. Upcoming patches will introduce support
for this.

Author: slavapestov

include/swift/AST/Types.h

@@ -325,6 +325,15 @@ class alignas(1 << TypeAlignInBits) TypeBase {
   };
   enum { NumAnyMetatypeTypeBits = NumTypeBaseBits + 2 };
   static_assert(NumAnyMetatypeTypeBits <= 32, "fits in an unsigned");
+
+  struct ProtocolCompositionTypeBitfields {
+    unsigned : NumTypeBaseBits;
+    /// Whether we have an explicitly-stated class constraint not
+    /// implied by any of our members.
+    unsigned HasExplicitAnyObject : 1;
+  };
+  enum { NumProtocolCompositionTypeBits = NumTypeBaseBits + 1 };
+  static_assert(NumProtocolCompositionTypeBits <= 32, "fits in an unsigned");
 
   union {
     TypeBaseBitfields TypeBaseBits;
@@ -334,6 +343,7 @@ class alignas(1 << TypeAlignInBits) TypeBase {
     ArchetypeTypeBitfields ArchetypeTypeBits;
     SILFunctionTypeBitfields SILFunctionTypeBits;
     AnyMetatypeTypeBitfields AnyMetatypeTypeBits;
+    ProtocolCompositionTypeBitfields ProtocolCompositionTypeBits;
   };
 
 protected:
@@ -3662,44 +3672,66 @@ END_CAN_TYPE_WRAPPER(ProtocolType, NominalType)
 /// protocol, then the canonical type is that protocol type. Otherwise, it is
 /// a composition of the protocols in that list.
 class ProtocolCompositionType : public TypeBase, public llvm::FoldingSetNode {
-  ArrayRef<Type> Protocols;
+  ArrayRef<Type> Members;
 
 public:
   /// \brief Retrieve an instance of a protocol composition type with the
-  /// given set of protocols.
-  static Type get(const ASTContext &C, ArrayRef<Type> Protocols);
+  /// given set of members.
+  static Type get(const ASTContext &C, ArrayRef<Type> Members,
+                  bool HasExplicitAnyObject);
 
-  /// \brief Retrieve the set of protocols composed to create this type.
-  ArrayRef<Type> getProtocols() const { return Protocols; }
+  /// \brief Retrieve the set of members composed to create this type.
+  ///
+  /// For non-canonical types, this can contain classes, protocols and
+  /// protocol compositions in any order. There can be at most one unique
+  /// class constraint, either stated directly or as recursive member.
+  ///
+  /// In canonical types, this list will contain the superclass first if
+  /// any, followed by zero or more protocols in a canonical sorted order,
+  /// minimized to remove duplicates or protocols implied by inheritance.
+  ///
+  /// Note that the list of members is not sufficient to uniquely identify
+  /// a protocol composition type; you also have to look at
+  /// hasExplicitAnyObject().
+  ArrayRef<Type> getMembers() const { return Members; }
 
   void Profile(llvm::FoldingSetNodeID &ID) {
-    Profile(ID, Protocols);
+    Profile(ID, Members, hasExplicitAnyObject());
   }
-  static void Profile(llvm::FoldingSetNodeID &ID, ArrayRef<Type> Protocols);
+  static void Profile(llvm::FoldingSetNodeID &ID,
+                      ArrayRef<Type> Members,
+                      bool HasExplicitAnyObject);
 
-  /// True if one or more of the protocols is class.
+  /// True if the composition requires the concrete conforming type to
+  /// be a class, either via a directly-stated superclass constraint or
+  /// one of its member protocols being class-constrained.
   bool requiresClass();
-  
+
+  /// True if the class requirement is stated directly via '& AnyObject'.
+  bool hasExplicitAnyObject() {
+    return ProtocolCompositionTypeBits.HasExplicitAnyObject;
+  }
+
   // Implement isa/cast/dyncast/etc.
   static bool classof(const TypeBase *T) {
     return T->getKind() == TypeKind::ProtocolComposition;
   }
 
 private:
   static ProtocolCompositionType *build(const ASTContext &C,
-                                        ArrayRef<Type> Protocols);
+                                        ArrayRef<Type> Members,
+                                        bool HasExplicitAnyObject);
 
-  ProtocolCompositionType(const ASTContext *ctx, ArrayRef<Type> protocols,
+  ProtocolCompositionType(const ASTContext *ctx, ArrayRef<Type> members,
+                          bool hasExplicitAnyObject,
                           RecursiveTypeProperties properties)
     : TypeBase(TypeKind::ProtocolComposition, /*Context=*/ctx,
                properties),
-      Protocols(protocols) { }
+      Members(members) {
+    ProtocolCompositionTypeBits.HasExplicitAnyObject = hasExplicitAnyObject;
+  }
 };
 BEGIN_CAN_TYPE_WRAPPER(ProtocolCompositionType, Type)
-  /// In the canonical representation, these are all ProtocolTypes.
-  CanTypeArrayRef getProtocols() const {
-    return CanTypeArrayRef(getPointer()->getProtocols());
-  }
 END_CAN_TYPE_WRAPPER(ProtocolCompositionType, Type)
 
 /// LValueType - An l-value is a handle to a physical object.  The

include/swift/Serialization/ModuleFormat.h

@@ -54,7 +54,7 @@ const uint16_t VERSION_MAJOR = 0;
 /// in source control, you should also update the comment to briefly
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
-const uint16_t VERSION_MINOR = 333; // Last change: AST constant_string_literal
+const uint16_t VERSION_MINOR = 334; // Last change: AnyObject bit in ProtocolCompositionType
 
 using DeclID = PointerEmbeddedInt<unsigned, 31>;
 using DeclIDField = BCFixed<31>;
@@ -660,6 +660,7 @@ namespace decls_block {
 
   using ProtocolCompositionTypeLayout = BCRecordLayout<
     PROTOCOL_COMPOSITION_TYPE,
+    BCFixed<1>,          // has AnyObject constraint
     BCArray<TypeIDField> // protocols
   >;
 

lib/AST/ASTContext.cpp

@@ -415,7 +415,8 @@ ASTContext::ASTContext(LangOptions &langOpts, SearchPathOptions &SearchPathOpts,
     TheUnresolvedType(new (*this, AllocationArena::Permanent)
                       UnresolvedType(*this)),
     TheEmptyTupleType(TupleType::get(ArrayRef<TupleTypeElt>(), *this)),
-    TheAnyType(ProtocolCompositionType::get(*this, ArrayRef<Type>())),
+    TheAnyType(ProtocolCompositionType::get(*this, ArrayRef<Type>(),
+                                            /*hasExplicitAnyObject=*/false)),
     TheNativeObjectType(new (*this, AllocationArena::Permanent)
                            BuiltinNativeObjectType(*this)),
     TheBridgeObjectType(new (*this, AllocationArena::Permanent)
@@ -2834,15 +2835,16 @@ void ClassType::Profile(llvm::FoldingSetNodeID &ID, ClassDecl *D, Type Parent) {
 }
 
 ProtocolCompositionType *
-ProtocolCompositionType::build(const ASTContext &C, ArrayRef<Type> Protocols) {
+ProtocolCompositionType::build(const ASTContext &C, ArrayRef<Type> Members,
+                               bool HasExplicitAnyObject) {
   // Check to see if we've already seen this protocol composition before.
   void *InsertPos = nullptr;
   llvm::FoldingSetNodeID ID;
-  ProtocolCompositionType::Profile(ID, Protocols);
+  ProtocolCompositionType::Profile(ID, Members, HasExplicitAnyObject);
 
   bool isCanonical = true;
   RecursiveTypeProperties properties;
-  for (Type t : Protocols) {
+  for (Type t : Members) {
     if (!t->isCanonical())
       isCanonical = false;
     properties |= t->getRecursiveProperties();
@@ -2859,7 +2861,8 @@ ProtocolCompositionType::build(const ASTContext &C, ArrayRef<Type> Protocols) {
   auto compTy
     = new (C, arena)
         ProtocolCompositionType(isCanonical ? &C : nullptr,
-                                C.AllocateCopy(Protocols),
+                                C.AllocateCopy(Members),
+                                HasExplicitAnyObject,
                                 properties);
   C.Impl.getArena(arena).ProtocolCompositionTypes
     .InsertNode(compTy, InsertPos);

lib/AST/ASTDumper.cpp

@@ -3075,7 +3075,9 @@ namespace {
     void visitProtocolCompositionType(ProtocolCompositionType *T,
                                       StringRef label) {
       printCommon(T, label, "protocol_composition_type");
-      for (auto proto : T->getProtocols()) {
+      if (T->hasExplicitAnyObject())
+        OS << " any_object";
+      for (auto proto : T->getMembers()) {
         printRec(proto);
       }
       OS << ")";

lib/AST/ASTPrinter.cpp

@@ -3513,9 +3513,12 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
     }
 
     case TypeKind::ProtocolComposition: {
-      // 'Any' and single protocol compositions are simple
+      // 'Any', 'AnyObject' and single protocol compositions are simple
       auto composition = type->getAs<ProtocolCompositionType>();
-      return composition->getProtocols().size() <= 1;
+      auto memberCount = composition->getMembers().size();
+      if (composition->hasExplicitAnyObject())
+        return memberCount == 0;
+      return memberCount <= 1;
     }
 
     default:
@@ -4187,11 +4190,16 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
   }
 
   void visitProtocolCompositionType(ProtocolCompositionType *T) {
-    if (T->getProtocols().empty()) {
-      Printer << "Any";
+    if (T->getMembers().empty()) {
+      if (T->hasExplicitAnyObject())
+        Printer << "AnyObject";
+      else
+        Printer << "Any";
     } else {
-      interleave(T->getProtocols(), [&](Type Proto) { visit(Proto); },
+      interleave(T->getMembers(), [&](Type Ty) { visit(Ty); },
                  [&] { Printer << " & "; });
+      if (T->hasExplicitAnyObject())
+        Printer << " & AnyObject";
     }
   }
 

lib/AST/ASTVerifier.cpp

@@ -18,6 +18,7 @@
 #include "swift/AST/ASTWalker.h"
 #include "swift/AST/AccessScope.h"
 #include "swift/AST/Decl.h"
+#include "swift/AST/ExistentialLayout.h"
 #include "swift/AST/Expr.h"
 #include "swift/AST/ForeignErrorConvention.h"
 #include "swift/AST/GenericEnvironment.h"
@@ -2042,9 +2043,12 @@ class Verifier : public ASTWalker {
       SmallVector<Type, 4> protocolTypes;
       for (auto proto : protocols)
         protocolTypes.push_back(proto->getDeclaredType());
+      auto type = ProtocolCompositionType::get(Ctx, protocolTypes,
+                                               /*hasExplicitAnyObject=*/false);
+      auto layout = type->getExistentialLayout();
       SmallVector<ProtocolDecl *, 4> canonicalProtocols;
-      ProtocolCompositionType::get(Ctx, protocolTypes)
-        ->getExistentialTypeProtocols(canonicalProtocols);
+      for (auto *protoTy : layout.getProtocols())
+        canonicalProtocols.push_back(protoTy->getDecl());
       if (nominalProtocols != canonicalProtocols) {
         dumpRef(decl);
         Out << " doesn't have a complete set of protocols\n";

lib/AST/ConformanceLookupTable.cpp

@@ -17,6 +17,7 @@
 #include "ConformanceLookupTable.h"
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/Decl.h"
+#include "swift/AST/ExistentialLayout.h"
 #include "swift/AST/Module.h"
 #include "swift/AST/ProtocolConformance.h"
 #include "swift/AST/ProtocolConformanceRef.h"
@@ -416,28 +417,6 @@ void ConformanceLookupTable::loadAllConformances(
   }
 }
 
-namespace {
-  /// Visit the protocols referenced by the given type, which was
-  /// uttered at the given location.
-  template<typename AddProtocolFunc>
-  void visitProtocols(Type type, SourceLoc loc, AddProtocolFunc addProtocol) {
-    if (!type) return;
-
-    // Protocol types.
-    if (auto protocol = type->getAs<ProtocolType>()) {
-      addProtocol(protocol->getDecl(), loc);
-      return;
-    }
-
-    // Protocol compositions.
-    if (auto composition = type->getAs<ProtocolCompositionType>()) {
-      for (auto protocol : composition->getProtocols())
-        visitProtocols(protocol, loc, addProtocol);
-      return;
-    }
-  }
-} // end anonymous namespace
-
 bool ConformanceLookupTable::addProtocol(NominalTypeDecl *nominal,
                                          ProtocolDecl *protocol, SourceLoc loc,
                                          ConformanceSource source) {
@@ -492,10 +471,11 @@ void ConformanceLookupTable::addProtocols(NominalTypeDecl *nominal,
   // Visit each of the types in the inheritance list to find
   // protocols.
   for (const auto &entry : inherited) {
-    visitProtocols(entry.getType(), entry.getLoc(),
-                   [&](ProtocolDecl *protocol, SourceLoc loc) {
-                     addProtocol(nominal, protocol, loc, source);
-                   });
+    if (!entry.getType() || !entry.getType()->isExistentialType())
+      continue;
+    auto layout = entry.getType()->getExistentialLayout();
+    for (auto *proto : layout.getProtocols())
+      addProtocol(nominal, proto->getDecl(), entry.getLoc(), source);
   }
 }
 

lib/AST/GenericSignatureBuilder.cpp

@@ -2199,13 +2199,16 @@ static ConstraintResult visitInherited(
   // Local function that (recursively) adds inherited types.
   ConstraintResult result = ConstraintResult::Resolved;
   std::function<void(Type, const TypeRepr *)> visitInherited;
+
+  // FIXME: Should this whole thing use getExistentialLayout() instead?
+
   visitInherited = [&](Type inheritedType, const TypeRepr *typeRepr) {
     // Decompose protocol compositions.
     auto composition = dyn_cast_or_null<CompositionTypeRepr>(typeRepr);
     if (auto compositionType
           = inheritedType->getAs<ProtocolCompositionType>()) {
       unsigned index = 0;
-      for (auto protoType : compositionType->getProtocols()) {
+      for (auto protoType : compositionType->getMembers()) {
         if (composition && index < composition->getTypes().size())
           visitInherited(protoType, composition->getTypes()[index]);
         else

lib/AST/LookupVisibleDecls.cpp

@@ -536,8 +536,8 @@ static void lookupVisibleMemberDeclsImpl(
 
   // If the base is a protocol composition, enumerate members of the protocols.
   if (auto PC = BaseTy->getAs<ProtocolCompositionType>()) {
-    for (auto Proto : PC->getProtocols())
-      lookupVisibleMemberDeclsImpl(Proto, Consumer, CurrDC, LS, Reason,
+    for (auto Member : PC->getMembers())
+      lookupVisibleMemberDeclsImpl(Member, Consumer, CurrDC, LS, Reason,
                                    TypeResolver, Visited);
     return;
   }