backport llvm commit ae20dbd to clang-tidy plugin

Author: mkolosick

utils/clang-tidy-auto-const/ExprAutoMutationAnalyzer.cpp

@@ -353,7 +353,7 @@ namespace clang
 
         // Assume Exp is not mutated before analyzing Exp.
         MemoizedResults[Exp] = nullptr;
-        if (isUnevaluated(Exp)) {
+        if (ExprAutoMutationAnalyzer::isUnevaluated(Exp, Context)) {
             return nullptr;
         }
 
@@ -390,45 +390,29 @@ namespace clang
         return nullptr;
     }
 
-    bool ExprAutoMutationAnalyzer::Analyzer::isUnevaluated(
-        Stmt const *Exp, Stmt const &Stm, ASTContext &Context)
-    {
-        return selectFirst<Stmt>(
-                   NodeID<Expr>::value,
-                   match(
-                       findFirst(
-                           stmt(
-                               canResolveToExpr(Exp),
-                               anyOf(
-                                   // `Exp` is part of the underlying expression
-                                   // of decltype/typeof if it has an ancestor
-                                   // of typeLoc.
-                                   hasAncestor(typeLoc(unless(hasAncestor(
-                                       unaryExprOrTypeTraitExpr())))),
-                                   hasAncestor(expr(anyOf(
-                                       // `UnaryExprOrTypeTraitExpr` is
-                                       // unevaluated unless it's sizeof on VLA.
-                                       unaryExprOrTypeTraitExpr(
-                                           unless(sizeOfExpr(hasArgumentOfType(
-                                               variableArrayType())))),
-                                       // `CXXTypeidExpr` is unevaluated unless
-                                       // it's applied to an expression of
-                                       // glvalue of polymorphic class type.
-                                       cxxTypeidExpr(
-                                           unless(isPotentiallyEvaluated())),
-                                       // The controlling expression of
-                                       // `GenericSelectionExpr` is unevaluated.
-                                       genericSelectionExpr(hasControllingExpr(
-                                           hasDescendant(equalsNode(Exp)))),
-                                       cxxNoexceptExpr())))))
-                               .bind(NodeID<Expr>::value)),
-                       Stm,
-                       Context)) != nullptr;
-    }
-
-    bool ExprAutoMutationAnalyzer::Analyzer::isUnevaluated(Expr const *Exp)
-    {
-        return isUnevaluated(Exp, Stm, Context);
+    bool ExprAutoMutationAnalyzer::isUnevaluated(const Stmt *Stm, ASTContext &Context) {
+        return !match(stmt(anyOf(
+                            // `Exp` is part of the underlying expression of
+                            // decltype/typeof if it has an ancestor of
+                            // typeLoc.
+                            hasAncestor(typeLoc(
+                                                unless(hasAncestor(unaryExprOrTypeTraitExpr())))),
+                            hasAncestor(expr(anyOf(
+                                                // `UnaryExprOrTypeTraitExpr` is unevaluated
+                                                // unless it's sizeof on VLA.
+                                                unaryExprOrTypeTraitExpr(unless(sizeOfExpr(
+                                                                                            hasArgumentOfType(variableArrayType())))),
+                                                // `CXXTypeidExpr` is unevaluated unless it's
+                                                // applied to an expression of glvalue of
+                                                // polymorphic class type.
+                                                cxxTypeidExpr(unless(isPotentiallyEvaluated())),
+                                                // The controlling expression of
+                                                // `GenericSelectionExpr` is unevaluated.
+                                                genericSelectionExpr(
+                                                                        hasControllingExpr(hasDescendant(equalsNode(Stm)))),
+                                                cxxNoexceptExpr()))))),
+                      *Stm, Context)
+              .empty();
     }
 
     Stmt const *ExprAutoMutationAnalyzer::Analyzer::findExprMutation(

utils/clang-tidy-auto-const/ExprAutoMutationAnalyzer.hpp

@@ -59,8 +59,6 @@ namespace clang
 
             Stmt const *findPointeeMutation(Expr const *Exp);
             Stmt const *findPointeeMutation(Decl const *Dec);
-            static bool isUnevaluated(
-                Stmt const *Smt, Stmt const &Stm, ASTContext &Context);
 
         private:
             using MutationFinder = Stmt const *(Analyzer::*)(Expr const *);
@@ -71,8 +69,6 @@ namespace clang
             Stmt const *tryEachDeclRef(Decl const *Dec, MutationFinder Finder);
             Stmt const *findMaybeRemovedIfConstexpr(Decl const *Dec);
 
-            bool isUnevaluated(Expr const *Exp);
-
             Stmt const *
             findExprMutation(ArrayRef<ast_matchers::BoundNodes> Matches);
             Stmt const *
@@ -101,6 +97,10 @@ namespace clang
         {
         }
 
+        /// check whether stmt is unevaluated. mutation analyzer will ignore the
+        /// content in unevaluated stmt.
+        static bool isUnevaluated(const Stmt *Stm, ASTContext &Context);
+
         bool isMutated(Expr const *Exp)
         {
             return findMutation(Exp) != nullptr;
@@ -141,12 +141,6 @@ namespace clang
             return A.findPointeeMutation(Dec);
         }
 
-        static bool
-        isUnevaluated(Stmt const *Smt, Stmt const &Stm, ASTContext &Context)
-        {
-            return Analyzer::isUnevaluated(Smt, Stm, Context);
-        }
-
     private:
         Memoized Memorized;
         Analyzer A;