[Performance Hints] Implement check for existential any

This commit introduces a performance hint check that warns on the use of
existential any in variable declarations, function and closure parameters and
return, and typealiases.

Author: aviralg

include/swift/AST/DiagnosticEngine.h

@@ -48,6 +48,8 @@ namespace swift {
   class FuncDecl;
   class SourceManager;
   class SourceFile;
+  class ParamDecl;
+  class AnyPattern;
 
   /// Enumeration describing all of possible diagnostics.
   ///

include/swift/AST/DiagnosticsSema.def

@@ -8946,6 +8946,30 @@ GROUPED_WARNING(perf_hint_closure_returns_array,ReturnTypeImplicitCopy,DefaultIg
                 "Performance: closure returns a%select{ dictionary|n array}0, leading to implicit copies. "
                 "Consider using an 'inout' parameter instead.", (bool))
 
+GROUPED_WARNING(perf_hint_param_has_existential,PerformanceHints,DefaultIgnore,
+                "Performance: %0 expects existential any, leading to heap allocation, reference counting, "
+                "and dynamic dispatch. Consider using generic constraints or concrete types instead.",
+                (const ParamDecl*))
+GROUPED_WARNING(perf_hint_func_returns_existential,PerformanceHints,DefaultIgnore,
+                "Performance: %0 returns existential any, leading to heap allocation, reference counting, "
+                "and dynamic dispatch. Consider using generic constraints or concrete types instead.",
+                (const FuncDecl*))
+GROUPED_WARNING(perf_hint_closure_returns_existential,PerformanceHints,DefaultIgnore,
+                "Performance: closure returns existential any, leading to heap allocation, reference counting, "
+                "and dynamic dispatch. Consider using generic constraints or concrete types instead.", ())
+GROUPED_WARNING(perf_hint_var_uses_existential,PerformanceHints,DefaultIgnore,
+                "Performance: %0 uses existential any, leading to heap allocation, reference counting, "
+                "and dynamic dispatch. Consider using generic constraints or concrete types instead.",
+                (const VarDecl *))
+GROUPED_WARNING(perf_hint_pat_uses_existential,PerformanceHints,DefaultIgnore,
+                "Performance: Ignored value uses existential any, leading to heap allocation, reference counting, "
+                "and dynamic dispatch. Consider using generic constraints or concrete types instead.",
+                ())
+GROUPED_WARNING(perf_hint_typealias_uses_existential,PerformanceHints,DefaultIgnore,
+                "Performance: %0 aliases existential any type, leading to heap allocation, reference counting, "
+                "and dynamic dispatch. Consider using generic constraints or concrete types instead.",
+                (const TypeAliasDecl *))
+
 ERROR(unsafe_self_dependent_result_attr_on_invalid_decl,none,
       "invalid use of @_unsafeSelfDependentResult", ())
 

lib/Sema/PerformanceHints.cpp

@@ -25,6 +25,7 @@
 #include "swift/AST/Evaluator.h"
 #include "swift/AST/Expr.h"
 #include "swift/AST/TypeCheckRequests.h"
+#include "swift/AST/TypeVisitor.h"
 
 using namespace swift;
 
@@ -52,6 +53,88 @@ void checkImplicitCopyReturnType(const ClosureExpr *Closure,
   }
 }
 
