[clang-tidy] Add a new check for non-trivial unused variables.

[veluca93]

Summary

This check is meant to detect case that -Wunused-variable does not,
by integrating some extra knowledge of types. For example, a
std::vector<int> that only ever gets push_back()-ed is similar to a
written-but-never-read variable.

[Eugene.Zelenko]

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

12

C++ headers should be after application's ones.

117

const auto *. Same in other places.

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

13

C++ headers should be after application's ones.

clang-tools-extra/docs/clang-tidy/checks/performance-unused-no-side-effect.rst

9

Missing colon?

11

Missing period. Same in other places.

16

Please highlight TypesByBase with single back-ticks. Same for other elements of JSON.

28

Please use double back-ticks for language constructs like this.

31

Please highlight std::vector::swap with double back-ticks.

[veluca93]

Address first round of review comments.

[Eugene.Zelenko]

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

136

const auto *. Same in other similar places.

[veluca93]

Missing const from auto *

[veluca93]

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

136

Somehow I missed a couple of those... should be fixed now.

[LegalizeAdulthood]

clang-tools-extra/docs/clang-tidy/checks/performance-unused-no-side-effect.rst

26–27

The quotes here don't feel like they're needed.

36

Single backquotes around FunctionAllowList

94

Since std::string is just a type alias, shouldn't we be considering basic_string?
What about wstring?

104

string_view is also just a type alias, there is wstring_view, etc.

116–153

It would be easier to scan this list if it were sorted alphabetically. I see basic_string listed here, but not basic_string_view. Is that intentional?

173–174

This isn't user-friendly at all. Why not an array of argument indices starting at zero?

clang-tools-extra/test/clang-tidy/checkers/performance-unused-no-side-effect.cpp

119

Should there be some test cases for user-defined template types with no side effects?

Also some test cases for the smart pointer cases?

[veluca93]

Switch from bitmasks to arrays. Add more tests & update doc.

clang-tools-extra/docs/clang-tidy/checks/performance-unused-no-side-effect.rst

94

Looks like std::string is indeed unnecessary.

173–174

Done. I'm using an empty array to indicate "everything", which is perhaps a bit weird.

[LegalizeAdulthood]

clang-tools-extra/docs/clang-tidy/checks/performance-unused-no-side-effect.rst

173–174

I think [-1] might be a better sentinel. What do you do for functions that take zero arguments?

[veluca93]

clang-tools-extra/docs/clang-tidy/checks/performance-unused-no-side-effect.rst

173–174

It doesn't matter, right? For the purpose of tracking whether variables are used, 0-argument free/static functions are meaningless anyway.

[LegalizeAdulthood]

clang-tools-extra/docs/clang-tidy/checks/performance-unused-no-side-effect.rst

173–174

OK, yes, I was thinking member functions not free/static functions.

[veluca93]

@LegalizeAdulthood friendly ping :)

[ymandel]

Luca,

Can you expand the description to give a better intuition as to what this check is finding that the diagnostic does not? The example is good, but it would be helpful if you could phrase the general rule being enforced. Similarly, that would be helpful in the documentation file -- before diving into the formal specification, explain what the intuition. For that matter, why does this merit a separate clang-tidy vs. integeration into the existing code for the diagnostic (or a similar, parallel one)? I'm not advocating one way or another, I'd just like to understand your decision.

Separately, can you provide some data as to how much of a problem this is in practice? The code here is quite complex and I think that sets a high bar (in terms of benefit to users) for committing it.

Thanks!

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

53–56

Please add comments explaining the roles of these fields (either individually or collectively)

57

can you expand or rephrase? is the idea that these are argument positions that should be ignored for the purposes of this check? If so, what does the name of the field mean?

59–60

Might this be better in the .cpp file?

clang-tools-extra/docs/clang-tidy/checks/list.rst

117

why the change to this line?

[asoffer]

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

91

Perhaps I'm not understanding precisely what markSideEffectFree means, but this doesn't seem right to me:

int *data = ...;
auto getNextEntry = [&] () -> int& { return *++data; };
int n = (getNextDataEntry() + 17); // We can't mark RHS as side-effect free.
*data = n;

[veluca93]

In D124918#3555719, @ymandel wrote:

Luca,

Can you expand the description to give a better intuition as to what this check is finding that the diagnostic does not? The example is good, but it would be helpful if you could phrase the general rule being enforced. Similarly, that would be helpful in the documentation file -- before diving into the formal specification, explain what the intuition. For that matter, why does this merit a separate clang-tidy vs. integeration into the existing code for the diagnostic (or a similar, parallel one)? I'm not advocating one way or another, I'd just like to understand your decision.

I wrote in the doc:

This check is similar to the -Wunused-variable and -Wunused-but-set-variable
compiler warnings; however, it integrates (configurable) knowledge about
library types and functions to be able to extend these checks to more types of
variables that do not produce user-visible side effects but i.e. perform
allocations; not using such variables is almost always a programming error.

The reason for this to be a tidy rather than an extension of the warning is twofold:

• I'm not quite confident that this check meets (or can meet) the standard for FPR that warnings are held to. It may well be the case, but it's not something I checked extensively.
• I don't think compiler warnings can be configured to the extent that would be needed for this check to be useful.

Separately, can you provide some data as to how much of a problem this is in practice? The code here is quite complex and I think that sets a high bar (in terms of benefit to users) for committing it.

I have seen this check trigger about 100k times among ~100M analyzed lines of code.

Thanks!

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

91

markSideEffectFree is a bad name - I renamed it to markMaybeNotObservable, with the idea being that an expression is observable iff any of its ancestors in the AST is marked as Observable.

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

57

I renamed the field and expanded the comment.

clang-tools-extra/docs/clang-tidy/checks/list.rst

117

No idea, must have been a merge gone wrong :) Reverted.

[veluca93]

Respond to comments

[LegalizeAdulthood]

Clang-Tidy tests and docs have moved to module subdirectories.

Please rebase this onto main:HEAD and:

• fold your changes into the appropriate subdirs, stripping the module prefix from new files.
• make the target check-clang-extra to validate your tests
• make the target docs-clang-tools-html to validate any docs changes

clang-tools-extra/clang-tidy/performance/CMakeLists.txt

