Merge pull request #8650 from slavapestov/subclass-existentials

Preliminary Sema and AST support for subclass existentials (SE-0156)

Author: slavapestov

include/swift/AST/ConcreteDeclRef.h

@@ -93,8 +93,12 @@ class ConcreteDeclRef {
   /// given declaration. This array will be copied into the ASTContext by the
   /// constructor.
   ConcreteDeclRef(ASTContext &ctx, ValueDecl *decl,
-                  SubstitutionList substitutions)
-    : Data(SpecializedDeclRef::create(ctx, decl, substitutions)) { }
+                  SubstitutionList substitutions) {
+    if (substitutions.empty())
+      Data = decl;
+    else
+      Data = SpecializedDeclRef::create(ctx, decl, substitutions);
+  }
 
   /// Determine whether this declaration reference refers to anything.
   explicit operator bool() const { return !Data.isNull(); }

include/swift/AST/DiagnosticsParse.def

@@ -699,9 +699,9 @@ ERROR(tuple_type_multiple_labels,none,
 
 // Protocol Types
 ERROR(expected_rangle_protocol,PointsToFirstBadToken,
-      "expected '>' to complete protocol composition type", ())
+      "expected '>' to complete protocol-constrained type", ())
 ERROR(disallowed_protocol_composition,PointsToFirstBadToken,
-      "protocol composition is neither allowed nor needed here", ())
+      "protocol-constrained type is neither allowed nor needed here", ())
 
 WARNING(deprecated_protocol_composition,none,
         "'protocol<...>' composition syntax is deprecated; join the protocols using '&'", ())
