Revert "[NFC, Typechecker] Remove UnsupportedProtocolVisitor and checkUnsupportedProtocolType()"

This reverts commit 15f88e9.

Author: hborla

lib/Sema/MiscDiagnostics.cpp

@@ -3361,6 +3361,8 @@ 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);
+
     // 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
     // if they are on the same source line, then warn.
@@ -4839,6 +4841,8 @@ 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));
+    
   if (auto switchStmt = dyn_cast<SwitchStmt>(S))
     checkSwitch(ctx, switchStmt);
 

lib/Sema/TypeCheckDeclPrimary.cpp

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

lib/Sema/TypeCheckType.cpp

@@ -3925,6 +3925,128 @@ Type TypeChecker::substMemberTypeWithBase(ModuleDecl *module,
   return resultType;
 }
 
+namespace {
+
+class UnsupportedProtocolVisitor
+  : public TypeReprVisitor<UnsupportedProtocolVisitor>, public ASTWalker
+{
+  ASTContext &Ctx;
+  bool checkStatements;
+  bool hitTopStmt;
+    
+public:
+  UnsupportedProtocolVisitor(ASTContext &ctx, bool checkStatements)
+    : Ctx(ctx), checkStatements(checkStatements), hitTopStmt(false) { }
+
+  bool walkToTypeReprPre(TypeRepr *T) override {
+    if (T->isInvalid())
+      return false;
+    if (auto compound = dyn_cast<CompoundIdentTypeRepr>(T)) {
+      // Only visit the last component to check, because nested typealiases in
+      // existentials are okay.
+      visit(compound->getComponentRange().back());
+      return false;
+    }
+    // Arbitrary protocol constraints are OK on opaque types.
+    if (isa<OpaqueReturnTypeRepr>(T))
+      return false;
+    
+    visit(T);
+    return true;
+  }
+
+  std::pair<bool, Stmt*> walkToStmtPre(Stmt *S) override {
+    if (checkStatements && !hitTopStmt) {
+      hitTopStmt = true;
+      return { true, S };
+    }
+
+    return { false, S };
+  }
+
+  bool walkToDeclPre(Decl *D) override {
+    return !checkStatements;
+  }
+
+  void visitTypeRepr(TypeRepr *T) {
+    // Do nothing for all TypeReprs except the ones listed below.
+  }
+
+  void visitIdentTypeRepr(IdentTypeRepr *T) {
+    return;
+  }
+
+  void visitRequirements(ArrayRef<RequirementRepr> reqts) {
+    for (auto reqt : reqts) {
+      if (reqt.getKind() == RequirementReprKind::SameType) {
+        if (auto *repr = reqt.getFirstTypeRepr())
+          repr->walk(*this);
+        if (auto *repr = reqt.getSecondTypeRepr())
+          repr->walk(*this);
+      }
+    }
+  }
+};
+
+} // end anonymous namespace
+
+void TypeChecker::checkUnsupportedProtocolType(Decl *decl) {
+  if (!decl || decl->isInvalid())
+    return;
+
+  auto &ctx = decl->getASTContext();
+  if (auto *protocolDecl = dyn_cast<ProtocolDecl>(decl)) {
+    checkUnsupportedProtocolType(ctx, protocolDecl->getTrailingWhereClause());
+  } else if (auto *genericDecl = dyn_cast<GenericTypeDecl>(decl)) {
+    checkUnsupportedProtocolType(ctx, genericDecl->getGenericParams());
+    checkUnsupportedProtocolType(ctx, genericDecl->getTrailingWhereClause());
+  } else if (auto *assocType = dyn_cast<AssociatedTypeDecl>(decl)) {
+    checkUnsupportedProtocolType(ctx, assocType->getTrailingWhereClause());
+  } else if (auto *extDecl = dyn_cast<ExtensionDecl>(decl)) {
+    checkUnsupportedProtocolType(ctx, extDecl->getTrailingWhereClause());
+  } else if (auto *subscriptDecl = dyn_cast<SubscriptDecl>(decl)) {
+    checkUnsupportedProtocolType(ctx, subscriptDecl->getGenericParams());
+    checkUnsupportedProtocolType(ctx, subscriptDecl->getTrailingWhereClause());
+  } else if (auto *funcDecl = dyn_cast<AbstractFunctionDecl>(decl)) {
+    if (!isa<AccessorDecl>(funcDecl)) {
+      checkUnsupportedProtocolType(ctx, funcDecl->getGenericParams());
+      checkUnsupportedProtocolType(ctx, funcDecl->getTrailingWhereClause());
+    }
+  }
+
+  if (isa<TypeDecl>(decl) || isa<ExtensionDecl>(decl))
+    return;
+
+  UnsupportedProtocolVisitor visitor(ctx, /*checkStatements=*/false);
+  decl->walk(visitor);
+}
+
+void TypeChecker::checkUnsupportedProtocolType(ASTContext &ctx, Stmt *stmt) {
+  if (!stmt)
+    return;
+
+  UnsupportedProtocolVisitor visitor(ctx, /*checkStatements=*/true);
+  stmt->walk(visitor);
+}
+
+void TypeChecker::checkUnsupportedProtocolType(
+    ASTContext &ctx, TrailingWhereClause *whereClause) {
+  if (whereClause == nullptr)
+    return;
+
+  UnsupportedProtocolVisitor visitor(ctx, /*checkStatements=*/false);
+  visitor.visitRequirements(whereClause->getRequirements());
+}
+
+void TypeChecker::checkUnsupportedProtocolType(
+    ASTContext &ctx, GenericParamList *genericParams) {
+  if (genericParams  == nullptr)
+    return;
+
+  UnsupportedProtocolVisitor visitor(ctx, /*checkStatements=*/false);
+  visitor.visitRequirements(genericParams->getRequirements());
+}
+
 Type CustomAttrTypeRequest::evaluate(Evaluator &eval, CustomAttr *attr,
                                      DeclContext *dc,
                                      CustomAttrTypeKind typeKind) const {

lib/Sema/TypeChecker.h

@@ -245,6 +245,22 @@ 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 unsupported protocol types in the given statement.
+void checkUnsupportedProtocolType(ASTContext &ctx, Stmt *stmt);
+
+/// Check for unsupported protocol types in the given generic requirement
+/// list.
+void checkUnsupportedProtocolType(ASTContext &ctx,
+                                  TrailingWhereClause *whereClause);
+
+/// Check for unsupported protocol types in the given generic requirement
+/// list.
+void checkUnsupportedProtocolType(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.
 ///