add_clang_library(clangTidyPerformanceModule
   NoAutomaticMoveCheck.cpp
   NoIntToPtrCheck.cpp
   NoexceptMoveConstructorCheck.cpp
   PerformanceTidyModule.cpp
   TriviallyDestructibleCheck.cpp
   TypePromotionInMathFnCheck.cpp
   UnnecessaryCopyInitialization.cpp
   UnnecessaryValueParamCheck.cpp
+  UnusedNoSideEffectCheck.cpp
 
   LINK_LIBS
   clangTidy
   clangTidyUtils
 
   DEPENDS
   omp_gen
   )

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

 #include "MoveConstructorInitCheck.h"
 #include "NoAutomaticMoveCheck.h"
 #include "NoIntToPtrCheck.h"
 #include "NoexceptMoveConstructorCheck.h"
 #include "TriviallyDestructibleCheck.h"
 #include "TypePromotionInMathFnCheck.h"
 #include "UnnecessaryCopyInitialization.h"
 #include "UnnecessaryValueParamCheck.h"
+#include "UnusedNoSideEffectCheck.h"
 
 namespace clang {
 namespace tidy {
 namespace performance {
 
 class PerformanceModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<TriviallyDestructibleCheck>(
         "performance-trivially-destructible");
     CheckFactories.registerCheck<TypePromotionInMathFnCheck>(
         "performance-type-promotion-in-math-fn");
     CheckFactories.registerCheck<UnnecessaryCopyInitialization>(
         "performance-unnecessary-copy-initialization");
     CheckFactories.registerCheck<UnnecessaryValueParamCheck>(
         "performance-unnecessary-value-param");
+    CheckFactories.registerCheck<UnusedNoSideEffectCheck>(
+        "performance-unused-no-side-effect");
   }
 };
 
 // Register the PerformanceModule using this statically initialized variable.
 static ClangTidyModuleRegistry::Add<PerformanceModule>
     X("performance-module", "Adds performance checks.");
 
 } // namespace performance
 
 // This anchor is used to force the linker to link in the generated object file
 // and thus register the PerformanceModule.
 volatile int PerformanceModuleAnchorSource = 0;
 
 } // namespace tidy
 } // namespace clang

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

