Use Type.findIf instead of TypeVisitor to avoid missing parent type

Author: aviralg

lib/Sema/PerformanceHints.cpp

@@ -67,87 +67,56 @@ void checkImplicitCopyReturnType(const ClosureExpr *Closure,
   }
 }
 
-class CheckExistentialAny : public TypeVisitor<CheckExistentialAny, bool> {
-public:
-  static bool inType(Type type) {
-    return CheckExistentialAny().visit(type->getCanonicalType());
-  }
-
-  static void inFunctionReturnType(FuncDecl *FD, DiagnosticEngine &Diags) {
-    Type T = FD->getResultInterfaceType();
-
-    if (inType(T))
-      Diags.diagnose(FD, diag::perf_hint_func_returns_existential_any, FD);
-  }
-
-  static void inClosureReturnType(ClosureExpr *CE, DiagnosticEngine &Diags) {
-    Type T = CE->getResultType();
-
-    if (inType(T))
-      Diags.diagnose(CE->getLoc(),
-                     diag::perf_hint_closure_returns_existential_any);
-  }
-
-  static void inVariableType(const VarDecl *VD, DiagnosticEngine &Diags) {
-    Type T = VD->getInterfaceType();
+bool isExistentialType(Type T) {
+  return dyn_cast<ExistentialType>(T) != nullptr;
+}
 
-    if (inType(T))
-      Diags.diagnose(VD, diag::perf_hint_var_uses_existential_any, VD);
-  }
+bool hasExistentialAnyInType(Type type) {
+  return type->getCanonicalType().findIf(isExistentialType);
+}
 
-  static void inPatternType(const AnyPattern *AP, DiagnosticEngine &Diags) {
-    Type T = AP->getType();
+void checkExistentialAnyInFunctionReturnType(FuncDecl *FD,
+                                             DiagnosticEngine &Diags) {
+  Type T = FD->getResultInterfaceType();
 
-    if (inType(T))
-      Diags.diagnose(AP->getLoc(),
-                     diag::perf_hint_any_pattern_uses_existential_any);
-  }
+  if (hasExistentialAnyInType(T))
+    Diags.diagnose(FD, diag::perf_hint_func_returns_existential_any, FD);
+}
 
-  static void inTypeAlias(const TypeAliasDecl *TAD, DiagnosticEngine &Diags) {
-    Type T = TAD->getUnderlyingType();
+void checkExistentialAnyInClosureReturnType(ClosureExpr *CE,
+                                            DiagnosticEngine &Diags) {
+  Type T = CE->getResultType();
 
-    if (inType(T))
-      Diags.diagnose(TAD->getLoc(),
-                     diag::perf_hint_typealias_uses_existential_any, TAD);
-  }
+  if (hasExistentialAnyInType(T))
+    Diags.diagnose(CE->getLoc(),
+                   diag::perf_hint_closure_returns_existential_any);
+}
 
-  bool visitExistentialType(ExistentialType *ET) {
-    return true;
-  }
+void checkExistentialAnyInVariableType(const VarDecl *VD,
+                                       DiagnosticEngine &Diags) {
+  Type T = VD->getInterfaceType();
 
-  bool visitTupleType(TupleType *TT) {
-    for (const auto &element : TT->getElements()) {
-      if (visit(element.getType())) {
-        return true;
-      }
-    }
-    return false;
-  }
+  if (hasExistentialAnyInType(T))
+    Diags.diagnose(VD, diag::perf_hint_var_uses_existential_any, VD);
+}
 
-  bool visitBoundGenericType(BoundGenericType *BGT) {
-    // Check generic arguments (e.g., Array<any Protocol>)
-    for (Type arg : BGT->getGenericArgs()) {
-      if (visit(arg)) {
-        return true;
-      }
-    }
-    return false;
-  }
+void checkExistentialAnyInPatternType(const AnyPattern *AP,
+                                      DiagnosticEngine &Diags) {
+  Type T = AP->getType();
 
-  bool visitFunctionType(FunctionType *FT) {
-    for (const auto &param : FT->getParams()) {
-      if (visit(param.getPlainType()->getCanonicalType())) {
-        return true;
-      }
-    }
+  if (hasExistentialAnyInType(T))
+    Diags.diagnose(AP->getLoc(),
+                   diag::perf_hint_any_pattern_uses_existential_any);
+}
 
-    return visit(FT->getResult()->getCanonicalType());
-  }
+void checkExistentialAnyInTypeAlias(const TypeAliasDecl *TAD,
+                                    DiagnosticEngine &Diags) {
+  Type T = TAD->getUnderlyingType();
 
-  bool visitType(TypeBase *T) {
-    return false;
-  }
-};
+  if (hasExistentialAnyInType(T))
+    Diags.diagnose(TAD->getLoc(),
+                   diag::perf_hint_typealias_uses_existential_any, TAD);
+}
 
 /// Produce performance hint diagnostics for a SourceFile.
 class PerformanceHintDiagnosticWalker final : public ASTWalker {
@@ -166,7 +135,7 @@ class PerformanceHintDiagnosticWalker final : public ASTWalker {
       return Action::SkipNode(P);
 
     if (const AnyPattern *AP = dyn_cast<AnyPattern>(P)) {
-      CheckExistentialAny::inPatternType(AP, Ctx.Diags);
+      checkExistentialAnyInPatternType(AP, Ctx.Diags);
     }
 
     return Action::Continue(P);
@@ -189,7 +158,7 @@ class PerformanceHintDiagnosticWalker final : public ASTWalker {
         "Traversing implicit expressions is disabled in the pre-walk visitor");
 
     if (auto Closure = dyn_cast<ClosureExpr>(E)) {
-      CheckExistentialAny::inClosureReturnType(Closure, Ctx.Diags);
+      checkExistentialAnyInClosureReturnType(Closure, Ctx.Diags);
     }
 
     return Action::Continue(E);
@@ -202,9 +171,9 @@ class PerformanceHintDiagnosticWalker final : public ASTWalker {
     if (const FuncDecl *FD = dyn_cast<FuncDecl>(D)) {
       checkImplicitCopyReturnType(FD, Ctx.Diags);
     } else if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
-      CheckExistentialAny::inVariableType(VD, Ctx.Diags);
+      checkExistentialAnyInVariableType(VD, Ctx.Diags);
     } else if (const TypeAliasDecl *TAD = dyn_cast<TypeAliasDecl>(D)) {
-      CheckExistentialAny::inTypeAlias(TAD, Ctx.Diags);
+      checkExistentialAnyInTypeAlias(TAD, Ctx.Diags);
     }
 
     return Action::Continue();
@@ -216,7 +185,7 @@ class PerformanceHintDiagnosticWalker final : public ASTWalker {
         "Traversing implicit declarations is disabled in the pre-walk visitor");
 
     if (auto *FD = dyn_cast<FuncDecl>(D)) {
-      CheckExistentialAny::inFunctionReturnType(FD, Ctx.Diags);
+      checkExistentialAnyInFunctionReturnType(FD, Ctx.Diags);
     }
 
     return Action::Continue();