Merge pull request swiftlang#9178 from slavapestov/anyobject-removal-vol-2

AnyObject removal volume 2

Author: slavapestov

lib/AST/GenericSignatureBuilder.cpp

@@ -2020,11 +2020,13 @@ Type GenericSignatureBuilder::PotentialArchetype::getTypeInContext(
   Type superclass = representative->getSuperclass();
   if (superclass && superclass->hasTypeParameter()) {
     if (representative->RecursiveSuperclassType) {
-      superclass = ErrorType::get(superclass);
+      superclass = Type();
     } else {
       superclass = genericEnv->mapTypeIntoContext(
                                               superclass,
                                               builder.getLookupConformanceFn());
+      if (superclass->is<ErrorType>())
+        superclass = Type();
 
       // We might have recursively recorded the archetype; if so, return early.
       // FIXME: This should be detectable before we end up building archetypes.

lib/AST/Type.cpp

@@ -889,16 +889,20 @@ Type TypeBase::getRValueInstanceType() {
 
 /// \brief Collect the protocols in the existential type T into the given
 /// vector.
-static void addProtocols(Type T, SmallVectorImpl<ProtocolDecl *> &Protocols,
-                         Type &Superclass) {
+static void addProtocols(Type T,
+                         SmallVectorImpl<ProtocolDecl *> &Protocols,
+                         Type &Superclass,
+                         bool &HasExplicitAnyObject) {
   if (auto Proto = T->getAs<ProtocolType>()) {
     Protocols.push_back(Proto->getDecl());
     return;
   }
 
   if (auto PC = T->getAs<ProtocolCompositionType>()) {
+    if (PC->hasExplicitAnyObject())
+      HasExplicitAnyObject = true;
     for (auto P : PC->getMembers())
-      addProtocols(P, Protocols, Superclass);
+      addProtocols(P, Protocols, Superclass, HasExplicitAnyObject);
     return;
   }
 
@@ -2554,6 +2558,8 @@ CanArchetypeType ArchetypeType::getNew(
                                    SmallVectorImpl<ProtocolDecl *> &ConformsTo,
                                    Type Superclass,
                                    LayoutConstraint Layout) {
+  assert(!Superclass || Superclass->getClassOrBoundGenericClass());
+
   // Gather the set of protocol declarations to which this archetype conforms.
   ProtocolType::canonicalizeProtocols(ConformsTo);
 
@@ -2574,6 +2580,7 @@ ArchetypeType::getNew(const ASTContext &Ctx,
                       SmallVectorImpl<ProtocolDecl *> &ConformsTo,
                       Type Superclass,
                       LayoutConstraint Layout) {
+  assert(!Superclass || Superclass->getClassOrBoundGenericClass());
   assert(genericEnvironment && "missing generic environment for archetype");
 
   // Gather the set of protocol declarations to which this archetype conforms.
@@ -2780,12 +2787,16 @@ Type ProtocolCompositionType::get(const ASTContext &C,
   Type Superclass;
   SmallVector<ProtocolDecl *, 4> Protocols;
   for (Type t : Members) {
-    addProtocols(t, Protocols, Superclass);
+    addProtocols(t, Protocols, Superclass, HasExplicitAnyObject);
   }
 
   // Minimize the set of protocols composed together.
   ProtocolType::canonicalizeProtocols(Protocols);
 
+  // The presence of a superclass constraint makes AnyObject redundant.
+  if (Superclass)
+    HasExplicitAnyObject = false;
+
   // If one protocol remains with no further constraints, its nominal
   // type is the canonical type.
   if (Protocols.size() == 1 && !Superclass && !HasExplicitAnyObject)
@@ -2803,8 +2814,7 @@ Type ProtocolCompositionType::get(const ASTContext &C,
                  });
 
   // TODO: Canonicalize away HasExplicitAnyObject if it is implied
-  // by one of our member protocols or the presence of a superclass
-  // constraint.
+  // by one of our member protocols.
   return build(C, CanTypes, HasExplicitAnyObject);
 }
 

lib/PrintAsObjC/PrintAsObjC.cpp

@@ -53,8 +53,7 @@ static bool isNSObjectOrAnyHashable(ASTContext &ctx, Type type) {
            classDecl->getModuleContext()->getName() == ctx.Id_ObjectiveC;
   }
   if (auto nomDecl = type->getAnyNominal()) {
-    return nomDecl->getName() == ctx.getIdentifier("AnyHashable") &&
-      nomDecl->getModuleContext() == ctx.getStdlibModule();
+    return nomDecl == ctx.getAnyHashableDecl();
   }
 
   return false;
@@ -1996,7 +1995,8 @@ class ModuleWriter {
 
     if (otherModule == &M)
       return false;
-    if (otherModule->isStdlibModule())
+    if (otherModule->isStdlibModule() ||
+        otherModule->isBuiltinModule())
       return true;
     // Don't need a module for SIMD types in C.
     if (otherModule->getName() == M.getASTContext().Id_simd)

lib/Sema/MiscDiagnostics.cpp

@@ -1469,53 +1469,46 @@ bool TypeChecker::getDefaultGenericArgumentsString(
   genericParamText << "<";
 
   auto printGenericParamSummary =
-      [&](const GenericTypeParamType *genericParamTy) {
+      [&](GenericTypeParamType *genericParamTy) {
     const GenericTypeParamDecl *genericParam = genericParamTy->getDecl();
     if (Type result = getPreferredType(genericParam)) {
       result.print(genericParamText);
       return;
     }
 
-    ArrayRef<ProtocolDecl *> protocols =
-        genericParam->getConformingProtocols();
+    auto contextTy = typeDecl->mapTypeIntoContext(genericParamTy);
+    if (auto archetypeTy = contextTy->getAs<ArchetypeType>()) {
+      SmallVector<Type, 2> members;
 
-    Type superclass = genericParam->getSuperclass();
-    if (superclass && !superclass->hasError()) {
-      if (protocols.empty()) {
-        superclass.print(genericParamText);
-        return;
+      bool hasExplicitAnyObject = archetypeTy->requiresClass();
+      if (auto superclass = archetypeTy->getSuperclass()) {
+        hasExplicitAnyObject = false;
+        members.push_back(superclass);
       }
 
-      genericParamText << "<#" << genericParam->getName() << ": ";
-      superclass.print(genericParamText);
-      for (const ProtocolDecl *proto : protocols) {
-        if (proto->isSpecificProtocol(KnownProtocolKind::AnyObject))
-          continue;
-        genericParamText << " & " << proto->getName();
+      for (auto proto : archetypeTy->getConformsTo()) {
+        members.push_back(proto->getDeclaredType());
+        if (proto->requiresClass())
+          hasExplicitAnyObject = false;
       }
-      genericParamText << "#>";
-      return;
-    }
 
-    if (protocols.empty()) {
-      genericParamText << Context.Id_Any;
-      return;
-    }
+      if (hasExplicitAnyObject)
+        members.push_back(typeDecl->getASTContext().getAnyObjectType());
+
+      auto type = ProtocolCompositionType::get(typeDecl->getASTContext(),
+                                               members, hasExplicitAnyObject);
+
+      if (type->isObjCExistentialType() || type->isAny()) {
+        genericParamText << type;
+        return;
+      }
 
-    if (protocols.size() == 1 &&
-        (protocols.front()->isObjC() ||
-         protocols.front()->isSpecificProtocol(KnownProtocolKind::AnyObject))) {
-      genericParamText << protocols.front()->getName();
+      genericParamText << "<#" << genericParam->getName() << ": ";
+      genericParamText << type << "#>";
       return;
     }
 
-    genericParamText << "<#" << genericParam->getName() << ": ";
-    interleave(protocols,
-               [&](const ProtocolDecl *proto) {
-                 genericParamText << proto->getName();
-               },
-               [&] { genericParamText << " & "; });
-    genericParamText << "#>";
+    genericParamText << contextTy;
   };
 
   interleave(typeDecl->getInnermostGenericParamTypes(),