+//===--- UnusedNoSideEffectCheck.h - clang-tidy -----------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_UNUSEDNOSIDEEFFECTCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_UNUSEDNOSIDEEFFECTCHECK_H
+
+#include "../ClangTidyCheck.h"
+#include "clang/AST/Decl.h"
+#include "clang/AST/Expr.h"
+#include "clang/AST/RecursiveASTVisitor.h"
+#include "clang/AST/Type.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "llvm/ADT/StringSet.h"
+
+#include <string>
+
+namespace clang {
+namespace tidy {
+namespace performance {
+
+/// Finds variables that are not used and do not have user-visible side effects.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/performance-unused-no-side-effect.html
+class UnusedNoSideEffectCheck : public ClangTidyCheck {
+public:
+  UnusedNoSideEffectCheck(StringRef Name, ClangTidyContext *Context);
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
+
+  struct NoSideEffectsInfo {
+    std::string Type;
+    llvm::SmallVector<std::string> ExcludedMethods;
+  };
+
+private:
+  class Visitor;
+
+  bool hasNoSideEffects(ASTContext &AstContext, QualType Type,
+                        const CXXMethodDecl *Method = nullptr);
+
+  bool hasNoSideEffectsImpl(ASTContext &AstContext, QualType Type,
+                            const CXXMethodDecl *Method, bool AllowReferences,
+                            llvm::DenseSet<QualType> &Seen);
+
+  // Configuration for the types that are considered side-effect-free by the
+  // check.
+
+  // Types that inherit directly from these types are considered side-effect
+  // free.
+  llvm::SmallVector<NoSideEffectsInfo> TypesByBase;
+
+  // The following non-template types are considered side-effect free.
+  llvm::SmallVector<NoSideEffectsInfo> RawTypes;
+
+  // Instantiations of these template types with side-effect free types are
+  // considered side-effect-free.
+  llvm::SmallVector<NoSideEffectsInfo> TemplateTypes;
+
+  // List of smart pointer types, which are template types that have special
+  // rules wrt side-effect-free-ness.
+  llvm::SmallVector<NoSideEffectsInfo> SmartPointerTypes;
+
+  // Functions that are known not to read data from some of their arguments,
+  // represented as a map from function name to set of not-read-from arguments.
+  llvm::StringMap<llvm::SmallSet<size_t, 4>> UnusedFunctionArguments;
+};
+
+} // namespace performance
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_UNUSEDNOSIDEEFFECTCHECK_H

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

+//===--- UnusedNoSideEffectCheck.cpp - clang-tidy -------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "UnusedNoSideEffectCheck.h"
+
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/Attrs.inc"
+#include "clang/AST/Decl.h"
+#include "clang/AST/Expr.h"
+#include "clang/AST/ExprCXX.h"
+#include "clang/AST/Stmt.h"
+#include "clang/AST/Type.h"
+#include "clang/AST/TypeLoc.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
+#include "clang/ASTMatchers/ASTMatchersInternal.h"
+#include "clang/Basic/Diagnostic.h"
+#include "clang/Basic/SourceLocation.h"
+#include "clang/Basic/Specifiers.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/Support/JSON.h"
+#include "llvm/Support/raw_ostream.h"
+
+#include <map>
+#include <sstream>
+#include <string>
+#include <utility>
+
+namespace clang {
+namespace tidy {
+namespace performance {
+
+// TODO(veluca): The FixIts don't really fix everything and can break code.
+static constexpr bool EmitFixits = false;
+
+using namespace ::clang::ast_matchers; // NOLINT: Too many names.
+
+class UnusedNoSideEffectCheck::Visitor
+    : public RecursiveASTVisitor<UnusedNoSideEffectCheck::Visitor> {
+public:
+  explicit Visitor(UnusedNoSideEffectCheck *Check) : Check(Check) {}
+
+  bool shouldVisitImplicitCode() { return true; }
+  bool shouldVisitTemplateInstantiations() const { return true; }
+
+  bool dataTraverseStmtPre(Stmt *S) {
+    if (CurrentExprOrDeclStmt != nullptr) {
+      return true;
+    }
+    if (isa<DeclStmt, Expr>(S)) {
+      CurrentExprOrDeclStmt = S;
+    }
+    return true;
+  }
+
+  bool dataTraverseStmtPost(Stmt *S) {
+    if (CurrentExprOrDeclStmt == S) {
+      CurrentExprOrDeclStmt = nullptr;
+    }
+    return true;
+  }
+
+  bool VisitStmt(Stmt *S) {
+    // Mark all children as observable by default.
+    for (const auto *Child : S->children()) {
+      markObservable(Child);
+    }
+    return true;
+  }
+
+  bool VisitCompoundStmt(CompoundStmt *Compound) {
+    // Compound statements (i.e. blocks) do not produce a value, nor have side
+    // effects by themselves.
+    for (const auto *Child : Compound->children()) {
+      markMaybeNotObservable(Child);
+    }
+    return true;
+  }
+
+  bool VisitBinaryOperator(BinaryOperator *Op) {
+    if (isObservable(Op)) {
+      return true;
+    }
+    // If this is not an assignment operation, its arguments are only observed
+    // iff the result of the operation is observed. If this is an assignment,
+    // then its RHS is always observed.
+    if (!Op->isAssignmentOp()) {
+      markMaybeNotObservable(Op->getRHS());
+    }
+    markMaybeNotObservable(Op->getLHS());
+    return true;
+  }
+
+  bool VisitUnaryOperator(UnaryOperator *Op) {
+    if (isObservable(Op) || Op->getOpcode() == UnaryOperatorKind::UO_Coawait ||
+        Op->getOpcode() == UnaryOperatorKind::UO_Deref) {
+      return true;
+    }
+    // Unary operators don't have side effects, except co_await and
+    // dereferencing.
+    markMaybeNotObservable(Op->getSubExpr());
+    return true;
+  }
+
+  bool VisitCallExpr(CallExpr *Call) {
+    if (isObservable(Call)) {
+      return true;
+    }
+    const auto *Callee = Call->getDirectCallee();
+    if (!Callee) {
+      return true;
+    }
+    CalleesForStmts[CurrentExprOrDeclStmt].insert(Callee);
+    const auto *CXXMethod = dyn_cast<CXXMethodDecl>(Callee);
+    if (!CXXMethod || CXXMethod->isStatic()) {
+      std::string QualName = Callee->getQualifiedNameAsString();
+      const auto Iter = Check->UnusedFunctionArguments.find(QualName);
+      if (Iter != Check->UnusedFunctionArguments.end()) {
+        for (size_t i = 0; i < Call->getNumArgs(); i++) {
+          if (Iter->second.contains(i) || Iter->second.empty()) {
+            markMaybeNotObservable(Call->getArg(i));
+          }
+        }
+      }
+      return true;
+    }
+    if (!Check->hasNoSideEffects(CXXMethod->getASTContext(),
+                                 CXXMethod->getThisObjectType(), CXXMethod)) {
+      return true;
+    }
+    // Here we know that the function is a method or operator call on a struct
+    // or class, and that there are no side effects on `this`.
+    if (const auto *Callee = dyn_cast<MemberExpr>(Call->getCallee())) {
+      markMaybeNotObservable(Callee);
+    }
+    if (const auto *CXXMethodCall = dyn_cast<CXXMemberCallExpr>(Call)) {
+      markMaybeNotObservable(CXXMethodCall->getImplicitObjectArgument());
+      return true;
+    }
+    // Otherwise, this is a call with operator syntax, and "this" is the first
+    // argument.
+    assert(isa<CXXOperatorCallExpr>(Call));
+    markMaybeNotObservable(Call->getArg(0));
+    return true;
+  }
+
+  bool VisitMemberExpr(MemberExpr *MemberExpr) {
+    if (isObservable(MemberExpr)) {
+      return true;
+    }
+    // Member access does not have side effects.
+    markMaybeNotObservable(MemberExpr->getBase());
+    return true;
+  }
+
+  bool VisitDeclRefExpr(DeclRefExpr *DeclRef) {
+    const auto *Decl = dyn_cast<VarDecl>(DeclRef->getDecl());
+    if (!Decl) {
+      return true;
+    }
+    StmtsForVars[Decl].insert(CurrentExprOrDeclStmt);
+    // Also consider used all variables that are used in a non-ODR context, i.e.
+    // array sizes, variables that appear in decltype expressions, or variables
+    // that appear as template parameters.
+    if (!isObservable(DeclRef) && !DeclRef->isNonOdrUse()) {
+      return true;
+    }
+    UsedDecls.insert(Decl);
+    return true;
+  }
+
+  bool VisitExprWithCleanups(ExprWithCleanups *ExprWithCleanups) {
+    if (isObservable(ExprWithCleanups)) {
+      return true;
+    }
+    markMaybeNotObservable(ExprWithCleanups->getSubExpr());
+    return true;
+  }
+
+  bool VisitImplicitCastExpr(ImplicitCastExpr *ImplicitCast) {
+    if (isObservable(ImplicitCast) ||
+        ImplicitCast->getCastKind() == CastKind::CK_LValueToRValue) {
+      return true;
+    }
+    // Implicit casts don't have side effects, except lvalue-to-rvalue.
+    markMaybeNotObservable(ImplicitCast->getSubExpr());
+    return true;
+  }
+  bool VisitParenExpr(ParenExpr *Paren) {
+    if (isObservable(Paren)) {
+      return true;
+    }
+    markMaybeNotObservable(Paren->getSubExpr());
+    return true;
+  }
+  bool VisitDeclStmt(DeclStmt *Decl) {
+    // We do not support producing fixits for variables in multiple
+    // declarations.
+    if (Decl->isSingleDecl() && isa<VarDecl>(Decl->getSingleDecl())) {
+      StmtsForVars[dyn_cast<VarDecl>(Decl->getSingleDecl())].insert(Decl);
+    }
+    return true;
+  }
+
+  // Utility methods to track observability of statements. By default, all
+  // statements are observable, and statements are marked as not observable when
+  // they are part of non-observable statements of a specific kind; for example,
+  // direct members of a CompoundStmt are not observable.
+  void markObservable(const Stmt *Stmt) { ObservableStmts.insert(Stmt); }
+  void markMaybeNotObservable(const Stmt *Stmt) { ObservableStmts.erase(Stmt); }
+  bool isObservable(const Stmt *Stmt) const {
+    return ObservableStmts.contains(Stmt);
+  }
+
+  UnusedNoSideEffectCheck *Check;
+  llvm::DenseSet<const Stmt *> ObservableStmts;
+  llvm::DenseSet<const VarDecl *> UsedDecls;
+  // Statements in which a given variable is used/declared. Used for fixits.
+  llvm::DenseMap<const VarDecl *, llvm::DenseSet<const Stmt *>> StmtsForVars;
+  llvm::DenseMap<const Stmt *, llvm::DenseSet<const FunctionDecl *>>
+      CalleesForStmts;
+  Stmt *CurrentExprOrDeclStmt = nullptr;
+};
+
+void UnusedNoSideEffectCheck::registerMatchers(MatchFinder *Finder) {
+  Finder->addMatcher(functionDecl(hasBody(compoundStmt())).bind("func"), this);
+}
+
+void UnusedNoSideEffectCheck::check(const MatchFinder::MatchResult &Result) {
+  const auto *MatchedDecl = Result.Nodes.getNodeAs<FunctionDecl>("func");
+
+  Visitor Vis(this);
+  if (const auto *CXXConstructor = dyn_cast<CXXConstructorDecl>(MatchedDecl)) {
+    for (const auto *Init : CXXConstructor->inits()) {
+      Vis.markObservable(Init->getInit());
+    }
+  }
+  Vis.TraverseFunctionDecl(const_cast<FunctionDecl *>(MatchedDecl));
+
+  for (const auto &KV : Vis.StmtsForVars) {
+    const auto *VarDecl = KV.first;
+    if (Vis.UsedDecls.contains(VarDecl))
+      continue;
+
+    // Common ways to mark variables as unused intentionally.
+    if (VarDecl->getName().empty())
+      continue;
+    if (VarDecl->getName().startswith("_"))
+      continue;
+    if (VarDecl->getName().startswith("unused_"))
+      continue;
+    if (VarDecl->hasAttr<UnusedAttr>())
+      continue;
+
+    // Unused function parameters are very common.
+    // TODO(veluca): consider also handling unused `ParmVarDecl`s of non-cheap
+    // types.
+    if (isa<ParmVarDecl>(VarDecl)) {
+      continue;
+    }
+
+    // Skip variables of types that are not known to be side effect free.
+    if (!hasNoSideEffects(VarDecl->getASTContext(), VarDecl->getType())) {
+      continue;
+    }
+
+    // Handle smart pointer constructors.
+    if (const auto *RecordDecl = VarDecl->getType()->getAsRecordDecl()) {
+      std::string Name = RecordDecl->getQualifiedNameAsString().c_str();
+      bool IsSmartPointer = false;
+      for (const auto &TypeInfo : SmartPointerTypes) {
+        if (Name == TypeInfo.Type) {
+          IsSmartPointer = true;
+        }
+      }
+
+      // TODO(veluca): consider also handling custom deleters.
+
+      // Detect some constructors.
+      if (IsSmartPointer && VarDecl->hasInit()) {
+        const Expr *Init = VarDecl->getInit();
+        if (isa<ExprWithCleanups>(Init)) {
+          Init = dyn_cast<ExprWithCleanups>(Init)->getSubExpr();
+        }
+        const auto *CXXConstruct = dyn_cast<CXXConstructExpr>(Init);
+        if (!CXXConstruct || CXXConstruct->getNumArgs() > 1) {
+          // We don't understand this constructor: conservatively do nothing.
+          continue;
+        }
+        // Bail out on constructors that take a pointer that is not
+        // immediately produced by a new expression.
+        if (CXXConstruct->getNumArgs() == 1 &&
+            CXXConstruct->getArg(0)->getType()->isPointerType() &&
+            !isa<CXXNewExpr>(CXXConstruct->getArg(0))) {
+          continue;
+        }
+      }
+    }
+
+    // Avoid reporting captured variables that are not used in the body of a
+    // lambda, or global/static variables.
+    if (!MatchedDecl->getSourceRange().fullyContains(
+            VarDecl->getSourceRange())) {
+      continue;
+    }
+
+    llvm::DenseSet<const FunctionDecl *> Callees;
+    {
+      auto Diag = diag(VarDecl->getLocation(), "variable %0 is never read")
+                  << VarDecl;
+      if (EmitFixits) {
+        for (const auto *StmtToDelete : KV.second) {
+          // TODO(veluca): semicolons.
+          Diag << FixItHint::CreateRemoval(StmtToDelete->getSourceRange());
+          for (const auto *FnDecl : Vis.CalleesForStmts[StmtToDelete]) {
+            Callees.insert(FnDecl);
+          }
+        }
+      }
+    }
+  }
+}
+
+bool fromJSON(
+    const llvm::json::Value &E,
+    llvm::SmallVector<UnusedNoSideEffectCheck::NoSideEffectsInfo> &Out,
+    llvm::json::Path P) {
+  if (const auto *O = E.getAsObject()) {
+    Out.clear();
+    for (const auto &KV : *O) {
+      UnusedNoSideEffectCheck::NoSideEffectsInfo Entry;
+      Entry.Type = KV.first.str();
+      if (const auto *A = KV.second.getAsArray()) {
+        for (const auto &Method : *A) {
+          llvm::Optional<llvm::StringRef> M = Method.getAsString();
+          if (M) {
+            Entry.ExcludedMethods.push_back(M.getValue().str());
+          } else {
+            P.field(KV.first).report("expected array of strings");
+          }
+        }
+      } else {
+        P.field(KV.first).report("expected array");
+        return false;
+      }
+      Out.push_back(std::move(Entry));
+    }
+    return true;
+  }
+  P.report("expected object");
+  return false;
+}
+
+UnusedNoSideEffectCheck::UnusedNoSideEffectCheck(StringRef Name,
+                                                 ClangTidyContext *Context)
+    : ClangTidyCheck(Name, Context) {
+  // Operator= is disabled by default because often used to force deallocations
+  constexpr const char *kDefaultSmartPointerTypes =
+      R"({"std::unique_ptr":["swap","operator=","reset"],"std::shared_ptr":["swap","operator=", "reset"]})";
+
+  // std::string & related classes are handled by std::basic_string & friends.
+  constexpr const char *kDefaultRawTypes = R"(
+    {
+      "absl::AlphaNum": [],
+      "absl::Cord": ["swap", "Swap", "CopyTo", "AppendTo", "CopyToArray",
+                     "DumpTreeStructure", "Dump", "operator="],
+      "absl::Duration": ["swap"],
+      "absl::Time": ["swap"],
+      "absl::TimeZone": ["swap"],
+      "absl::int128": [],
+      "absl::string_view": ["swap", "copy"],
+      "absl::uint128": []
+    }
+)";
+  constexpr const char *kDefaultTypesByBase =
+      R"({"proto2::Message":["Swap","SerializeToString"]})";
+
+  constexpr const char *kDefaultTemplateTypes = R"r(
+  {
+    "absl::FunctionRef": ["operator()", "operator=", "swap"],
+    "absl::Hash": [],
+    "absl::StatusOr": ["swap"],
+    "absl::btree_set": ["swap"],
+    "absl::btree_map": ["swap"],
+    "absl::btree_multiset": ["swap"],
+    "absl::btree_multimap": ["swap"],
+    "absl::container_internal::hash_default_hash": [],
+    "absl::container_internal::hash_default_eq": [],
+    "absl::flat_hash_set": ["swap"],
+    "absl::flat_hash_map": ["swap"],
+    "absl::hash_internal::Hash": [],
+    "absl::node_hash_set": ["swap"],
+    "absl::node_hash_map": ["swap"],
+    "std::array": [],
+    "std::allocator": ["deallocate"],
+    "std::basic_string": ["swap"],
+    "std::basic_string_view": ["swap"],
+    "std::char_traits": [],
+    "std::deque": ["swap"],
+    "std::function": ["operator()", "operator=", "swap"],
+    "std::list": ["swap"],
+    "std::map": ["swap"],
+    "std::multiset": ["swap"],
+    "std::multimap": ["swap"],
+    "std::optional": ["swap"],
+    "std::pair": [],
+    "std::priority_queue": ["swap"],
+    "std::queue": ["swap"],
+    "std::set": ["swap"],
+    "std::tuple": [],
+    "std::unordered_set": ["swap"],
+    "std::unordered_map": ["swap"],
+    "std::unordered_multiset": ["swap"],
+    "std::unordered_multimap": ["swap"],
+    "std::variant": ["swap"],
+    "std::vector": ["swap"]
+  }
+)r";
+
+  static constexpr const char *kDefaultFunctionAllowList = R"(
+  {
+    "absl::CordAppend": [0],
+    "absl::CordCat": [],
+    "absl::CordContains": [],
+    "absl::CordSplit": [],
+    "absl::CordJoin": [],
+    "absl::StringPrintf": [],
+    "absl::StrAppend": [0],
+    "absl::StrCat": [],
+    "absl::StrContains": [],
+    "absl::StrSplit": [],
+    "absl::StrJoin": [],
+    "absl::Substitute": [],
+    "absl::SubstituteAndAppend": [0]
+  }
+)";
+
+  auto FunctionAllowListOrError =
+      llvm::json::parse<std::map<std::string, std::vector<size_t>>>(
+          Options.get("FunctionAllowList", kDefaultFunctionAllowList),
+          "FunctionAllowList");
+  if (FunctionAllowListOrError) {
+    for (const auto &kv : FunctionAllowListOrError.get()) {
+      UnusedFunctionArguments[kv.first].clear();
+      for (size_t v : kv.second) {
+        UnusedFunctionArguments[kv.first].insert(v);
+      }
+    }
+  }
+
+  if (auto TypesByBaseOrError =
+          llvm::json::parse<llvm::SmallVector<NoSideEffectsInfo>>(
+              Options.get("TypesByBase", kDefaultTypesByBase), "TypesByBase")) {
+    TypesByBase = TypesByBaseOrError.get();
+  }
+
+  if (auto RawTypesOrError =
+          llvm::json::parse<llvm::SmallVector<NoSideEffectsInfo>>(
+              Options.get("RawTypes", kDefaultRawTypes), "RawTypes")) {
+    RawTypes = RawTypesOrError.get();
+  }
+
+  if (auto SmartPointerTypesOrError =
+          llvm::json::parse<llvm::SmallVector<NoSideEffectsInfo>>(
+              Options.get("SmartPointerTypes", kDefaultSmartPointerTypes),
+              "SmartPointerTypes")) {
+    SmartPointerTypes = SmartPointerTypesOrError.get();
+  }
+
+  if (auto TemplateTypesOrError =
+          llvm::json::parse<llvm::SmallVector<NoSideEffectsInfo>>(
+              Options.get("TemplateTypes", kDefaultTemplateTypes),
+              "TemplateTypes")) {
+    TemplateTypes = TemplateTypesOrError.get();
+  }
+}
+
+void UnusedNoSideEffectCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
+  std::string Output;
+  llvm::raw_string_ostream OS(Output);
+  {
+    llvm::json::OStream J(OS);
+    J.object([&] {
+      for (const auto &kv : UnusedFunctionArguments) {
+        J.attributeArray(kv.first(), [&] {
+          for (const auto &v : kv.second) {
+            J.value(v);
+          }
+        });
+      }
+    });
+    Options.store(Opts, "FunctionAllowList", Output);
+  }
+
+  auto SerializeTypeInfo =
+      [&](const llvm::SmallVector<NoSideEffectsInfo> &Types, const char *Name) {
+        llvm::json::OStream J(OS);
+        Output.clear();
+        J.object([&] {
+          for (const auto &Info : Types) {
+            J.attributeArray(Info.Type, [&] {
+              for (const auto &Excl : Info.ExcludedMethods) {
+                J.value(Excl);
+              }
+            });
+          }
+        });
+        Options.store(Opts, Name, Output);
+      };
+  SerializeTypeInfo(TypesByBase, "TypesByBase");
+  SerializeTypeInfo(RawTypes, "RawTypes");
+  SerializeTypeInfo(SmartPointerTypes, "SmartPointerTypes");
+  SerializeTypeInfo(TemplateTypes, "TemplateTypes");
+}
+
+bool UnusedNoSideEffectCheck::hasNoSideEffects(ASTContext &AstContext,
+                                               QualType Type,
+                                               const CXXMethodDecl *Method) {
+  llvm::DenseSet<QualType> Seen;
+  return hasNoSideEffectsImpl(AstContext, Type, Method,
+                              /*AllowReferences=*/false, Seen);
+}
+
+bool UnusedNoSideEffectCheck::hasNoSideEffectsImpl(
+    ASTContext &AstContext, QualType Type, const CXXMethodDecl *Method,
+    bool AllowReferences, llvm::DenseSet<QualType> &Seen) {
+  if (Type.isNull()) {
+    return true;
+  }
+  Type = Type.getCanonicalType();
+  // With recursive types (i.e. lists or trees), recursively visiting member
+  // variables would lead to infinite loops. OTOH, such members cannot make a
+  // type have side effects unless other members do so already, so we can just
+  // return true here.
+  if (Seen.count(Type)) {
+    return true;
+  }
+  Seen.insert(Type);
+  if (Type->isBuiltinType()) {
+    return true;
+  }
+  if (Type->isFunctionPointerType() || Type->isFunctionType()) {
+    return true;
+  }
+  if (Type->isReferenceType()) {
+    return AllowReferences;
+  }
+  if (Type->isPointerType()) {
+    return true;
+  }
+
+  // Check known types.
+  const auto *Record = Type->getAs<RecordType>();
+  if (Record) {
+    const auto *RecordDecl = Record->getDecl();
+    const llvm::SmallVector<std::string> *ExcludedList = nullptr;
+
+    {
+      std::string RecordDeclName = RecordDecl->getQualifiedNameAsString();
+      for (const auto &TypeInfo : RawTypes) {
+        if (RecordDeclName == TypeInfo.Type) {
+          ExcludedList = &TypeInfo.ExcludedMethods;
+        }
+      }
+    }
+
+    const auto *CXXRecord = dyn_cast<CXXRecordDecl>(RecordDecl);
+
+    if (CXXRecord && CXXRecord->hasDefinition()) {
+      CXXRecord = CXXRecord->getDefinition();
+      for (const auto &Base : CXXRecord->bases()) {
+        const auto *BaseType = Base.getType()->getAs<RecordType>();
+        if (!BaseType)
+          continue;
+        std::string BaseTypeName =
+            BaseType->getDecl()->getQualifiedNameAsString();
+        for (const auto &TypeInfo : TypesByBase) {
+          if (BaseTypeName == TypeInfo.Type) {
+            ExcludedList = &TypeInfo.ExcludedMethods;
+          }
+        }
+      }
+    }
+
+    const auto *CXXTemplateSpecialization =
+        dyn_cast<ClassTemplateSpecializationDecl>(RecordDecl);
+    if (CXXTemplateSpecialization) {
+      for (const auto TmplArg :
+           CXXTemplateSpecialization->getTemplateArgs().asArray()) {
+        if (TmplArg.getKind() == TemplateArgument::ArgKind::Type &&
+            !hasNoSideEffectsImpl(AstContext, TmplArg.getAsType(),
+                                  /*Method=*/nullptr, AllowReferences, Seen)) {
+          return false;
+        }
+        if (TmplArg.getKind() == TemplateArgument::ArgKind::Pack) {
+          for (auto TArg : TmplArg.getPackAsArray()) {
+            if (TArg.getKind() == TemplateArgument::ArgKind::Type &&
+                !hasNoSideEffectsImpl(AstContext, TArg.getAsType(),
+                                      /*Method=*/nullptr, AllowReferences,
+                                      Seen)) {
+              return false;
+            }
+          }
+        }
+      }
+      const auto TemplateName =
+          CXXTemplateSpecialization->getSpecializedTemplate()
+              ->getTemplatedDecl()
+              ->getQualifiedNameAsString();
+      for (const auto &TypeInfo : RawTypes) {
+        if (TemplateName == TypeInfo.Type) {
+          ExcludedList = &TypeInfo.ExcludedMethods;
+        }
+      }
+      for (const auto &TypeInfo : TemplateTypes) {
+        if (TemplateName == TypeInfo.Type) {
+          ExcludedList = &TypeInfo.ExcludedMethods;
+        }
+      }
+      for (const auto &TypeInfo : SmartPointerTypes) {
+        if (TemplateName == TypeInfo.Type) {
+          ExcludedList = &TypeInfo.ExcludedMethods;
+        }
+      }
+    }
+
+    // Unknown type.
+    if (ExcludedList == nullptr) {
+      // Always return false if we are calling a method.
+      if (Method != nullptr) {
+        return false;
+      }
+      // If the type is POD we return true.
+      if (Type.isPODType(AstContext)) {
+        return true;
+      }
+      // If we don't know enough about this type, conservatively return false.
+      if (!CXXRecord || !CXXRecord->hasDefinition()) {
+        return false;
+      }
+      // Otherwise, return true iff all struct members and bases are
+      // side-effect-free themselves, and there is no user-defined destructor.
+      if (CXXRecord->hasUserDeclaredDestructor()) {
+        return false;
+      }
+      for (const auto &Base : CXXRecord->bases()) {
+        if (!hasNoSideEffectsImpl(AstContext, Base.getType(),
+                                  /*Method=*/nullptr, AllowReferences, Seen))
+          return false;
+      }
+      for (const auto *Field : CXXRecord->fields()) {
+        if (!hasNoSideEffectsImpl(AstContext, Field->getType(),
+                                  /*Method=*/nullptr,
+                                  AllowReferences ||
+                                      Field->getAccess() !=
+                                          AccessSpecifier::AS_public,
+                                  Seen))
+          return false;
+      }
+      return true;
+    }
+
+    if (Method == nullptr) {
+      return true;
+    }
+
+    std::string MethodName = Method->getNameAsString();
+    for (const auto &Excl : *ExcludedList) {
+      if (Excl == MethodName) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  return false;
+}
+
+} // namespace performance
+} // namespace tidy
+} // namespace clang

