UnnecessaryCopyInitialization.cpp

Go to the documentation of this file.

//===----------------------------------------------------------------------===//
//
// 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 "UnnecessaryCopyInitialization.h"
#include "../utils/DeclRefExprUtils.h"
#include "../utils/FixItHintUtils.h"
#include "../utils/LexerUtils.h"
#include "../utils/Matchers.h"
#include "../utils/OptionsUtils.h"
#include "clang/AST/Decl.h"
#include "clang/Basic/Diagnostic.h"
#include <optional>
 
namespace clang::tidy::performance {
 
using namespace ::clang::ast_matchers;
using llvm::StringRef;
using utils::decl_ref_expr::allDeclRefExprs;
using utils::decl_ref_expr::isOnlyUsedAsConst;
 
static constexpr StringRef ObjectArgId = "objectArg";
static constexpr StringRef InitFunctionCallId = "initFunctionCall";
static constexpr StringRef MethodDeclId = "methodDecl";
static constexpr StringRef FunctionDeclId = "functionDecl";
static constexpr StringRef OldVarDeclId = "oldVarDecl";
 
static void recordFixes(const VarDecl &Var, ASTContext &Context,
                        DiagnosticBuilder &Diagnostic) {
  Diagnostic << utils::fixit::changeVarDeclToReference(Var, Context);
  if (!Var.getType().isLocalConstQualified()) {
    if (std::optional<FixItHint> Fix = utils::fixit::addQualifierToVarDecl(
            Var, Context, Qualifiers::Const))
      Diagnostic << *Fix;
  }
}
 
static std::optional<SourceLocation> firstLocAfterNewLine(SourceLocation Loc,
                                                          SourceManager &SM) {
  bool Invalid = false;
  const char *TextAfter = SM.getCharacterData(Loc, &Invalid);
  if (Invalid) {
    return std::nullopt;
  }
  size_t Offset = std::strcspn(TextAfter, "\n");
  return Loc.getLocWithOffset(TextAfter[Offset] == '\0' ? Offset : Offset + 1);
}
 
static void recordRemoval(const DeclStmt &Stmt, ASTContext &Context,
                          DiagnosticBuilder &Diagnostic) {
  auto &SM = Context.getSourceManager();
  // Attempt to remove trailing comments as well.
  auto Tok = utils::lexer::findNextTokenSkippingComments(Stmt.getEndLoc(), SM,
                                                         Context.getLangOpts());
  std::optional<SourceLocation> PastNewLine =
      firstLocAfterNewLine(Stmt.getEndLoc(), SM);
  if (Tok && PastNewLine) {
    auto BeforeFirstTokenAfterComment = Tok->getLocation().getLocWithOffset(-1);
    // Remove until the end of the line or the end of a trailing comment which
    // ever comes first.
    auto End =
        SM.isBeforeInTranslationUnit(*PastNewLine, BeforeFirstTokenAfterComment)
            ? *PastNewLine
            : BeforeFirstTokenAfterComment;
    Diagnostic << FixItHint::CreateRemoval(
        SourceRange(Stmt.getBeginLoc(), End));
  } else {
    Diagnostic << FixItHint::CreateRemoval(Stmt.getSourceRange());
  }
}
 
namespace {
 
AST_MATCHER_FUNCTION_P(StatementMatcher,
                       isRefReturningMethodCallWithConstOverloads,
                       std::vector<StringRef>, ExcludedContainerTypes) {
  // Match method call expressions where the `this` argument is only used as
  // const, this will be checked in `check()` part. This returned reference is
  // highly likely to outlive the local const reference of the variable being
  // declared. The assumption is that the reference being returned either points
  // to a global static variable or to a member of the called object.
  const auto MethodDecl =
      cxxMethodDecl(returns(hasCanonicalType(referenceType())))
          .bind(MethodDeclId);
  const auto ReceiverExpr =
      ignoringParenImpCasts(declRefExpr(to(varDecl().bind(ObjectArgId))));
  const auto OnExpr = anyOf(
      // Direct reference to `*this`: `a.f()` or `a->f()`.
      ReceiverExpr,
      // Access through dereference, typically used for `operator[]`: `(*a)[3]`.
      unaryOperator(hasOperatorName("*"), hasUnaryOperand(ReceiverExpr)));
  const auto ReceiverType =
      hasCanonicalType(recordType(hasDeclaration(namedDecl(
          unless(matchers::matchesAnyListedName(ExcludedContainerTypes))))));
 
  return expr(
      anyOf(cxxMemberCallExpr(callee(MethodDecl), on(OnExpr),
                              thisPointerType(ReceiverType)),
            cxxOperatorCallExpr(callee(MethodDecl), hasArgument(0, OnExpr),
                                hasArgument(0, hasType(ReceiverType)))));
}
 
AST_MATCHER(CXXMethodDecl, isStatic) { return Node.isStatic(); }
 
AST_MATCHER_FUNCTION(StatementMatcher, isConstRefReturningFunctionCall) {
  // Only allow initialization of a const reference from a free function or
  // static member function if it has no arguments. Otherwise it could return
  // an alias to one of its arguments and the arguments need to be checked
  // for const use as well.
  return callExpr(argumentCountIs(0),
                  callee(functionDecl(returns(hasCanonicalType(
                                          matchers::isReferenceToConst())),
                                      unless(cxxMethodDecl(unless(isStatic()))))
                             .bind(FunctionDeclId)))
      .bind(InitFunctionCallId);
}
 
AST_MATCHER_FUNCTION_P(StatementMatcher, initializerReturnsReferenceToConst,
                       std::vector<StringRef>, ExcludedContainerTypes) {
  auto OldVarDeclRef =
      declRefExpr(to(varDecl(hasLocalStorage()).bind(OldVarDeclId)));
  return expr(
      anyOf(isConstRefReturningFunctionCall(),
            isRefReturningMethodCallWithConstOverloads(ExcludedContainerTypes),
            ignoringImpCasts(OldVarDeclRef),
            ignoringImpCasts(unaryOperator(hasOperatorName("&"),
                                           hasUnaryOperand(OldVarDeclRef)))));
}
 
} // namespace
 
// This checks that the variable itself is only used as const, and also makes
// sure that it does not reference another variable that could be modified in
// the BlockStmt. It does this by checking the following:
// 1. If the variable is neither a reference nor a pointer then the
// isOnlyUsedAsConst() check is sufficient.
// 2. If the (reference or pointer) variable is not initialized in a DeclStmt in
// the BlockStmt. In this case its pointee is likely not modified (unless it
// is passed as an alias into the method as well).
// 3. If the reference is initialized from a reference to const. This is
// the same set of criteria we apply when identifying the unnecessary copied
// variable in this check to begin with. In this case we check whether the
// object arg or variable that is referenced is immutable as well.
static bool isInitializingVariableImmutable(
    const VarDecl &InitializingVar, const Stmt &BlockStmt, ASTContext &Context,
    const std::vector<StringRef> &ExcludedContainerTypes) {
  QualType T = InitializingVar.getType().getCanonicalType();
  if (!isOnlyUsedAsConst(InitializingVar, BlockStmt, Context,
                         T->isPointerType() ? 1 : 0))
    return false;
 
  // The variable is a value type and we know it is only used as const. Safe
  // to reference it and avoid the copy.
  if (!isa<ReferenceType, PointerType>(T))
    return true;
 
  // The reference or pointer is not declared and hence not initialized anywhere
  // in the function. We assume its pointee is not modified then.
  if (!InitializingVar.isLocalVarDecl() || !InitializingVar.hasInit()) {
    return true;
  }
 
  auto Matches =
      match(initializerReturnsReferenceToConst(ExcludedContainerTypes),
            *InitializingVar.getInit(), Context);
  // The reference is initialized from a free function without arguments
  // returning a const reference. This is a global immutable object.
  if (selectFirst<CallExpr>(InitFunctionCallId, Matches) != nullptr)
    return true;
  // Check that the object argument is immutable as well.
  if (const auto *OrigVar = selectFirst<VarDecl>(ObjectArgId, Matches))
    return isInitializingVariableImmutable(*OrigVar, BlockStmt, Context,
                                           ExcludedContainerTypes);
  // Check that the old variable we reference is immutable as well.
  if (const auto *OrigVar = selectFirst<VarDecl>(OldVarDeclId, Matches))
    return isInitializingVariableImmutable(*OrigVar, BlockStmt, Context,
                                           ExcludedContainerTypes);
 
  return false;
}
 
static bool isVariableUnused(const VarDecl &Var, const Stmt &BlockStmt,
                             ASTContext &Context) {
  return allDeclRefExprs(Var, BlockStmt, Context).empty();
}
 
static const SubstTemplateTypeParmType *
getSubstitutedType(const QualType &Type, ASTContext &Context) {
  auto Matches = match(
      qualType(anyOf(substTemplateTypeParmType().bind("subst"),
                     hasDescendant(substTemplateTypeParmType().bind("subst")))),
      Type, Context);
  return selectFirst<SubstTemplateTypeParmType>("subst", Matches);
}
 
static bool differentReplacedTemplateParams(const QualType &VarType,
                                            const QualType &InitializerType,
                                            ASTContext &Context) {
  if (const SubstTemplateTypeParmType *VarTmplType =
          getSubstitutedType(VarType, Context)) {
    if (const SubstTemplateTypeParmType *InitializerTmplType =
            getSubstitutedType(InitializerType, Context)) {
      const TemplateTypeParmDecl *VarTTP = VarTmplType->getReplacedParameter();
      const TemplateTypeParmDecl *InitTTP =
          InitializerTmplType->getReplacedParameter();
      return (VarTTP->getDepth() != InitTTP->getDepth() ||
              VarTTP->getIndex() != InitTTP->getIndex() ||
              VarTTP->isParameterPack() != InitTTP->isParameterPack());
    }
  }
  return false;
}
 
static QualType constructorArgumentType(const VarDecl *OldVar,
                                        const BoundNodes &Nodes) {
  if (OldVar) {
    return OldVar->getType();
  }
  if (const auto *FuncDecl = Nodes.getNodeAs<FunctionDecl>(FunctionDeclId)) {
    return FuncDecl->getReturnType();
  }
  const auto *MethodDecl = Nodes.getNodeAs<CXXMethodDecl>(MethodDeclId);
  return MethodDecl->getReturnType();
}
 
UnnecessaryCopyInitialization::UnnecessaryCopyInitialization(
    StringRef Name, ClangTidyContext *Context)
    : ClangTidyCheck(Name, Context),
      AllowedTypes(
          utils::options::parseStringList(Options.get("AllowedTypes", ""))),
      ExcludedContainerTypes(utils::options::parseStringList(
          Options.get("ExcludedContainerTypes", ""))) {}
 
void UnnecessaryCopyInitialization::registerMatchers(MatchFinder *Finder) {
  auto LocalVarCopiedFrom =
      [this](const ast_matchers::internal::Matcher<Expr> &CopyCtorArg) {
        return compoundStmt(
                   forEachDescendant(
                       declStmt(
                           unless(has(decompositionDecl())),
                           has(varDecl(
                                   hasLocalStorage(),
                                   hasType(qualType(
                                       hasCanonicalType(allOf(
                                           matchers::isExpensiveToCopy(),
                                           unless(hasDeclaration(namedDecl(
                                               hasName("::std::function")))))),
                                       unless(hasDeclaration(namedDecl(
                                           matchers::matchesAnyListedName(
                                               AllowedTypes)))))),
                                   unless(isImplicit()),
                                   hasInitializer(traverse(
                                       TK_AsIs,
                                       cxxConstructExpr(
                                           hasDeclaration(cxxConstructorDecl(
                                               isCopyConstructor())),
                                           hasArgument(0, CopyCtorArg))
                                           .bind("ctorCall"))))
                                   .bind("newVarDecl")))
                           .bind("declStmt")))
            .bind("blockStmt");
      };
 
  Finder->addMatcher(
      LocalVarCopiedFrom(anyOf(
          isConstRefReturningFunctionCall(),
          isRefReturningMethodCallWithConstOverloads(ExcludedContainerTypes))),
      this);
 
  Finder->addMatcher(LocalVarCopiedFrom(declRefExpr(
                         to(varDecl(hasLocalStorage()).bind(OldVarDeclId)))),
                     this);
}
 
void UnnecessaryCopyInitialization::check(
    const MatchFinder::MatchResult &Result) {
  const auto &NewVar = *Result.Nodes.getNodeAs<VarDecl>("newVarDecl");
  const auto &BlockStmt = *Result.Nodes.getNodeAs<Stmt>("blockStmt");
  const auto &VarDeclStmt = *Result.Nodes.getNodeAs<DeclStmt>("declStmt");
  // Do not propose fixes if the DeclStmt has multiple VarDecls or in
  // macros since we cannot place them correctly.
  const bool IssueFix =
      VarDeclStmt.isSingleDecl() && !NewVar.getLocation().isMacroID();
  const bool IsVarUnused = isVariableUnused(NewVar, BlockStmt, *Result.Context);
  const bool IsVarOnlyUsedAsConst =
      isOnlyUsedAsConst(NewVar, BlockStmt, *Result.Context,
                        // `NewVar` is always of non-pointer type.
                        0);
  const CheckContext Context{
      NewVar,   BlockStmt,   VarDeclStmt,         *Result.Context,
      IssueFix, IsVarUnused, IsVarOnlyUsedAsConst};
  const auto *OldVar = Result.Nodes.getNodeAs<VarDecl>(OldVarDeclId);
  const auto *ObjectArg = Result.Nodes.getNodeAs<VarDecl>(ObjectArgId);
  const auto *CtorCall = Result.Nodes.getNodeAs<CXXConstructExpr>("ctorCall");
 
  TraversalKindScope RAII(*Result.Context, TK_AsIs);
 
  // A constructor that looks like T(const T& t, bool arg = false) counts as a
  // copy only when it is called with default arguments for the arguments after
  // the first.
  for (unsigned int I = 1; I < CtorCall->getNumArgs(); ++I)
    if (!CtorCall->getArg(I)->isDefaultArgument())
      return;
 
  // Don't apply the check if the variable and its initializer have different
  // replaced template parameter types. In this case the check triggers for a
  // template instantiation where the substituted types are the same, but
  // instantiations where the types differ and rely on implicit conversion would
  // no longer compile if we switched to a reference.
  if (differentReplacedTemplateParams(
          Context.Var.getType(), constructorArgumentType(OldVar, Result.Nodes),
          *Result.Context))
    return;
 
  if (OldVar == nullptr) {
    // `auto NewVar = functionCall();`
    handleCopyFromMethodReturn(Context, ObjectArg);
  } else {
    // `auto NewVar = OldVar;`
    handleCopyFromLocalVar(Context, *OldVar);
  }
}
 
void UnnecessaryCopyInitialization::handleCopyFromMethodReturn(
    const CheckContext &Ctx, const VarDecl *ObjectArg) {
  bool IsConstQualified = Ctx.Var.getType().isConstQualified();
  if (!IsConstQualified && !Ctx.IsVarOnlyUsedAsConst)
    return;
  if (ObjectArg != nullptr &&
      !isInitializingVariableImmutable(*ObjectArg, Ctx.BlockStmt, Ctx.ASTCtx,
                                       ExcludedContainerTypes))
    return;
  diagnoseCopyFromMethodReturn(Ctx);
}
 
void UnnecessaryCopyInitialization::handleCopyFromLocalVar(
    const CheckContext &Ctx, const VarDecl &OldVar) {
  if (!Ctx.IsVarOnlyUsedAsConst ||
      !isInitializingVariableImmutable(OldVar, Ctx.BlockStmt, Ctx.ASTCtx,
                                       ExcludedContainerTypes))
    return;
  diagnoseCopyFromLocalVar(Ctx, OldVar);
}
 
void UnnecessaryCopyInitialization::diagnoseCopyFromMethodReturn(
    const CheckContext &Ctx) {
  auto Diagnostic =
      diag(Ctx.Var.getLocation(),
           "the %select{|const qualified }0variable %1 of type %2 is "
           "copy-constructed "
           "from a const reference%select{%select{ but is only used as const "
           "reference|}0| but is never used}3; consider "
           "%select{making it a const reference|removing the statement}3")
      << Ctx.Var.getType().isConstQualified() << &Ctx.Var << Ctx.Var.getType()
      << Ctx.IsVarUnused;
  maybeIssueFixes(Ctx, Diagnostic);
}
 
void UnnecessaryCopyInitialization::diagnoseCopyFromLocalVar(
    const CheckContext &Ctx, const VarDecl &OldVar) {
  auto Diagnostic =
      diag(Ctx.Var.getLocation(),
           "local copy %0 of the variable %1 of type %2 is never "
           "modified%select{"
           "| and never used}3; consider %select{avoiding the copy|removing "
           "the statement}3")
      << &Ctx.Var << &OldVar << Ctx.Var.getType() << Ctx.IsVarUnused;
  maybeIssueFixes(Ctx, Diagnostic);
}
 
void UnnecessaryCopyInitialization::maybeIssueFixes(
    const CheckContext &Ctx, DiagnosticBuilder &Diagnostic) {
  if (Ctx.IssueFix) {
    if (Ctx.IsVarUnused)
      recordRemoval(Ctx.VarDeclStmt, Ctx.ASTCtx, Diagnostic);
    else
      recordFixes(Ctx.Var, Ctx.ASTCtx, Diagnostic);
  }
}
 
void UnnecessaryCopyInitialization::storeOptions(
    ClangTidyOptions::OptionMap &Opts) {
  Options.store(Opts, "AllowedTypes",
                utils::options::serializeStringList(AllowedTypes));
  Options.store(Opts, "ExcludedContainerTypes",
                utils::options::serializeStringList(ExcludedContainerTypes));
}
 
} // namespace clang::tidy::performance