+class HasExistentialAnyType : public TypeVisitor<HasExistentialAnyType, bool> {
+public:
+  static bool check(Type type) {
+    return HasExistentialAnyType().visit(type->getCanonicalType());
+  }
+
+  bool visitExistentialType(ExistentialType *ET) {
+    return true;
+  }
+
+  bool visitTupleType(TupleType *TT) {
+    for (const auto &element : TT->getElements()) {
+      if (visit(element.getType())) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  bool visitBoundGenericType(BoundGenericType *BGT) {
+    // Check generic arguments (e.g., Array<any Protocol>)
+    for (Type arg : BGT->getGenericArgs()) {
+      if (visit(arg)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  bool visitFunctionType(FunctionType *FT) {
+    for (const auto &param : FT->getParams()) {
+      if (visit(param.getPlainType()->getCanonicalType())) {
+        return true;
+      }
+    }
+
+    return visit(FT->getResult()->getCanonicalType());
+  }
+
+  bool visitType(TypeBase *T) {
+    return false;
+  }
+};
+
+void checkExistentialAnyReturnType(FuncDecl *FD, DiagnosticEngine &Diags) {
+  Type T = FD->getResultInterfaceType();
+
+  if (HasExistentialAnyType::check(T))
+    Diags.diagnose(FD, diag::perf_hint_func_returns_existential, FD);
+}
+
+void checkExistentialAnyReturnType(ClosureExpr *CE, DiagnosticEngine &Diags) {
+  Type T = CE->getResultType();
+
+  if (HasExistentialAnyType::check(T))
+    Diags.diagnose(CE->getLoc(), diag::perf_hint_closure_returns_existential);
+}
+
+void checkExistentialAnyVarType(const VarDecl *VD, DiagnosticEngine &Diags) {
+  Type T = VD->getInterfaceType();
+
+  if (HasExistentialAnyType::check(T))
+    Diags.diagnose(VD, diag::perf_hint_var_uses_existential, VD);
+}
+
+void checkExistentialAnyPatternType(const AnyPattern *AP,
+                                    DiagnosticEngine &Diags) {
+  Type T = AP->getType();
+
+  if (HasExistentialAnyType::check(T))
+    Diags.diagnose(AP->getLoc(), diag::perf_hint_pat_uses_existential);
+}
+
+void checkExistentialAnyTypeAlias(const TypeAliasDecl *TAD,
+                                  DiagnosticEngine &Diags) {
+  Type T = TAD->getUnderlyingType();
+
+  if (HasExistentialAnyType::check(T))
+    Diags.diagnose(TAD->getLoc(), diag::perf_hint_typealias_uses_existential,
+                   TAD);
+}
+
 /// Produce performance hint diagnostics for a SourceFile.
 class PerformanceHintDiagnosticWalker final : public ASTWalker {
   ASTContext &Ctx;
@@ -64,16 +147,63 @@ class PerformanceHintDiagnosticWalker final : public ASTWalker {
     SF->walk(Walker);
   }
 
+  PreWalkResult<Pattern *> walkToPatternPre(Pattern *P) override {
+    if (P->isImplicit())
+      return Action::SkipNode(P);
+
+    if (const AnyPattern *AP = dyn_cast<AnyPattern>(P)) {
+      checkExistentialAnyPatternType(AP, Ctx.Diags);
+    }
+
+    return Action::Continue(P);
+  }
+
   PreWalkResult<Expr *> walkToExprPre(Expr *E) override {
-    if (auto Closure = dyn_cast<ClosureExpr>(E))
+    if (E->isImplicit())
+      return Action::SkipNode(E);
+
+    if (const ClosureExpr* Closure = dyn_cast<ClosureExpr>(E)) {
       checkImplicitCopyReturnType(Closure, Ctx.Diags);
+    }
+
+    return Action::Continue(E);
+  }
+
+  PostWalkResult<Expr *> walkToExprPost(Expr *E) override {
+    assert(
+        !E->isImplicit() &&
+        "Traversing implicit expressions is disabled in the pre-walk visitor");
+
+    if (auto Closure = dyn_cast<ClosureExpr>(E)) {
+      checkExistentialAnyReturnType(Closure, Ctx.Diags);
+    }
 
     return Action::Continue(E);
   }
 
   PreWalkAction walkToDeclPre(Decl *D) override {
-    if (auto *FD = dyn_cast<FuncDecl>(D))
+    if (D->isImplicit())
+      return Action::SkipNode();
+
+    if (const FuncDecl *FD = dyn_cast<FuncDecl>(D)) {
       checkImplicitCopyReturnType(FD, Ctx.Diags);
+    } else if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
+      checkExistentialAnyVarType(VD, Ctx.Diags);
+    } else if (const TypeAliasDecl *TAD = dyn_cast<TypeAliasDecl>(D)) {
+      checkExistentialAnyTypeAlias(TAD, Ctx.Diags);
+    }
+
+    return Action::Continue();
+  }
+
+  PostWalkAction walkToDeclPost(Decl *D) override {
+    assert(
+        !D->isImplicit() &&
+        "Traversing implicit declarations is disabled in the pre-walk visitor");
+
+    if (auto *FD = dyn_cast<FuncDecl>(D)) {
+      checkExistentialAnyReturnType(FD, Ctx.Diags);
+    }
 
     return Action::Continue();
   }