clang-tools-extra/docs/ReleaseNotes.rst

- New :doc:`bugprone-unchecked-optional-access
    Warns when the code is unwrapping a `std::optional<T>`, `absl::optional<T>`,
    or `base::Optional<T>` object without assuring that it contains a value.
 
 - New :doc:`modernize-macro-to-enum
   <clang-tidy/checks/modernize-macro-to-enum>` check.
 
   Replaces groups of adjacent macros with an unscoped anonymous enum.
 
+- New :doc:`performance-unused-no-side-effect
+  <clang-tidy/checks/performance-unused-no-side-effect>` check.
+
+  Finds variables that are not used and do not have user-visible side effects.
+
 - New :doc:`portability-std-allocator-const <clang-tidy/checks/portability-std-allocator-const>` check.
 
   Report use of ``std::vector<const T>`` (and similar containers of const
   elements). These are not allowed in standard C++ due to undefined
   ``std::allocator<const T>``. They do not compile with libstdc++ or MSVC.
   Future libc++ will remove the extension (`D120996
   <https://reviews.llvm.org/D120996>`).
 

clang-tools-extra/docs/clang-tidy/checks/list.rst

.. csv-table::
    `bugprone-undefined-memory-manipulation <bugprone-undefined-memory-manipulation.html>`_,
    `bugprone-undelegated-constructor <bugprone-undelegated-constructor.html>`_,
    `bugprone-unhandled-exception-at-new <bugprone-unhandled-exception-at-new.html>`_,
    `bugprone-unhandled-self-assignment <bugprone-unhandled-self-assignment.html>`_,
    `bugprone-unused-raii <bugprone-unused-raii.html>`_, "Yes"
    `bugprone-unused-return-value <bugprone-unused-return-value.html>`_,
    `bugprone-use-after-move <bugprone-use-after-move.html>`_,
    `bugprone-virtual-near-miss <bugprone-virtual-near-miss.html>`_, "Yes"
    `cert-dcl21-cpp <cert-dcl21-cpp.html>`_, "Yes"
    `cert-dcl50-cpp <cert-dcl50-cpp.html>`_,
    `cert-dcl58-cpp <cert-dcl58-cpp.html>`_,
    `cert-env33-c <cert-env33-c.html>`_,
    `cert-err33-c <cert-err33-c.html>`_,
    `cert-err34-c <cert-err34-c.html>`_,
    `cert-err52-cpp <cert-err52-cpp.html>`_,
    `cert-err58-cpp <cert-err58-cpp.html>`_,
    `cert-err60-cpp <cert-err60-cpp.html>`_,
