[NFC][Sema] Rename checkUnsupportedProtocolType to checkExistentialTypes.

Author: hborla

lib/Sema/MiscDiagnostics.cpp

@@ -3361,7 +3361,7 @@ static void checkSwitch(ASTContext &ctx, const SwitchStmt *stmt) {
   // We want to warn about "case .Foo, .Bar where 1 != 100:" since the where
   // clause only applies to the second case, and this is surprising.
   for (auto cs : stmt->getCases()) {
-    TypeChecker::checkUnsupportedProtocolType(ctx, cs);
+    TypeChecker::checkExistentialTypes(ctx, cs);
 
     // The case statement can have multiple case items, each can have a where.
     // If we find a "where", and there is a preceding item without a where, and
@@ -4841,7 +4841,7 @@ void swift::performSyntacticExprDiagnostics(const Expr *E,
 void swift::performStmtDiagnostics(const Stmt *S, DeclContext *DC) {
   auto &ctx = DC->getASTContext();
 
-  TypeChecker::checkUnsupportedProtocolType(ctx, const_cast<Stmt *>(S));
+  TypeChecker::checkExistentialTypes(ctx, const_cast<Stmt *>(S));
 
   if (auto switchStmt = dyn_cast<SwitchStmt>(S))
     checkSwitch(ctx, switchStmt);

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -1696,7 +1696,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
 
     DeclVisitor<DeclChecker>::visit(decl);
 
-    TypeChecker::checkUnsupportedProtocolType(decl);
+    TypeChecker::checkExistentialTypes(decl);
 
     if (auto VD = dyn_cast<ValueDecl>(decl)) {
       auto &Context = getASTContext();

lib/Sema/TypeCheckType.cpp

@@ -3945,15 +3945,15 @@ Type TypeChecker::substMemberTypeWithBase(ModuleDecl *module,
 
 namespace {
 
-class UnsupportedProtocolVisitor
-  : public TypeReprVisitor<UnsupportedProtocolVisitor>, public ASTWalker
+class ExistentialTypeVisitor
+  : public TypeReprVisitor<ExistentialTypeVisitor>, public ASTWalker
 {
   ASTContext &Ctx;
   bool checkStatements;
   bool hitTopStmt;
 
 public:
-  UnsupportedProtocolVisitor(ASTContext &ctx, bool checkStatements)
+  ExistentialTypeVisitor(ASTContext &ctx, bool checkStatements)
     : Ctx(ctx), checkStatements(checkStatements), hitTopStmt(false) { }
 
   bool walkToTypeReprPre(TypeRepr *T) override {
@@ -4008,60 +4008,60 @@ class UnsupportedProtocolVisitor
 
 } // end anonymous namespace
 
-void TypeChecker::checkUnsupportedProtocolType(Decl *decl) {
+void TypeChecker::checkExistentialTypes(Decl *decl) {
   if (!decl || decl->isInvalid())
     return;
 
   auto &ctx = decl->getASTContext();
   if (auto *protocolDecl = dyn_cast<ProtocolDecl>(decl)) {
-    checkUnsupportedProtocolType(ctx, protocolDecl->getTrailingWhereClause());
+    checkExistentialTypes(ctx, protocolDecl->getTrailingWhereClause());
   } else if (auto *genericDecl = dyn_cast<GenericTypeDecl>(decl)) {
-    checkUnsupportedProtocolType(ctx, genericDecl->getGenericParams());
-    checkUnsupportedProtocolType(ctx, genericDecl->getTrailingWhereClause());
+    checkExistentialTypes(ctx, genericDecl->getGenericParams());
+    checkExistentialTypes(ctx, genericDecl->getTrailingWhereClause());
   } else if (auto *assocType = dyn_cast<AssociatedTypeDecl>(decl)) {
-    checkUnsupportedProtocolType(ctx, assocType->getTrailingWhereClause());
+    checkExistentialTypes(ctx, assocType->getTrailingWhereClause());
   } else if (auto *extDecl = dyn_cast<ExtensionDecl>(decl)) {
-    checkUnsupportedProtocolType(ctx, extDecl->getTrailingWhereClause());
+    checkExistentialTypes(ctx, extDecl->getTrailingWhereClause());
   } else if (auto *subscriptDecl = dyn_cast<SubscriptDecl>(decl)) {
-    checkUnsupportedProtocolType(ctx, subscriptDecl->getGenericParams());
-    checkUnsupportedProtocolType(ctx, subscriptDecl->getTrailingWhereClause());
+    checkExistentialTypes(ctx, subscriptDecl->getGenericParams());
+    checkExistentialTypes(ctx, subscriptDecl->getTrailingWhereClause());
   } else if (auto *funcDecl = dyn_cast<AbstractFunctionDecl>(decl)) {
     if (!isa<AccessorDecl>(funcDecl)) {
-      checkUnsupportedProtocolType(ctx, funcDecl->getGenericParams());
-      checkUnsupportedProtocolType(ctx, funcDecl->getTrailingWhereClause());
+      checkExistentialTypes(ctx, funcDecl->getGenericParams());
+      checkExistentialTypes(ctx, funcDecl->getTrailingWhereClause());
     }
   }
 
   if (isa<TypeDecl>(decl) || isa<ExtensionDecl>(decl))
     return;
 
-  UnsupportedProtocolVisitor visitor(ctx, /*checkStatements=*/false);
+  ExistentialTypeVisitor visitor(ctx, /*checkStatements=*/false);
   decl->walk(visitor);
 }
 
-void TypeChecker::checkUnsupportedProtocolType(ASTContext &ctx, Stmt *stmt) {
+void TypeChecker::checkExistentialTypes(ASTContext &ctx, Stmt *stmt) {
   if (!stmt)
     return;
 
-  UnsupportedProtocolVisitor visitor(ctx, /*checkStatements=*/true);
+  ExistentialTypeVisitor visitor(ctx, /*checkStatements=*/true);
   stmt->walk(visitor);
 }
 
-void TypeChecker::checkUnsupportedProtocolType(
+void TypeChecker::checkExistentialTypes(
     ASTContext &ctx, TrailingWhereClause *whereClause) {
   if (whereClause == nullptr)
     return;
 
-  UnsupportedProtocolVisitor visitor(ctx, /*checkStatements=*/false);
+  ExistentialTypeVisitor visitor(ctx, /*checkStatements=*/false);
   visitor.visitRequirements(whereClause->getRequirements());
 }
 
-void TypeChecker::checkUnsupportedProtocolType(
+void TypeChecker::checkExistentialTypes(
     ASTContext &ctx, GenericParamList *genericParams) {
   if (genericParams  == nullptr)
     return;
 
-  UnsupportedProtocolVisitor visitor(ctx, /*checkStatements=*/false);
+  ExistentialTypeVisitor visitor(ctx, /*checkStatements=*/false);
   visitor.visitRequirements(genericParams->getRequirements());
 }
 

lib/Sema/TypeChecker.h

@@ -245,21 +245,21 @@ Type getOptionalType(SourceLoc loc, Type elementType);
 Expr *resolveDeclRefExpr(UnresolvedDeclRefExpr *UDRE, DeclContext *Context,
                          bool replaceInvalidRefsWithErrors);
 
-/// Check for unsupported protocol types in the given declaration.
-void checkUnsupportedProtocolType(Decl *decl);
+/// Check for invalid existential types in the given declaration.
+void checkExistentialTypes(Decl *decl);
 
-/// Check for unsupported protocol types in the given statement.
-void checkUnsupportedProtocolType(ASTContext &ctx, Stmt *stmt);
+/// Check for invalid existential types in the given statement.
+void checkExistentialTypes(ASTContext &ctx, Stmt *stmt);
 
-/// Check for unsupported protocol types in the given generic requirement
+/// Check for invalid existential types in the given generic requirement
 /// list.
-void checkUnsupportedProtocolType(ASTContext &ctx,
-                                  TrailingWhereClause *whereClause);
+void checkExistentialTypes(ASTContext &ctx,
+                           TrailingWhereClause *whereClause);
 
-/// Check for unsupported protocol types in the given generic requirement
+/// Check for invalid existential types in the given generic requirement
 /// list.
-void checkUnsupportedProtocolType(ASTContext &ctx,
-                                  GenericParamList *genericParams);
+void checkExistentialTypes(ASTContext &ctx,
+                           GenericParamList *genericParams);
 
 /// Substitute the given base type into the type of the given nested type,
 /// producing the effective type that the nested type will have.