Use hasLocalStorage() to identify unnecessary copy initializations to exclude static local variables.

[flx]

Summary

Since local static variables can outlive other local variables exclude them from the unnecessary copy initialization check.

[alexfh]

LG. I'll commit the patch.

[flx]

Thanks, Alex!

clang-tidy/performance/UnnecessaryCopyInitialization.cpp

 
 namespace clang {
 namespace tidy {
 namespace performance {
 
 using namespace ::clang::ast_matchers;
 
 namespace {
-AST_MATCHER(VarDecl, isLocalVarDecl) { return Node.isLocalVarDecl(); }
 AST_MATCHER(QualType, isPointerType) { return Node->isPointerType(); }
 } // namespace
 
 void UnnecessaryCopyInitialization::registerMatchers(
     ast_matchers::MatchFinder *Finder) {
   auto ConstReference = referenceType(pointee(qualType(isConstQualified())));
   auto ConstOrConstReference =
       allOf(anyOf(ConstReference, isConstQualified()),
             unless(allOf(isPointerType(), unless(pointerType(pointee(qualType(
                                               isConstQualified())))))));
   // Match method call expressions where the this argument is a const
   // type or const reference. This returned const reference is highly likely to
   // outlive the local const reference of the variable being declared.
   // The assumption is that the const reference being returned either points
   // to a global static variable or to a member of the called object.
   auto ConstRefReturningMethodCallOfConstParam = cxxMemberCallExpr(
       callee(cxxMethodDecl(returns(ConstReference))),
       on(declRefExpr(to(varDecl(hasType(qualType(ConstOrConstReference)))))));
   auto ConstRefReturningFunctionCall =
       callExpr(callee(functionDecl(returns(ConstReference))),
                unless(callee(cxxMethodDecl())));
   Finder->addMatcher(
       varDecl(
-          isLocalVarDecl(), hasType(isConstQualified()),
+          hasLocalStorage(), hasType(isConstQualified()),
           hasType(matchers::isExpensiveToCopy()),
           hasInitializer(cxxConstructExpr(
               hasDeclaration(cxxConstructorDecl(isCopyConstructor())),
               hasArgument(0, anyOf(ConstRefReturningFunctionCall,
                                    ConstRefReturningMethodCallOfConstParam)))))
           .bind("varDecl"),
       this);
 }

test/clang-tidy/performance-unnecessary-copy-initialization.cpp

 
 void NegativeFunctionCallTrivialType() {
   const auto AutoAssigned = TrivialTypeReference();
   const auto AutoCopyConstructed(TrivialTypeReference());
   const TrivialToCopyType VarAssigned = TrivialTypeReference();
   const TrivialToCopyType VarCopyConstructed(TrivialTypeReference());
 }
 
+void NegativeStaticLocalVar(const ExpensiveToCopyType &Obj) {
+  static const auto StaticVar = Obj.reference();
+}
+
 void NegativeFunctionCallExpensiveTypeNonConstVariable() {
   auto AutoAssigned = ExpensiveTypeReference();
   auto AutoCopyConstructed(ExpensiveTypeReference());
   ExpensiveToCopyType VarAssigned = ExpensiveTypeReference();
   ExpensiveToCopyType VarCopyConstructed(ExpensiveTypeReference());
 }
 
 void NegativeMethodCallNonConstRef(ExpensiveToCopyType &Obj) {