.. csv-table::
    `performance-move-constructor-init <performance-move-constructor-init.html>`_,
    `performance-no-automatic-move <performance-no-automatic-move.html>`_,
    `performance-no-int-to-ptr <performance-no-int-to-ptr.html>`_,
    `performance-noexcept-move-constructor <performance-noexcept-move-constructor.html>`_, "Yes"
    `performance-trivially-destructible <performance-trivially-destructible.html>`_, "Yes"
    `performance-type-promotion-in-math-fn <performance-type-promotion-in-math-fn.html>`_, "Yes"
    `performance-unnecessary-copy-initialization <performance-unnecessary-copy-initialization.html>`_, "Yes"
    `performance-unnecessary-value-param <performance-unnecessary-value-param.html>`_, "Yes"
+   `performance-unused-no-side-effect <performance-unused-no-side-effect.html>`_, "Yes"
    `portability-restrict-system-includes <portability-restrict-system-includes.html>`_, "Yes"
    `portability-simd-intrinsics <portability-simd-intrinsics.html>`_,
    `portability-std-allocator-const <portability-std-allocator-const.html>`_,
    `readability-avoid-const-params-in-decls <readability-avoid-const-params-in-decls.html>`_, "Yes"
    `readability-braces-around-statements <readability-braces-around-statements.html>`_, "Yes"
    `readability-const-return-type <readability-const-return-type.html>`_, "Yes"
    `readability-container-contains <readability-container-contains.html>`_, "Yes"
    `readability-container-data-pointer <readability-container-data-pointer.html>`_, "Yes"

