review fixes

Author: segoon

clang-tools-extra/clang-tidy/performance/LostStdMoveCheck.cpp

@@ -16,16 +16,31 @@ namespace clang::tidy::performance {
 
 using utils::decl_ref_expr::allDeclRefExprs;
 
+static const Expr* getLastVarUsage(const VarDecl& Var, const Decl& Func,
+                                   ASTContext& Context) {
+  auto Exprs = allDeclRefExprs(Var, Func, Context);
+
+  const Expr* LastExpr = nullptr;
+  for (const clang::DeclRefExpr* Expr : Exprs) {
+    if (!LastExpr) LastExpr = Expr;
+
+    if (LastExpr->getBeginLoc() < Expr->getBeginLoc()) LastExpr = Expr;
+  }
+
+  return LastExpr;
+}
+
 AST_MATCHER(CXXRecordDecl, hasTrivialMoveConstructor) {
   return Node.hasDefinition() && Node.hasTrivialMoveConstructor();
 }
 
-void LostStdMoveCheck::registerMatchers(MatchFinder *Finder) {
+void LostStdMoveCheck::registerMatchers(MatchFinder* Finder) {
   auto returnParent =
       hasParent(expr(hasParent(cxxConstructExpr(hasParent(returnStmt())))));
 
   auto outermostExpr = expr(unless(hasParent(expr())));
-  auto leafStatement = stmt(outermostExpr, unless(hasDescendant(outermostExpr)));
+  auto leafStatement =
+      stmt(outermostExpr, unless(hasDescendant(outermostExpr)));
 
   Finder->addMatcher(
       declRefExpr(
@@ -49,7 +64,7 @@ void LostStdMoveCheck::registerMatchers(MatchFinder *Finder) {
           unless(hasDeclaration(
               varDecl(hasType(qualType(lValueReferenceType()))))),
 
-	  hasAncestor(leafStatement.bind("leaf_statement")),
+          hasAncestor(leafStatement.bind("leaf_statement")),
 
           hasDeclaration(
               varDecl(hasAncestor(functionDecl().bind("func"))).bind("decl")),
@@ -59,60 +74,44 @@ void LostStdMoveCheck::registerMatchers(MatchFinder *Finder) {
       this);
 }
 
-const Expr *LostStdMoveCheck::getLastVarUsage(const VarDecl &Var,
-                                              const Decl &Func,
-                                              ASTContext &Context) {
-  auto Exprs = allDeclRefExprs(Var, Func, Context);
-
-  const Expr *LastExpr = nullptr;
-  for (const auto &Expr : Exprs) {
-    if (!LastExpr)
-      LastExpr = Expr;
-
-    if (LastExpr->getBeginLoc() < Expr->getBeginLoc())
-      LastExpr = Expr;
-  }
-
-  return LastExpr;
-}
-
 template <typename Node>
 void extractNodesByIdTo(ArrayRef<BoundNodes> Matches, StringRef ID,
-                        llvm::SmallPtrSet<const Node *, 16> &Nodes) {
-  for (const auto &Match : Matches)
+                        llvm::SmallPtrSet<const Node*, 16>& Nodes) {
+  for (const BoundNodes& Match : Matches)
     Nodes.insert(Match.getNodeAs<Node>(ID));
 }
 
-void LostStdMoveCheck::check(const MatchFinder::MatchResult &Result) {
-  const auto *MatchedDecl = Result.Nodes.getNodeAs<VarDecl>("decl");
-  const auto *MatchedFunc = Result.Nodes.getNodeAs<FunctionDecl>("func");
-  const auto *MatchedUse = Result.Nodes.getNodeAs<Expr>("use");
-  const auto *MatchedUseCall = Result.Nodes.getNodeAs<CallExpr>("use_parent");
-  const auto *MatchedLeafStatement = Result.Nodes.getNodeAs<Stmt>("leaf_statement");
+void LostStdMoveCheck::check(const MatchFinder::MatchResult& Result) {
+  const auto* MatchedDecl = Result.Nodes.getNodeAs<VarDecl>("decl");
+  const auto* MatchedFunc = Result.Nodes.getNodeAs<FunctionDecl>("func");
+  const auto* MatchedUse = Result.Nodes.getNodeAs<Expr>("use");
+  const auto* MatchedUseCall = Result.Nodes.getNodeAs<CallExpr>("use_parent");
+  const auto* MatchedLeafStatement =
+      Result.Nodes.getNodeAs<Stmt>("leaf_statement");
 
-  if (MatchedUseCall)
-    return;
+  if (MatchedUseCall) return;
 
-  const auto *LastUsage =
+  const auto* LastUsage =
       getLastVarUsage(*MatchedDecl, *MatchedFunc, *Result.Context);
-  if (LastUsage == nullptr)
-    return;
+  if (LastUsage == nullptr) return;
 
   if (LastUsage->getBeginLoc() > MatchedUse->getBeginLoc()) {
     // "use" is not the last reference to x
     return;
   }
 
   // Calculate X usage count in the statement
-  llvm::SmallPtrSet<const DeclRefExpr *, 16> DeclRefs;
-  auto Matches = match(findAll(declRefExpr(to(varDecl(equalsNode(MatchedDecl)))).bind("ref")), *MatchedLeafStatement, *Result.Context);
+  llvm::SmallPtrSet<const DeclRefExpr*, 16> DeclRefs;
+  ArrayRef<BoundNodes> Matches = match(
+      findAll(declRefExpr(to(varDecl(equalsNode(MatchedDecl)))).bind("ref")),
+      *MatchedLeafStatement, *Result.Context);
   extractNodesByIdTo(Matches, "ref", DeclRefs);
   if (DeclRefs.size() > 1) {
     // Unspecified order of evaluation, e.g. f(x, x)
     return;
   }
 
-  diag(LastUsage->getBeginLoc(), "Could be std::move()");
+  diag(LastUsage->getBeginLoc(), "could be std::move()");
 }
 
-} // namespace clang::tidy::performance
+}  // namespace clang::tidy::performance

clang-tools-extra/clang-tidy/performance/LostStdMoveCheck.h

@@ -24,12 +24,8 @@ class LostStdMoveCheck : public ClangTidyCheck {
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
-    return LangOpts.CPlusPlus;
+    return LangOpts.CPlusPlus11;
   }
-
-private:
-  const Expr *getLastVarUsage(const VarDecl &Var, const Decl &Func,
-                              ASTContext &Context);
 };
 
 } // namespace clang::tidy::performance