[AST] Switch ProtocolDecl::requiresClass() over to decl-based resolution.

Resolving whether a protocol is class-bound only requires declaration-based
resolution (not the full type checker), so switch over to those APIs.

Author: DougGregor

include/swift/AST/NameLookup.h

@@ -356,18 +356,23 @@ void lookupInModule(ModuleDecl *module, ModuleDecl::AccessPathTy accessPath,
 /// "inherited" by the given declaration at a particular position in the
 /// list of "inherited" types.
 ///
-/// Add anything we find to the
+/// Add anything we find to the \c result vector. If we come across the
+/// AnyObject type, set \c anyObject true.
 void getDirectlyInheritedNominalTypeDecls(
     llvm::PointerUnion<TypeDecl *, ExtensionDecl *> decl,
     unsigned i,
-    llvm::SmallVectorImpl<std::pair<SourceLoc, NominalTypeDecl *>> &result);
+    llvm::SmallVectorImpl<std::pair<SourceLoc, NominalTypeDecl *>> &result,
+    bool &anyObject);
 
 /// Retrieve the set of nominal type declarations that are directly
 /// "inherited" by the given declaration, looking through typealiases
 /// and splitting out the components of compositions.
+///
+/// If we come across the AnyObject type, set \c anyObject true.
 SmallVector<std::pair<SourceLoc, NominalTypeDecl *>, 4>
 getDirectlyInheritedNominalTypeDecls(
-                      llvm::PointerUnion<TypeDecl *, ExtensionDecl *> decl);
+                      llvm::PointerUnion<TypeDecl *, ExtensionDecl *> decl,
+                      bool &anyObject);
 
 } // end namespace swift
 

lib/AST/ConformanceLookupTable.cpp