clang-tools-extra/docs/clang-tidy/checks/performance-unused-no-side-effect.rst

+.. title:: clang-tidy - performance-unused-no-side-effect
+
+performance-unused-no-side-effect
+=================================
+
+Finds variables that are not used and do not have user-visible side effects.
+
+This check is similar to the -Wunused-variable and -Wunused-but-set-variable
+compiler warnings; however, it integrates (configurable) knowledge about
+library types and functions to be able to extend these checks to more types of
+variables that do not produce user-visible side effects but i.e. perform
+allocations; not using such variables is almost always a programming error.
+
+A variable is defined to be side-effect-free and unused if:
+
+- It has a side-effect-free type (defined below).
+- It is not passed to a function that reads its content and whose result is used.
+
+A type is side-effect-free if it is any of the following:
+
+- A type with a base class specified in `TypesByBase`.
+- A type listed in `RawTypes`.
+- A template type listed in `TemplateTypes` whose template arguments are
+  themselves side-effect-free types.
+- A smart pointer (listed in `SmartPointerTypes`) whose pointee is of
+  side-effect-free type.
+- A primitive type.
+- A pointer.
+- A struct/class with no user-defined destructor and members of trivial type.
+
+A function is considered to not read an argument unless the return value is
+used in the following cases:
+
+- It is a method of the explicitly listed types and the argument is ``this``,
+  except:
+
+  - The exceptions associated with the type (eg. ``std::vector::swap``).
+  - A constructor of a smart pointer type that takes a non-newly-allocated
+    pointer as argument.
+
+- A function listed in `FunctionAllowList`, if the argument is in index ``i`` and
+  bit ``i`` is set in the corresponding allow list entry.
+
+Examples of snippets that trigger the check with the default configuration:
+
+.. code-block:: c++
+
+  void f() {
+    std::vector<int> vec;
+    vec.push_back(1);
+  }
+
+
+Examples that do *not* trigger the check:
+
+.. code-block:: c++
+
+  void f() {
+    std::vector<int> vec;
+    vec.push_back(1);
+    std::cout << vec[0];
+  }
+
+  void g(std::vector<int>& outp) {
+    std::vector<int> vec;
+    vec.push_back(1);
+    vec.swap(outp);
+  }
+
+
+
+Configuration
+-------------
+The types that are considered unused can be specified in the check
+configuration. As more than just a simple list of types is used for
+configuration, the configuration options are JSON.
+
+`TypesByBase`
+^^^^^^^^^^^^^
+Types in this group will cause any type that derives from them to be considered
+side effect free. All methods on such types will also be considered side effect
+free, except for the exceptions explicitly listed as the value of the mapping.
+
+The default value for this configuration option is
+
+.. code-block:: json
+
+  {"proto2::Message": ["Swap", "SerializeToString"]}
+
+`RawTypes`
+^^^^^^^^^^
+Similar to `TypesByBase`, except it only applies to the types themselves.
+
+The default value for this configuration option is
+
+.. code-block:: json
+
+   {
+      "absl::AlphaNum": [],
+      "absl::Cord": ["swap", "Swap", "CopyTo", "AppendTo", "CopyToArray",
+                     "DumpTreeStructure", "Dump", "operator="],
+      "absl::Duration": ["swap"],
+      "absl::Time": ["swap"],
+      "absl::TimeZone": ["swap"],
+      "absl::int128": [],
+      "absl::string_view": ["swap", "copy"],
+      "absl::uint128": []
+   }
+
+`TemplateTypes`
+^^^^^^^^^^^^^^^
+Similar to `TypesByBase`, except it only applies to specializations of the
+specified template with side-effect-free types.
+
+The default value for this configuration option is
+
+.. code-block:: json
+
+  {
+    "absl::FunctionRef": ["operator()", "operator=", "swap"],
+    "absl::Hash": [],
+    "absl::StatusOr": ["swap"],
+    "absl::btree_set": ["swap"],
+    "absl::btree_map": ["swap"],
+    "absl::btree_multiset": ["swap"],
+    "absl::btree_multimap": ["swap"],
+    "absl::container_internal::hash_default_hash": [],
+    "absl::container_internal::hash_default_eq": [],
+    "absl::flat_hash_set": ["swap"],
+    "absl::flat_hash_map": ["swap"],
+    "absl::hash_internal::Hash": [],
+    "absl::node_hash_set": ["swap"],
+    "absl::node_hash_map": ["swap"],
+    "std::array": [],
+    "std::allocator": ["deallocate"],
+    "std::basic_string": ["swap"],
+    "std::basic_string_view": ["swap"],
+    "std::char_traits": [],
+    "std::deque": ["swap"],
+    "std::function": ["operator()", "operator=", "swap"],
+    "std::list": ["swap"],
+    "std::map": ["swap"],
+    "std::multiset": ["swap"],
+    "std::multimap": ["swap"],
+    "std::optional": ["swap"],
+    "std::pair": [],
+    "std::priority_queue": ["swap"],
+    "std::queue": ["swap"],
+    "std::set": ["swap"],
+    "std::tuple": [],
+    "std::unordered_set": ["swap"],
+    "std::unordered_map": ["swap"],
+    "std::unordered_multiset": ["swap"],
+    "std::unordered_multimap": ["swap"],
+    "std::variant": ["swap"],
+    "std::vector": ["swap"]
+  }
+
+`SmartPointerTypes`
+^^^^^^^^^^^^^^^^^^^
+Similar to `TemplateTypes`, except constructors are handled in a special way:
+only constructors that take a newly allocated raw pointer are considered
+side-effect free. 
+
+The default value for this configuration option is
+
+.. code-block:: json
+
+  {
+    "std::unique_ptr": ["swap", "operator=", "reset"],
+    "std::shared_ptr": ["swap", "operator=", "reset"]
+  }
+
+`FunctionAllowList`
+^^^^^^^^^^^^^^^^^^^
+List of functions that are considered not to read some of their arguments
+unless their return value is read. Arguments are identified by index (starting
+from 0): the value `i` being present in the array implies that the `i`-th
+argument is unused. If the array is empty, all arguments are unused. 
+
+The default value for this configuration option is
+
+.. code-block:: json
+
+  {
+    "absl::CordAppend": [0],
+    "absl::CordCat": [],
+    "absl::CordContains": [],
+    "absl::CordSplit": [],
+    "absl::CordJoin": [],
+    "absl::StringPrintf": [],
+    "absl::StrAppend": [0],
+    "absl::StrCat": [],
+    "absl::StrContains": [],
+    "absl::StrSplit": [],
+    "absl::StrJoin": [],
+    "absl::Substitute": [],
+    "absl::SubstituteAndAppend": [0]
+  }

