ReturnBracedInitListCheck.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 "ReturnBracedInitListCheck.h"
#include "../utils/TypeTraits.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/DeclTemplate.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/Lex/Lexer.h"
 
using namespace clang::ast_matchers;
 
namespace clang::tidy::modernize {
 
static bool hasInitListConstructor(const CXXRecordDecl *RD) {
  if (RD == nullptr || !RD->hasDefinition())
    return false;
  auto IsInitListCtor = [](const CXXConstructorDecl *Ctor) {
    return Ctor->hasOneParamOrDefaultArgs() &&
           utils::type_traits::isStdInitializerList(
               Ctor->getParamDecl(0)->getType().getNonReferenceType());
  };
  auto TestDecl = [&](const Decl *D) {
    if (const auto *Ctor = dyn_cast<CXXConstructorDecl>(D))
      return IsInitListCtor(Ctor);
    if (const auto *FTD = dyn_cast<FunctionTemplateDecl>(D))
      if (const auto *Ctor =
              dyn_cast<CXXConstructorDecl>(FTD->getTemplatedDecl()))
        return IsInitListCtor(Ctor);
    return false;
  };
  const ASTContext &Ctx = RD->getASTContext();
  const DeclarationName Name =
      Ctx.DeclarationNames.getCXXConstructorName(Ctx.getCanonicalTagType(RD));
  return llvm::any_of(RD->lookup(Name), [&](const NamedDecl *D) {
    if (const auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(D))
      return TestDecl(Shadow->getTargetDecl());
    return TestDecl(D);
  });
}
 
void ReturnBracedInitListCheck::registerMatchers(MatchFinder *Finder) {
  auto SemanticallyDifferentContainer = allOf(
      hasDeclaration(
          // Container(size_type count, const T &value,
          //           const Allocator &alloc = Allocator());
          cxxConstructorDecl(parameterCountIs(3),
                             hasParameter(0, hasType(qualType(hasCanonicalType(
                                                 isInteger())))))),
      hasType(cxxRecordDecl(hasAnyName("::std::basic_string", "::std::vector",
                                       "::std::deque", "::std::forward_list",
                                       "::std::list"))));
 
  const auto ConstructExpr =
      cxxConstructExpr(
          unless(anyOf(
              // Skip explicit constructor.
              hasDeclaration(cxxConstructorDecl(isExplicit())),
              // Skip list initialization and constructors with an initializer
              // list.
              isListInitialization(), hasDescendant(initListExpr()),
              // Skip container `vector(size_type, const T&, ...)`.
              SemanticallyDifferentContainer)))
          .bind("ctor");
 
  Finder->addMatcher(
      returnStmt(hasReturnValue(ConstructExpr),
                 forFunction(functionDecl(returns(unless(anyOf(builtinType(),
                                                               autoType()))))
                                 .bind("fn"))),
      this);
}
 
void ReturnBracedInitListCheck::check(const MatchFinder::MatchResult &Result) {
  const auto *MatchedFunctionDecl = Result.Nodes.getNodeAs<FunctionDecl>("fn");
  const auto *MatchedConstructExpr =
      Result.Nodes.getNodeAs<CXXConstructExpr>("ctor");
 
  // Don't make replacements in macro.
  const SourceLocation Loc = MatchedConstructExpr->getExprLoc();
  if (Loc.isMacroID())
    return;
 
  // Make sure that the return type matches the constructed type.
  const QualType ReturnType =
      MatchedFunctionDecl->getReturnType().getCanonicalType();
  const QualType ConstructType =
      MatchedConstructExpr->getType().getCanonicalType();
  if (ReturnType != ConstructType)
    return;
 
  // Rewriting `T(args)` to a braced-init-list changes overload resolution when
  // `T` has a std::initializer_list constructor: list-initialization prefers
  // the initializer_list overload, so the braced form may silently select a
  // different constructor than the parenthesized call.
  if (hasInitListConstructor(ConstructType->getAsCXXRecordDecl()))
    return;
 
  const auto Diag =
      diag(Loc, "avoid repeating the return type from the "
                "declaration; use a braced initializer list instead");
 
  const SourceRange CallParensRange =
      MatchedConstructExpr->getParenOrBraceRange();
 
  // Make sure there is an explicit constructor call.
  if (CallParensRange.isInvalid())
    return;
 
  // Make sure that the ctor arguments match the declaration.
  for (unsigned I = 0, NumParams = MatchedConstructExpr->getNumArgs();
       I < NumParams; ++I) {
    if (const ParmVarDecl *VD =
            MatchedConstructExpr->getConstructor()->getParamDecl(I)) {
      const auto ArgType = MatchedConstructExpr->getArg(I)->getType();
      const auto ParamType = VD->getType().getNonReferenceType();
      if (ArgType.getCanonicalType().getUnqualifiedType() !=
          ParamType.getCanonicalType().getUnqualifiedType())
        return;
    }
  }
 
  // Range for constructor name and opening brace.
  const CharSourceRange CtorCallSourceRange = CharSourceRange::getTokenRange(
      Loc, CallParensRange.getBegin().getLocWithOffset(-1));
 
  Diag << FixItHint::CreateRemoval(CtorCallSourceRange)
       << FixItHint::CreateReplacement(CallParensRange.getBegin(), "{")
       << FixItHint::CreateReplacement(CallParensRange.getEnd(), "}");
}
 
} // namespace clang::tidy::modernize