AST: New getExistentialLayout() method on TypeBase and CanType

This consolidates calculations which need to look at every
protocol in an existential type. Soon we will also have to
deal with superclass constrained existentials, so start
updating call sites that look at all protocols to use the
new ExistentialLayout and correctly handle a class constraint
as well.

Also, eventually I will kill off the AnyObject protocol and
model it as a protocol composition with no protocols or
superclass, but the requiresClass() flag set.

This is not quite modeled this way yet and AnyObject still
exists, but the new abstraction is a step in the right
direction.

Author: slavapestov

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);

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"
@@ -3454,19 +3455,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/Module.cpp

@@ -22,6 +22,7 @@
 #include "swift/AST/ASTWalker.h"
 #include "swift/AST/Builtins.h"
 #include "swift/AST/DiagnosticsSema.h"
+#include "swift/AST/ExistentialLayout.h"
 #include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/LazyResolver.h"
 #include "swift/AST/LinkLibrary.h"
@@ -586,6 +587,7 @@ ModuleDecl::lookupConformance(Type type, ProtocolDecl *protocol,
       }
     }
 
+    // FIXME: This will go away soon.
     if (protocol->isSpecificProtocol(KnownProtocolKind::AnyObject)) {
       if (archetype->requiresClass())
         return ProtocolConformanceRef(protocol);
@@ -605,35 +607,38 @@ ModuleDecl::lookupConformance(Type type, ProtocolDecl *protocol,
   // existential's list of conformances and the existential conforms to
   // itself.
   if (type->isExistentialType()) {
-    SmallVector<ProtocolDecl *, 4> protocols;
-    type->getExistentialTypeProtocols(protocols);
-
-    // Due to an IRGen limitation, witness tables cannot be passed from an
-    // existential to an archetype parameter, so for now we restrict this to
-    // @objc protocols.
-    for (auto proto : protocols) {
-      if (!proto->isObjC() &&
-          !proto->isSpecificProtocol(KnownProtocolKind::AnyObject))
-        return None;
-    }
-
     // If the existential type cannot be represented or the protocol does not
     // conform to itself, there's no point in looking further.
     if (!protocol->existentialConformsToSelf() ||
         !protocol->existentialTypeSupported(resolver))
       return None;
 
-    // Special-case AnyObject, which may not be in the list of conformances.
-    if (protocol->isSpecificProtocol(KnownProtocolKind::AnyObject)) {
-      if (type->isClassExistentialType())
-        return ProtocolConformanceRef(protocol);
+    auto layout = type->getExistentialLayout();
 
+    // Due to an IRGen limitation, witness tables cannot be passed from an
+    // existential to an archetype parameter, so for now we restrict this to
+    // @objc protocols.
+    if (!layout.isObjC())
       return None;
+
+    // Special-case AnyObject, which may not be in the list of conformances.
+    //
+    // FIXME: This is going away soon.
+    if (protocol->isSpecificProtocol(KnownProtocolKind::AnyObject))
+      return ProtocolConformanceRef(protocol);
+
+    // If the existential is class-constrained, the class might conform
+    // concretely.
+    if (layout.superclass) {
+      if (auto result = lookupConformance(layout.superclass, protocol,
+                                          resolver))
+        return result;
     }
 
-    // Look for this protocol within the existential's list of conformances.
-    for (auto proto : protocols) {
-      if (proto == protocol || proto->inheritsFrom(protocol))
+    // Otherwise, the existential might conform abstractly.
+    for (auto proto : layout.getProtocols()) {
+      auto *protoDecl = proto->getDecl();
+      if (protoDecl == protocol || protoDecl->inheritsFrom(protocol))
         return ProtocolConformanceRef(protocol);
     }
 

lib/AST/NameLookup.cpp

@@ -20,6 +20,7 @@
 #include "swift/AST/ASTScope.h"
 #include "swift/AST/ASTVisitor.h"
 #include "swift/AST/DebuggerClient.h"
+#include "swift/AST/ExistentialLayout.h"
 #include "swift/AST/LazyResolver.h"
 #include "swift/AST/Initializer.h"
 #include "swift/AST/ReferencedNameTracker.h"
@@ -1391,6 +1392,8 @@ bool DeclContext::lookupQualified(Type type,
 
     // If we want dynamic lookup and we're searching in the
     // AnyObject protocol, note this for later.
+    //
+    // FIXME: This will go away soon.
     if (options & NL_DynamicLookup) {
       if (auto proto = dyn_cast<ProtocolDecl>(nominal)) {
         if (proto->isSpecificProtocol(KnownProtocolKind::AnyObject))
@@ -1406,28 +1409,29 @@ bool DeclContext::lookupQualified(Type type,
         stack.push_back(proto);
 
     // Look into the superclasses of this archetype.
-    if (auto superclassTy = archetypeTy->getSuperclass()) {
-      if (auto superclassDecl = superclassTy->getAnyNominal()) {
-        if (visited.insert(superclassDecl).second) {
+    if (auto superclassTy = archetypeTy->getSuperclass())
+      if (auto superclassDecl = superclassTy->getAnyNominal())
+        if (visited.insert(superclassDecl).second)
           stack.push_back(superclassDecl);
-        }
-      }
-    }
   }
   // Handle protocol compositions.
   else if (auto compositionTy = type->getAs<ProtocolCompositionType>()) {
-    SmallVector<ProtocolDecl *, 4> protocols;
-    compositionTy->getExistentialTypeProtocols(protocols);
-    for (auto proto : protocols) {
-      if (visited.insert(proto).second) {
-        stack.push_back(proto);
+    auto layout = compositionTy->getExistentialLayout();
 
-        // If we want dynamic lookup and this is the AnyObject
-        // protocol, note this for later.
-        if ((options & NL_DynamicLookup) &&
-            proto->isSpecificProtocol(KnownProtocolKind::AnyObject))
-          wantLookupInAllClasses = true;
-      }
+    if (layout.isAnyObject() &&
+        (options & NL_DynamicLookup))
+      wantLookupInAllClasses = true;
+
+    for (auto proto : layout.getProtocols()) {
+      auto *protoDecl = proto->getDecl();
+      if (visited.insert(protoDecl).second)
+        stack.push_back(protoDecl);
+    }
+
+    if (layout.superclass) {
+      auto *nominalDecl = layout.superclass->getAnyNominal();
+      if (visited.insert(nominalDecl).second)
+        stack.push_back(nominalDecl);
     }
   } else {
     llvm_unreachable("Bad type for qualified lookup");