swiftlang · slavapestov · May 2, 2017 · May 1, 2017 · Apr 28, 2017 · Apr 28, 2017
diff --git a/include/swift/AST/ExistentialLayout.h b/include/swift/AST/ExistentialLayout.h
@@ -28,8 +28,7 @@ namespace swift {
 
 struct ExistentialLayout {
   ExistentialLayout() {
-    requiresClass = false;
-    requiresClassImplied = false;
+    hasExplicitAnyObject = false;
     containsNonObjCProtocol = false;
     singleProtocol = nullptr;
   }
@@ -40,13 +39,8 @@ struct ExistentialLayout {
   /// 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 the existential contains an explicit '& AnyObject' constraint.
+  bool hasExplicitAnyObject : 1;
 
   /// Whether any protocol members are non-@objc.
   bool containsNonObjCProtocol : 1;
@@ -55,9 +49,16 @@ struct ExistentialLayout {
 
   bool isObjC() const {
     // FIXME: Does the superclass have to be @objc?
-    return requiresClass && !containsNonObjCProtocol;
+    return ((superclass ||
+             hasExplicitAnyObject ||
+             getProtocols().size() > 0)
+            && !containsNonObjCProtocol);
   }
 
+  /// Whether the existential requires a class, either via an explicit
+  /// '& AnyObject' member or because of a superclass or protocol constraint.
+  bool requiresClass() const;
+
   // Does this existential contain the Error protocol?
   bool isExistentialWithError(ASTContext &ctx) const;
 

diff --git a/lib/AST/ASTMangler.cpp b/lib/AST/ASTMangler.cpp
@@ -680,7 +680,7 @@ void ASTMangler::appendType(Type type) {
       if (layout.superclass) {
         appendType(layout.superclass);
         return appendOperator("Xc");
-      } else if (layout.requiresClass & !layout.requiresClassImplied) {
+      } else if (layout.hasExplicitAnyObject) {
         return appendOperator("Xl");
       }
       return appendOperator("p");

diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
@@ -21,6 +21,7 @@
 #include "swift/AST/ASTWalker.h"
 #include "swift/AST/DiagnosticEngine.h"
 #include "swift/AST/DiagnosticsSema.h"
+#include "swift/AST/ExistentialLayout.h"
 #include "swift/AST/Expr.h"
 #include "swift/AST/ForeignErrorConvention.h"
 #include "swift/AST/GenericEnvironment.h"
@@ -2883,25 +2884,31 @@ bool ProtocolDecl::inheritsFrom(const ProtocolDecl *super) const {
 }
 
 bool ProtocolDecl::requiresClassSlow() {
-  ProtocolDeclBits.RequiresClass =
-    walkInheritedProtocols([&](ProtocolDecl *proto) {
-      // If the 'requires class' bit is valid, we don't need to search any
-      // further.
-      if (proto->ProtocolDeclBits.RequiresClassValid) {
-        // If this protocol has a class requirement, we're done.
-        if (proto->ProtocolDeclBits.RequiresClass)
-          return TypeWalker::Action::Stop;
-
-        return TypeWalker::Action::SkipChildren;
-      }
+  // Set this first to catch (invalid) circular inheritance.
+  ProtocolDeclBits.RequiresClassValid = true;
 
-      // Quick check: @objc indicates that it requires a class.
-      if (proto->getAttrs().hasAttribute<ObjCAttr>() || proto->isObjC())
-        return TypeWalker::Action::Stop;
+  // Quick check: @objc protocols require a class.
+  if (isObjC()) {
+    ProtocolDeclBits.RequiresClass = true;
+    return true;
+  }
 
-      // Keep looking.
-      return TypeWalker::Action::Continue;
-    });
+  // Otherwise, check if the inheritance clause contains a
+  // class-constrained existential.
+  //
+  // FIXME: Use the requirement signature if available.
+  ProtocolDeclBits.RequiresClass = false;
+  for (auto inherited : getInherited()) {
+    auto type = inherited.getType();
+    assert(type && "Should have type checked inheritance clause by now");
+    if (type->isExistentialType()) {
+      auto layout = type->getExistentialLayout();
+      if (layout.requiresClass()) {
+        ProtocolDeclBits.RequiresClass = true;
+        return true;
+      }
+    }
+  }
 
   return ProtocolDeclBits.RequiresClass;
 }

diff --git a/lib/AST/DiagnosticEngine.cpp b/lib/AST/DiagnosticEngine.cpp
@@ -322,8 +322,19 @@ static bool isInterestingTypealias(Type type) {
     return false;
   if (type->is<BuiltinType>())
     return false;
+
+  auto underlyingTy = aliasTy->getDecl()->getUnderlyingTypeLoc().getType();
+
+  // A typealias that directly points at Builtin.AnyObject is not
+  // 'interesting', since it is in fact the AnyObject typealias in
+  // the standard library.
+  if (underlyingTy->isAnyObject() &&
+      isa<ProtocolCompositionType>(underlyingTy.getPointer()))
+    return false;
+
   if (aliasTy->getDecl()->isCompatibilityAlias())
-    return isInterestingTypealias(aliasTy->getSinglyDesugaredType());
+    return isInterestingTypealias(underlyingTy);
+
   return true;
 }
 

diff --git a/lib/AST/LayoutConstraint.cpp b/lib/AST/LayoutConstraint.cpp
@@ -60,7 +60,7 @@ StringRef LayoutConstraintInfo::getName(LayoutConstraintKind Kind) {
   case LayoutConstraintKind::UnknownLayout:
     return "_UnknownLayout";
   case LayoutConstraintKind::Class:
-    return "_Class";
+    return "AnyObject";
   case LayoutConstraintKind::NativeClass:
     return "_NativeClass";
   case LayoutConstraintKind::RefCountedObject:

diff --git a/lib/AST/LookupVisibleDecls.cpp b/lib/AST/LookupVisibleDecls.cpp
@@ -471,11 +471,6 @@ static void lookupVisibleProtocolMemberDecls(
     Type BaseTy, ProtocolType *PT, VisibleDeclConsumer &Consumer,
     const DeclContext *CurrDC, LookupState LS, DeclVisibilityKind Reason,
     LazyResolver *TypeResolver, VisitedSet &Visited) {
-  if (PT->getDecl()->isSpecificProtocol(KnownProtocolKind::AnyObject)) {
-    // Handle AnyObject in a special way.
-    doDynamicLookup(Consumer, CurrDC, LS, TypeResolver);
-    return;
-  }
   if (!Visited.insert(PT->getDecl()).second)
     return;
 
@@ -527,6 +522,12 @@ static void lookupVisibleMemberDeclsImpl(
     return;
   }
 
+  // If the base is AnyObject, we are doing dynamic lookup.
+  if (BaseTy->isAnyObject()) {
+    doDynamicLookup(Consumer, CurrDC, LS, TypeResolver);
+    return;
+  }
+
   // If the base is a protocol, enumerate its members.
   if (ProtocolType *PT = BaseTy->getAs<ProtocolType>()) {
     lookupVisibleProtocolMemberDecls(BaseTy, PT, Consumer, CurrDC, LS, Reason,

diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp
@@ -228,14 +228,7 @@ ExistentialLayout::ExistentialLayout(ProtocolType *type) {
 
   auto *protoDecl = type->getDecl();
 
-  if (protoDecl->requiresClass()) {
-    requiresClass = true;
-    requiresClassImplied = true;
-  } else {
-    requiresClass = false;
-    requiresClassImplied = false;
-  }
-
+  hasExplicitAnyObject = false;
   containsNonObjCProtocol =
     !(protoDecl->isSpecificProtocol(KnownProtocolKind::AnyObject) ||
       protoDecl->isObjC());
@@ -246,26 +239,18 @@ ExistentialLayout::ExistentialLayout(ProtocolType *type) {
 ExistentialLayout::ExistentialLayout(ProtocolCompositionType *type) {
   assert(type->isCanonical());
 
-  requiresClass = type->hasExplicitAnyObject();
-  requiresClassImplied = false;
+  hasExplicitAnyObject = type->hasExplicitAnyObject();
   containsNonObjCProtocol = false;
 
   auto members = type->getMembers();
   if (!members.empty() &&
       isa<ClassDecl>(members[0]->getAnyNominal())) {
     superclass = members[0];
     members = members.slice(1);
-    requiresClass = true;
-    requiresClassImplied = true;
   }
 
   for (auto member : members) {
     auto *protoDecl = member->castTo<ProtocolType>()->getDecl();
-    if (protoDecl->requiresClass()) {
-      requiresClass = true;
-      requiresClassImplied = true;
-    }
-
     containsNonObjCProtocol |=
       !(protoDecl->isSpecificProtocol(KnownProtocolKind::AnyObject) ||
         protoDecl->isObjC());
@@ -291,10 +276,22 @@ ExistentialLayout CanType::getExistentialLayout() {
   return ExistentialLayout(comp);
 }
 
+bool ExistentialLayout::requiresClass() const {
+  if (hasExplicitAnyObject || superclass)
+    return true;
+
+  for (auto proto : getProtocols()) {
+    if (proto->requiresClass())
+      return true;
+  }
+
+  return false;
+}
+
 bool ExistentialLayout::isAnyObject() const {
   // New implementation
   auto protocols = getProtocols();
-  if (requiresClass && !requiresClassImplied && protocols.empty())
+  if (hasExplicitAnyObject && !superclass && protocols.empty())
     return true;
 
   // Old implementation -- FIXME: remove this
@@ -583,7 +580,8 @@ bool TypeBase::isAnyObject() {
 
 bool ExistentialLayout::isErrorExistential() const {
   auto protocols = getProtocols();
-  return (!requiresClass &&
+  return (!hasExplicitAnyObject &&
+          !superclass &&
           protocols.size() == 1 &&
           protocols[0]->getDecl()->isSpecificProtocol(KnownProtocolKind::Error));
 }
@@ -602,7 +600,7 @@ bool ExistentialLayout::isExistentialWithError(ASTContext &ctx) const {
 }
 
 LayoutConstraint ExistentialLayout::getLayoutConstraint() const {
-  if (requiresClass && !requiresClassImplied) {
+  if (hasExplicitAnyObject) {
     return LayoutConstraint::getLayoutConstraint(
       LayoutConstraintKind::Class);
   }
@@ -2768,7 +2766,7 @@ bool ProtocolType::requiresClass() {
 }
 
 bool ProtocolCompositionType::requiresClass() {
-  return getExistentialLayout().requiresClass;
+  return getExistentialLayout().requiresClass();
 }
 
 Type ProtocolCompositionType::get(const ASTContext &C,
@@ -4015,7 +4013,7 @@ bool TypeBase::usesNativeReferenceCounting(ResilienceExpansion resilience) {
   case TypeKind::Protocol:
   case TypeKind::ProtocolComposition: {
     auto layout = getExistentialLayout();
-    assert(layout.requiresClass && "Opaque existentials don't use refcounting");
+    assert(layout.requiresClass() && "Opaque existentials don't use refcounting");
     if (layout.superclass)
       return layout.superclass->usesNativeReferenceCounting(resilience);
     return ::doesOpaqueClassUseNativeReferenceCounting(type->getASTContext());

diff --git a/lib/Demangling/NodePrinter.cpp b/lib/Demangling/NodePrinter.cpp
@@ -278,8 +278,10 @@ class NodePrinter {
     case Node::Kind::ProtocolList:
       return Node->getChild(0)->getNumChildren() <= 1;
 
-    case Node::Kind::ProtocolListWithClass:
     case Node::Kind::ProtocolListWithAnyObject:
+      return Node->getChild(0)->getChild(0)->getNumChildren() == 0;
+
+    case Node::Kind::ProtocolListWithClass:
     case Node::Kind::Allocator:
     case Node::Kind::ArgumentTuple:
     case Node::Kind::AssociatedTypeMetadataAccessor:
@@ -628,7 +630,8 @@ class NodePrinter {
 static bool isExistentialType(NodePointer node) {
   return (node->getKind() == Node::Kind::ExistentialMetatype ||
           node->getKind() == Node::Kind::ProtocolList ||
-          node->getKind() == Node::Kind::ProtocolListWithClass);
+          node->getKind() == Node::Kind::ProtocolListWithClass ||
+          node->getKind() == Node::Kind::ProtocolListWithAnyObject);
 }
 
 /// Print the relevant parameters and return the new index.
@@ -1362,7 +1365,10 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
     NodePointer superclass = Node->getChild(1);
     print(superclass);
     Printer << " & ";
-    printChildren(protocols, " & ");
+    if (protocols->getNumChildren() < 1)
+      return nullptr;
+    NodePointer type_list = protocols->getChild(0);
+    printChildren(type_list, " & ");
     return nullptr;
   }
   case Node::Kind::ProtocolListWithAnyObject: {
@@ -1371,12 +1377,14 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
     NodePointer protocols = Node->getChild(0);
     if (protocols->getNumChildren() < 1)
       return nullptr;
-    if (protocols->getChild(0)->getNumChildren() == 0) {
-      Printer << "AnyObject";
-    } else {
-      printChildren(protocols->getChild(0), " & ");
-      Printer << " & AnyObject";
+    NodePointer type_list = protocols->getChild(0);
+    if (type_list->getNumChildren() > 0) {
+      printChildren(type_list, " & ");
+      Printer << " & ";
     }
+    if (Options.QualifyEntities)
+      Printer << "Swift.";
+    Printer << "AnyObject";
     return nullptr;
   }
   case Node::Kind::AssociatedType:

diff --git a/lib/IRGen/GenCast.cpp b/lib/IRGen/GenCast.cpp
@@ -521,7 +521,7 @@ void irgen::emitScalarExistentialDowncast(IRGenFunction &IGF,
   SmallVector<llvm::Value*, 4> objcProtos;
   SmallVector<llvm::Value*, 4> witnessTableProtos;
 
-  bool hasClassConstraint = layout.requiresClass;
+  bool hasClassConstraint = layout.requiresClass();
   bool hasClassConstraintByProtocol = false;
 
   bool hasSuperclassConstraint = bool(layout.superclass);

diff --git a/lib/IRGen/GenExistential.cpp b/lib/IRGen/GenExistential.cpp
@@ -1418,7 +1418,7 @@ static const TypeInfo *createExistentialTypeInfo(IRGenModule &IGM, CanType T) {
 
   // If the existential is class, lower it to a class
   // existential representation.
-  if (layout.requiresClass) {
+  if (layout.requiresClass()) {
     // If we're not using the Objective-C runtime, we can use the
     // native reference counting entry points.
     ReferenceCounting refcounting = getReferenceCountingForType(IGM, T);

diff --git a/lib/IRGen/GenMeta.cpp b/lib/IRGen/GenMeta.cpp
@@ -951,7 +951,7 @@ namespace {
       // Note: ProtocolClassConstraint::Class is 0, ::Any is 1.
       auto classConstraint =
         llvm::ConstantInt::get(IGF.IGM.Int1Ty,
-                               !layout.requiresClass);
+                               !layout.requiresClass());
       llvm::Value *superclassConstraint =
         llvm::ConstantPointerNull::get(IGF.IGM.TypeMetadataPtrTy);
       if (layout.superclass) {

diff --git a/lib/Parse/ParseSIL.cpp b/lib/Parse/ParseSIL.cpp
@@ -1538,7 +1538,7 @@ collectExistentialConformances(Parser &P, CanType conformingType, SourceLoc loc,
                                CanType protocolType) {
   auto layout = protocolType.getExistentialLayout();
 
-  if (layout.requiresClass) {
+  if (layout.requiresClass()) {
     if (!conformingType->mayHaveSuperclass() &&
         !conformingType->isObjCExistentialType()) {
       P.diagnose(loc, diag::sil_not_class, conformingType);

diff --git a/lib/SIL/SILType.cpp b/lib/SIL/SILType.cpp
@@ -506,7 +506,7 @@ SILType::getPreferredExistentialRepresentation(SILModule &M,
 
   // A class-constrained protocol composition can adopt the conforming
   // class reference directly.
-  if (layout.requiresClass)
+  if (layout.requiresClass())
     return ExistentialRepresentation::Class;
 
   // Otherwise, we need to use a fixed-sized buffer.
@@ -539,7 +539,7 @@ SILType::canUseExistentialRepresentation(SILModule &M,
 
     // A class-constrained composition uses ClassReference representation;
     // otherwise, we use a fixed-sized buffer.
-    if (layout.requiresClass)
+    if (layout.requiresClass())
       return repr == ExistentialRepresentation::Class;
 
     return repr == ExistentialRepresentation::Opaque;

diff --git a/lib/SIL/SILVerifier.cpp b/lib/SIL/SILVerifier.cpp
@@ -2707,10 +2707,10 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
             "init_existential instruction must have the "
             "right number of conformances");
 
-    if (layout.requiresClass) {
+    if (layout.requiresClass()) {
       require(concreteType->mayHaveSuperclass() ||
               (concreteType.isExistentialType() &&
-               concreteType.getExistentialLayout().requiresClass),
+               concreteType.getExistentialLayout().requiresClass()),
               "init_existential of class existential with non-class type");
     }