clang-tools-extra/test/clang-tidy/checkers/performance-unused-no-side-effect.cpp

+// RUN: %check_clang_tidy %s performance-unused-no-side-effect %t -- \
+// RUN:  -config="{CheckOptions: [{key: \"performance-unused-no-side-effect.TypesByBase\", value: '{\"Marker\":[\"swap\"]}'}]}"
+
+namespace std {
+
+template <class CharT>
+struct char_traits {};
+
+template <class CharT>
+struct allocator {};
+
+template <
+    class CharT,
+    class Traits = std::char_traits<CharT>,
+    class Allocator = std::allocator<CharT>>
+class basic_string {
+public:
+  basic_string &operator+=(const char *);
+  ~basic_string();
+};
+
+using string = basic_string<char>;
+
+class thread {
+public:
+  ~thread();
+};
+
+template <typename T, typename Allocator = std::allocator<T>>
+class vector {
+public:
+  void push_back(T);
+};
+
+template <typename T>
+class unique_ptr {
+public:
+  unique_ptr(T *);
+};
+
+} // namespace std
+
+struct Marker {
+};
+
+struct SideEffectFree : Marker {
+  SideEffectFree();
+  ~SideEffectFree();
+  void swap(SideEffectFree *);
+};
+
+struct POD {
+  int A;
+};
+
+template <typename T, typename U>
+struct CustomPair {
+  T t;
+  U u;
+};
+
+void f(const std::string &);
+
+void unusedString() {
+  std::string SomeString;
+  // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: variable 'SomeString' is never read [performance-unused-no-side-effect]
+}
+
+void unusedStringWithMethodCall() {
+  std::string SomeString;
+  // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: variable 'SomeString' is never read [performance-unused-no-side-effect]
+  SomeString += "hi";
+}
+
+void unusedStdThread() {
+  std::thread T;
+}
+
+void usedString() {
+  std::string SomeString;
+  SomeString += "hi";
+  f(SomeString);
+}
+
+void vectorString() {
+  std::vector<std::string> VecString;
+  // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: variable 'VecString' is never read [performance-unused-no-side-effect]
+  VecString.push_back(std::string{});
+}
+
+void vectorThread() {
+  std::vector<std::thread> VecThread;
+  VecThread.push_back(std::thread{});
+}
+
+void withMarker() {
+  SideEffectFree M;
+  // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: variable 'M' is never read [performance-unused-no-side-effect]
+}
+
+void withMarkerAndExcludedMethod(SideEffectFree *S) {
+  SideEffectFree M;
+  M.swap(S);
+}
+
+void withPOD() {
+  POD P;
+  // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: variable 'P' is never read [performance-unused-no-side-effect]
+  P.A = 1;
+}
+
+int withPODReturn() {
+  POD P;
+  P.A = 1;
+  return P.A;
+}
+
+void withLoops() {
+  std::vector<int> VecLoops;
+  // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: variable 'VecLoops' is never read [performance-unused-no-side-effect]
+  for (int i = 0; i < 15; i++) {
+    VecLoops.push_back(1);
+  }
+  int j = 0;
+  while (j < 1) {
+    VecLoops.push_back(2);
+    j++;
+  }
+  (VecLoops).push_back(3);
+}
+
+void withSmartPointer(int *Arg) {
+  std::unique_ptr<int> Unused(new int);
+  // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: variable 'Unused' is never read [performance-unused-no-side-effect]
+
+  std::unique_ptr<int> Used(Arg);
+}
+
+void withCustomPair() {
+  CustomPair<std::string, std::vector<int>> Unused{};
+  // CHECK-MESSAGES: :[[@LINE-1]]:45: warning: variable 'Unused' is never read [performance-unused-no-side-effect]
+
+  CustomPair<int, std::thread> Used;
+}