@@ -1361,7 +1361,7 @@ ERROR(unexpected_class_constraint,none,
 NOTE(suggest_anyobject,none,
      "did you mean to constrain %0 with the 'AnyObject' protocol?", (Identifier))
 ERROR(expected_generics_type_restriction,none,
-      "expected a type name or protocol composition restricting %0",
+      "expected a class type or protocol-constrained type restricting %0",
       (Identifier))
 ERROR(requires_single_equal,none,
       "use '==' for same-type requirements rather than '='", ())

include/swift/AST/DiagnosticsSema.def

@@ -1552,14 +1552,19 @@ ERROR(circular_protocol_def,none,
       "circular protocol inheritance %0", (StringRef))
 NOTE(protocol_here,none,
      "protocol %0 declared here", (Identifier))
-ERROR(protocol_composition_not_protocol,none,
-      "non-protocol type %0 cannot be used within a protocol composition", (Type))
 ERROR(objc_protocol_inherits_non_objc_protocol,none,
       "@objc protocol %0 cannot refine non-@objc protocol %1", (Type, Type))
 WARNING(protocol_composition_with_postfix,none,
-        "protocol composition with postfix '%0' is ambiguous "
+        "protocol-constrained type with postfix '%0' is ambiguous "
         "and will be rejected in future version of Swift", (StringRef))
 
+ERROR(invalid_protocol_composition_member,none,
+      "non-protocol, non-class type %0 cannot be used within a "
+      "protocol-constrained type", (Type))
+ERROR(protocol_composition_one_class,none,
+      "protocol-constrained type cannot contain class %0 because it already "
+      "contains class %1", (Type, Type))
+
 ERROR(requires_conformance_nonprotocol,none,
       "type %0 constrained to non-protocol type %1", (TypeLoc, TypeLoc))
 ERROR(requires_not_suitable_archetype,none,
@@ -3090,7 +3095,7 @@ NOTE(not_objc_empty_protocol_composition,none,
 NOTE(not_objc_protocol,none,
      "protocol %0 is not '@objc'", (Type))
 NOTE(not_objc_error_protocol_composition,none,
-     "protocol composition involving 'Error' cannot be represented "
+     "protocol-constrained type containing 'Error' cannot be represented "
      "in Objective-C", ())
 NOTE(not_objc_empty_tuple,none,
       "empty tuple type cannot be represented in Objective-C", ())

include/swift/AST/ExistentialLayout.h

@@ -0,0 +1,80 @@
+//===--- ExistentialLayout.h - Existential type decomposition ---*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the ExistentialLayout struct.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_EXISTENTIAL_LAYOUT_H
+#define SWIFT_EXISTENTIAL_LAYOUT_H
+
+#include "swift/AST/ASTContext.h"
+#include "swift/AST/Type.h"
+#include "llvm/ADT/SmallVector.h"
+
+namespace swift {
+  class ProtocolDecl;
+  class ProtocolType;
+  class ProtocolCompositionType;
+
+struct ExistentialLayout {
+  ExistentialLayout() {
+    requiresClass = false;
+    requiresClassImplied = false;
+    containsNonObjCProtocol = false;
+    singleProtocol = nullptr;
+  }
+
+  ExistentialLayout(ProtocolType *type);
+  ExistentialLayout(ProtocolCompositionType *type);
+
+  /// The superclass constraint, if any.
+  Type superclass;
+
+  /// Whether the existential requires a class, either via an explicit
+  /// '& AnyObject' member or because of a superclass or protocol constraint.
+  bool requiresClass : 1;
+
+  /// Whether the class constraint was implied by another constraint and therefore
+  /// does not need to be stated explicitly.
+  bool requiresClassImplied : 1;
+
+  /// Whether any protocol members are non-@objc.
+  bool containsNonObjCProtocol : 1;
+
+  bool isAnyObject() const;
+
+  bool isObjC() const {
+    // FIXME: Does the superclass have to be @objc?
+    return requiresClass && !containsNonObjCProtocol;
+  }
+
+  bool isExistentialWithError(ASTContext &ctx) const;
+
+  ArrayRef<ProtocolType *> getProtocols() const {
+    if (singleProtocol)
+      return ArrayRef<ProtocolType *>{&singleProtocol, 1};
+    return multipleProtocols;
+  }
+
+private:
+  // Inline storage for 'protocols' member above when computing
+  // layout of a single ProtocolType
+  ProtocolType *singleProtocol;
+
+  /// Zero or more protocol constraints.
+  ArrayRef<ProtocolType *> multipleProtocols;
+};
+
+}
+
+#endif  // SWIFT_EXISTENTIAL_LAYOUT_H

include/swift/AST/Type.h

@@ -51,6 +51,7 @@ class SubstitutionMap;
 class TypeBase;
 class Type;
 class TypeWalker;
+struct ExistentialLayout;
 
 /// \brief Type substitution mapping from substitutable types to their
 /// replacements.
@@ -410,16 +411,15 @@ class CanType : public Type {
   /// Given that this type is an existential, return its
   /// protocols in a canonical order.
   void getExistentialTypeProtocols(
-                                SmallVectorImpl<ProtocolDecl *> &protocols) {
-    return getExistentialTypeProtocolsImpl(*this, protocols);
-  }
+      SmallVectorImpl<ProtocolDecl *> &protocols);
 
   /// Given that this type is any kind of existential, return its
   /// protocols in a canonical order.
   void getAnyExistentialTypeProtocols(
-                                SmallVectorImpl<ProtocolDecl *> &protocols) {
-    return getAnyExistentialTypeProtocolsImpl(*this, protocols);
-  }
+      SmallVectorImpl<ProtocolDecl *> &protocols);
+
+  /// Break an existential down into a set of constraints.
+  ExistentialLayout getExistentialLayout();
 
   /// Is this an ObjC-compatible existential type?
   bool isObjCExistentialType() const {

include/swift/AST/Types.h

@@ -584,6 +584,9 @@ class alignas(1 << TypeAlignInBits) TypeBase {
   /// its list of protocols.
   void getAnyExistentialTypeProtocols(SmallVectorImpl<ProtocolDecl *> &protocols);
 
+  /// Break an existential down into a set of constraints.
+  ExistentialLayout getExistentialLayout();
+
   /// Determines the element type of a known *UnsafeMutablePointer
   /// variant, or returns null if the type is not a pointer.
   Type getAnyPointerElementType(PointerTypeKind &PTK);
@@ -3602,7 +3605,7 @@ class ProtocolType : public NominalType, public llvm::FoldingSetNode {
   }
 
   /// True if only classes may conform to the protocol.
-  bool requiresClass() const;
+  bool requiresClass();
 
   // Implement isa/cast/dyncast/etc.
   static bool classof(const TypeBase *T) {
@@ -3669,16 +3672,13 @@ class ProtocolCompositionType : public TypeBase, public llvm::FoldingSetNode {
   /// \brief Retrieve the set of protocols composed to create this type.
   ArrayRef<Type> getProtocols() const { return Protocols; }
 
-  /// \brief Return the protocols of this type in canonical order.
-  void getAnyExistentialTypeProtocols(SmallVectorImpl<ProtocolDecl *> &protos);
-
   void Profile(llvm::FoldingSetNodeID &ID) {
     Profile(ID, Protocols);
   }
   static void Profile(llvm::FoldingSetNodeID &ID, ArrayRef<Type> Protocols);
 
   /// True if one or more of the protocols is class.
-  bool requiresClass() const;
+  bool requiresClass();
 
   // Implement isa/cast/dyncast/etc.
   static bool classof(const TypeBase *T) {
@@ -3689,10 +3689,11 @@ class ProtocolCompositionType : public TypeBase, public llvm::FoldingSetNode {
   static ProtocolCompositionType *build(const ASTContext &C,
                                         ArrayRef<Type> Protocols);
 
-  ProtocolCompositionType(const ASTContext *Ctx, ArrayRef<Type> Protocols)
-    : TypeBase(TypeKind::ProtocolComposition, /*Context=*/Ctx,
-               RecursiveTypeProperties()),
-      Protocols(Protocols) { }
+  ProtocolCompositionType(const ASTContext *ctx, ArrayRef<Type> protocols,
+                          RecursiveTypeProperties properties)
+    : TypeBase(TypeKind::ProtocolComposition, /*Context=*/ctx,
+               properties),
+      Protocols(protocols) { }
 };
 BEGIN_CAN_TYPE_WRAPPER(ProtocolCompositionType, Type)
   /// In the canonical representation, these are all ProtocolTypes.
@@ -4555,9 +4556,14 @@ inline bool TypeBase::mayHaveSuperclass() {
   if (getClassOrBoundGenericClass())
     return true;
 
+  // FIXME: requiresClass() is not the same as having an explicit superclass;
+  // is this wrong?
   if (auto archetype = getAs<ArchetypeType>())
     return (bool)archetype->requiresClass();
 
+  if (isExistentialType())
+    return (bool)getSuperclass(nullptr);
+
   return is<DynamicSelfType>();
 }
 

include/swift/Basic/LangOptions.h

@@ -162,6 +162,9 @@ namespace swift {
     /// optimized custom allocator, so that memory debugging tools can be used.
     bool UseMalloc = false;
 
+    /// \brief Enable classes to appear in protocol composition types.
+    bool EnableExperimentalSubclassExistentials = false;
+
     /// \brief Enable experimental property behavior feature.
     bool EnableExperimentalPropertyBehaviors = false;
 

include/swift/Option/FrontendOptions.td

@@ -267,6 +267,10 @@ def enable_experimental_deserialization_recovery :
   Flag<["-"], "enable-experimental-deserialization-recovery">,
   HelpText<"Attempt to recover from missing xrefs (etc) in swiftmodules">;
 
+def enable_experimental_subclass_existentials : Flag<["-"],
+  "enable-experimental-subclass-existentials">,
+  HelpText<"Enable classes to appear in protocol composition types">;
+
 def enable_cow_existentials : Flag<["-"], "enable-cow-existentials">,
   HelpText<"Enable the copy-on-write existential implementation">;
 

lib/AST/ASTContext.cpp

@@ -17,6 +17,7 @@
 #include "swift/AST/ASTContext.h"
 #include "ForeignRepresentationInfo.h"
 #include "swift/Strings.h"
+#include "swift/AST/ExistentialLayout.h"
 #include "swift/AST/GenericSignatureBuilder.h"
 #include "swift/AST/ConcreteDeclRef.h"
 #include "swift/AST/DiagnosticEngine.h"
@@ -269,6 +270,7 @@ struct ASTContext::Implementation {
     llvm::FoldingSet<UnboundGenericType> UnboundGenericTypes;
     llvm::FoldingSet<BoundGenericType> BoundGenericTypes;
     llvm::FoldingSet<ProtocolType> ProtocolTypes;
+    llvm::FoldingSet<ProtocolCompositionType> ProtocolCompositionTypes;
     llvm::FoldingSet<LayoutConstraintInfo> LayoutConstraints;
 
     /// The set of normal protocol conformances.
@@ -311,7 +313,6 @@ struct ASTContext::Implementation {
   llvm::DenseMap<CanType, SILBlockStorageType *> SILBlockStorageTypes;
   llvm::FoldingSet<SILBoxType> SILBoxTypes;
   llvm::DenseMap<BuiltinIntegerWidth, BuiltinIntegerType*> IntegerTypes;
-  llvm::FoldingSet<ProtocolCompositionType> ProtocolCompositionTypes;
   llvm::FoldingSet<BuiltinVectorType> BuiltinVectorTypes;
   llvm::FoldingSet<GenericSignature> GenericSignatures;
   llvm::FoldingSet<DeclName::CompoundDeclName> CompoundNames;
@@ -2797,23 +2798,31 @@ ProtocolCompositionType::build(const ASTContext &C, ArrayRef<Type> Protocols) {
   void *InsertPos = nullptr;
   llvm::FoldingSetNodeID ID;
   ProtocolCompositionType::Profile(ID, Protocols);
-  if (ProtocolCompositionType *Result
-        = C.Impl.ProtocolCompositionTypes.FindNodeOrInsertPos(ID, InsertPos))
-    return Result;
 
   bool isCanonical = true;
+  RecursiveTypeProperties properties;
   for (Type t : Protocols) {
     if (!t->isCanonical())
       isCanonical = false;
+    properties |= t->getRecursiveProperties();
   }
 
   // Create a new protocol composition type.
-  ProtocolCompositionType *New
-    = new (C, AllocationArena::Permanent)
+  auto arena = getArena(properties);
+
+  if (auto compTy
+      = C.Impl.getArena(arena).ProtocolCompositionTypes
+          .FindNodeOrInsertPos(ID, InsertPos))
+    return compTy;
+
+  auto compTy
+    = new (C, arena)
         ProtocolCompositionType(isCanonical ? &C : nullptr,
-                                C.AllocateCopy(Protocols));
-  C.Impl.ProtocolCompositionTypes.InsertNode(New, InsertPos);
-  return New;
+                                C.AllocateCopy(Protocols),
+                                properties);
+  C.Impl.getArena(arena).ProtocolCompositionTypes
+    .InsertNode(compTy, InsertPos);
+  return compTy;
 }
 
 ReferenceStorageType *ReferenceStorageType::get(Type T, Ownership ownership,
@@ -3454,19 +3463,22 @@ CanArchetypeType ArchetypeType::getOpened(Type existential,
     knownID = UUID::fromTime();
   }
 
-  llvm::SmallVector<ProtocolDecl *, 4> conformsTo;
-  assert(existential->isExistentialType());
-  existential->getExistentialTypeProtocols(conformsTo);
-  Type superclass = existential->getSuperclass(nullptr);
+  auto layout = existential->getExistentialLayout();
+
+  SmallVector<ProtocolDecl *, 2> protos;
+  for (auto proto : layout.getProtocols())
+    protos.push_back(proto->getDecl());
 
   auto arena = AllocationArena::Permanent;
   void *mem = ctx.Allocate(
       totalSizeToAlloc<ProtocolDecl *, Type, LayoutConstraint, UUID>(
-        conformsTo.size(), superclass ? 1 : 0, 0, 1),
+      protos.size(), layout.superclass ? 1 : 0, 0, 1),
       alignof(ArchetypeType), arena);
 
+  // FIXME: Pass in class layout constraint
   auto result =
-      ::new (mem) ArchetypeType(ctx, existential, conformsTo, superclass,
+      ::new (mem) ArchetypeType(ctx, existential,
+                                protos, layout.superclass,
                                 existential->getLayoutConstraint(), *knownID);
   openedExistentialArchetypes[*knownID] = result;
 

lib/AST/Decl.cpp

@@ -2727,16 +2727,16 @@ ProtocolDecl::getInheritedProtocols() const {
   // FIXME: Gather inherited protocols from the "inherited" list.
   // We shouldn't need this, but it shows up in recursive invocations.
   if (!isRequirementSignatureComputed()) {
+    SmallPtrSet<ProtocolDecl *, 4> known;
     for (auto inherited : getInherited()) {
-      SmallPtrSet<ProtocolDecl *, 4> known;
       if (auto type = inherited.getType()) {
-        if (type->isExistentialType()) {
-          SmallVector<ProtocolDecl *, 4> protocols;
-          type->getExistentialTypeProtocols(protocols);
-          for (auto proto : protocols) {
-            if (known.insert(proto).second)
-              result.push_back(proto);
-          }
+        // Only protocols can appear in the inheritance clause
+        // of a protocol -- anything else should get diagnosed
+        // elsewhere.
+        if (auto *protoTy = type->getAs<ProtocolType>()) {
+          auto *protoDecl = protoTy->getDecl();
+          if (known.insert(protoDecl).second)
+            result.push_back(protoDecl);
         }
       }
     }

lib/AST/Expr.cpp

@@ -1321,6 +1321,7 @@ MemberRefExpr::MemberRefExpr(Expr *base, SourceLoc dotLoc,
 
   MemberRefExprBits.Semantics = (unsigned) semantics;
   MemberRefExprBits.IsSuper = false;
+  assert(Member);
 }
 
 Type OverloadSetRefExpr::getBaseType() const {