@@ -490,7 +490,9 @@ void ConformanceLookupTable::addInheritedProtocols(
                           llvm::PointerUnion<TypeDecl *, ExtensionDecl *> decl,
                           ConformanceSource source) {
   // Find all of the protocols in the inheritance list.
-  for (const auto &found : getDirectlyInheritedNominalTypeDecls(decl)) {
+  bool anyObject = false;
+  for (const auto &found :
+          getDirectlyInheritedNominalTypeDecls(decl, anyObject)) {
     if (auto proto = dyn_cast<ProtocolDecl>(found.second))
       addProtocol(proto, found.first, source);
   }

lib/AST/Decl.cpp

@@ -31,6 +31,7 @@
 #include "swift/AST/LazyResolver.h"
 #include "swift/AST/ASTMangler.h"
 #include "swift/AST/Module.h"
+#include "swift/AST/NameLookup.h"
 #include "swift/AST/NameLookupRequests.h"
 #include "swift/AST/ParameterList.h"
 #include "swift/AST/Pattern.h"
@@ -3652,31 +3653,32 @@ bool ProtocolDecl::inheritsFrom(const ProtocolDecl *super) const {
 bool ProtocolDecl::requiresClassSlow() {
   // Set this first to catch (invalid) circular inheritance.
   Bits.ProtocolDecl.RequiresClassValid = true;
+  Bits.ProtocolDecl.RequiresClass = false;
 
   // Quick check: @objc protocols require a class.
-  if (isObjC()) {
-    Bits.ProtocolDecl.RequiresClass = true;
-    return true;
-  }
-
-  // Otherwise, check if the inheritance clause contains a
-  // class-constrained existential.
-  //
-  // FIXME: Use the requirement signature if available.
-  Bits.ProtocolDecl.RequiresClass = false;
-  for (unsigned i : indices(getInherited())) {
-    Type type = getInheritedType(i);
-    assert(type && "Should have type checked inheritance clause by now");
-    if (type->isExistentialType()) {
-      auto layout = type->getExistentialLayout();
-      if (layout.requiresClass()) {
-        Bits.ProtocolDecl.RequiresClass = true;
-        return true;
-      }
-    }
-    if (type->getClassOrBoundGenericClass()) {
-      Bits.ProtocolDecl.RequiresClass = true;
-      return true;
+  if (isObjC())
+    return Bits.ProtocolDecl.RequiresClass = true;
+
+  // Determine the set of nominal types that this protocol inherits.
+  bool anyObject = false;
+  auto allInheritedNominals =
+    getDirectlyInheritedNominalTypeDecls(this, anyObject);
+
+  // Quick check: do we inherit AnyObject?
+  if (anyObject)
+    return Bits.ProtocolDecl.RequiresClass = true;
+
+  // Look through all of the inherited nominals for a superclass or a
+  // class-bound protocol.
+  for (const auto &found : allInheritedNominals) {
+    // Superclass bound.
+    if (isa<ClassDecl>(found.second))
+      return Bits.ProtocolDecl.RequiresClass = true;
+
+    // A protocol that might be class-constrained;
+    if (auto proto = dyn_cast<ProtocolDecl>(found.second)) {
+      if (proto->requiresClass())
+        return Bits.ProtocolDecl.RequiresClass = true;
     }
   }
 

lib/AST/NameLookup.cpp

@@ -1957,7 +1957,8 @@ static TinyPtrVector<NominalTypeDecl *>
 resolveTypeDeclsToNominal(Evaluator &evaluator,
                           ASTContext &ctx,
                           ArrayRef<TypeDecl *> typeDecls,
-                          SmallVectorImpl<ModuleDecl *> &modulesFound) {
+                          SmallVectorImpl<ModuleDecl *> &modulesFound,
+                          bool &anyObject) {
   TinyPtrVector<NominalTypeDecl *> nominalDecls;
 
   for (auto typeDecl : typeDecls) {
@@ -1973,10 +1974,32 @@ resolveTypeDeclsToNominal(Evaluator &evaluator,
         = evaluator(UnderlyingTypeDeclsReferencedRequest{typealias});
       auto underlyingNominalReferences
         = resolveTypeDeclsToNominal(evaluator, ctx, underlyingTypeReferences,
-                                    modulesFound);
+                                    modulesFound, anyObject);
       nominalDecls.insert(nominalDecls.end(),
                           underlyingNominalReferences.begin(),
                           underlyingNominalReferences.end());
+
+      // Recognize Swift.AnyObject directly.
+      if (typealias->getName().is("AnyObject")) {
+        // TypeRepr version: Builtin.AnyObject
+        if (auto typeRepr = typealias->getUnderlyingTypeLoc().getTypeRepr()) {
+          if (auto compound = dyn_cast<CompoundIdentTypeRepr>(typeRepr)) {
+            auto components = compound->getComponents();
+            if (components.size() == 2 &&
+                components[0]->getIdentifier().is("Builtin") &&
+                components[1]->getIdentifier().is("AnyObject")) {
+              anyObject = true;
+            }
+          }
+        }
+
+        // Type version: an empty class-bound existential.
+        if (auto type = typealias->getUnderlyingTypeLoc().getType()) {
+          if (type->isAnyObject())
+            anyObject = true;
+        }
+      }
+
       continue;
     }
 
@@ -2018,8 +2041,10 @@ directReferencesForQualifiedTypeLookup(Evaluator &evaluator,
   // Look through the base types to find something on which we can perform
   // qualified name lookup.
   SmallVector<ModuleDecl *, 2> moduleBaseTypes;
+  bool anyObject = false;
   auto nominalBaseTypes =
-      resolveTypeDeclsToNominal(evaluator, ctx, baseTypes, moduleBaseTypes);
+      resolveTypeDeclsToNominal(evaluator, ctx, baseTypes, moduleBaseTypes,
+                                anyObject);
 
   DirectlyReferencedTypeDecls result;
   auto addResults = [&result](ArrayRef<ValueDecl *> found){
@@ -2241,9 +2266,10 @@ ClassDecl *SuperclassDeclRequest::evaluate(Evaluator &evaluator,
 
     // Resolve those type declarations to nominal type declarations.
     SmallVector<ModuleDecl *, 2> modulesFound;
+    bool anyObject = false;
     auto inheritedNominalTypes
       = resolveTypeDeclsToNominal(evaluator, subject->getASTContext(),
-                                  inheritedTypes, modulesFound);
+                                  inheritedTypes, modulesFound, anyObject);
 
     // Look for a class declaration.
     for (auto inheritedNominal : inheritedNominalTypes) {
@@ -2273,15 +2299,18 @@ NominalTypeDecl *ExtendedNominalRequest::evaluate(Evaluator &evaluator,
 
   // Resolve those type declarations to nominal type declarations.
   SmallVector<ModuleDecl *, 2> modulesFound;
+  bool anyObject = false;
   auto nominalTypes
-    = resolveTypeDeclsToNominal(evaluator, ctx, referenced, modulesFound);
+    = resolveTypeDeclsToNominal(evaluator, ctx, referenced, modulesFound,
+                                anyObject);
   return nominalTypes.empty() ? nullptr : nominalTypes.front();
 }
 
 void swift::getDirectlyInheritedNominalTypeDecls(
     llvm::PointerUnion<TypeDecl *, ExtensionDecl *> decl,
     unsigned i,
-    llvm::SmallVectorImpl<std::pair<SourceLoc, NominalTypeDecl *>> &result) {
+    llvm::SmallVectorImpl<std::pair<SourceLoc, NominalTypeDecl *>> &result,
+    bool &anyObject) {
   auto typeDecl = decl.dyn_cast<TypeDecl *>();
   auto extDecl = decl.dyn_cast<ExtensionDecl *>();
 
@@ -2294,7 +2323,8 @@ void swift::getDirectlyInheritedNominalTypeDecls(
   // Resolve those type declarations to nominal type declarations.
   SmallVector<ModuleDecl *, 2> modulesFound;
   auto nominalTypes
-    = resolveTypeDeclsToNominal(ctx.evaluator, ctx, referenced, modulesFound);
+    = resolveTypeDeclsToNominal(ctx.evaluator, ctx, referenced, modulesFound,
+                                anyObject);
 
   // Dig out the source location
   // FIXME: This is a hack. We need cooperation from
@@ -2313,7 +2343,8 @@ void swift::getDirectlyInheritedNominalTypeDecls(
 
 SmallVector<std::pair<SourceLoc, NominalTypeDecl *>, 4>
 swift::getDirectlyInheritedNominalTypeDecls(
-                        llvm::PointerUnion<TypeDecl *, ExtensionDecl *> decl) {
+                        llvm::PointerUnion<TypeDecl *, ExtensionDecl *> decl,
+                        bool &anyObject) {
   auto typeDecl = decl.dyn_cast<TypeDecl *>();
   auto extDecl = decl.dyn_cast<ExtensionDecl *>();
 
@@ -2322,7 +2353,7 @@ swift::getDirectlyInheritedNominalTypeDecls(
                                    : extDecl->getInherited().size();
   SmallVector<std::pair<SourceLoc, NominalTypeDecl *>, 4> result;
   for (unsigned i : range(numInherited)) {
-    getDirectlyInheritedNominalTypeDecls(decl, i, result);
+    getDirectlyInheritedNominalTypeDecls(decl, i, result, anyObject);
   }
 
   return result;