2016-05-03 00:56:39 +08:00
|
|
|
//===--- MakeSmartPtrCheck.cpp - clang-tidy--------------------------------===//
|
|
|
|
//
|
2019-01-19 16:50:56 +08:00
|
|
|
// 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
|
2016-05-03 00:56:39 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "MakeSharedCheck.h"
|
2017-07-05 15:49:00 +08:00
|
|
|
#include "clang/Frontend/CompilerInstance.h"
|
2016-05-03 00:56:39 +08:00
|
|
|
#include "clang/Lex/Lexer.h"
|
2017-07-05 15:49:00 +08:00
|
|
|
#include "clang/Lex/Preprocessor.h"
|
2016-05-03 00:56:39 +08:00
|
|
|
|
|
|
|
using namespace clang::ast_matchers;
|
|
|
|
|
|
|
|
namespace clang {
|
|
|
|
namespace tidy {
|
|
|
|
namespace modernize {
|
|
|
|
|
2017-06-27 16:31:27 +08:00
|
|
|
namespace {
|
2017-07-05 15:49:00 +08:00
|
|
|
|
|
|
|
constexpr char StdMemoryHeader[] = "memory";
|
2018-10-09 23:58:18 +08:00
|
|
|
constexpr char ConstructorCall[] = "constructorCall";
|
|
|
|
constexpr char ResetCall[] = "resetCall";
|
|
|
|
constexpr char NewExpression[] = "newExpression";
|
2017-07-05 15:49:00 +08:00
|
|
|
|
2017-06-28 00:25:05 +08:00
|
|
|
std::string GetNewExprName(const CXXNewExpr *NewExpr,
|
|
|
|
const SourceManager &SM,
|
|
|
|
const LangOptions &Lang) {
|
|
|
|
StringRef WrittenName = Lexer::getSourceText(
|
2017-06-27 16:31:27 +08:00
|
|
|
CharSourceRange::getTokenRange(
|
|
|
|
NewExpr->getAllocatedTypeSourceInfo()->getTypeLoc().getSourceRange()),
|
|
|
|
SM, Lang);
|
2017-06-28 00:25:05 +08:00
|
|
|
if (NewExpr->isArray()) {
|
2018-10-09 23:58:18 +08:00
|
|
|
return (WrittenName + "[]").str();
|
2017-06-28 00:25:05 +08:00
|
|
|
}
|
|
|
|
return WrittenName.str();
|
2017-06-27 16:31:27 +08:00
|
|
|
}
|
2017-07-05 15:49:00 +08:00
|
|
|
|
2017-06-27 16:31:27 +08:00
|
|
|
} // namespace
|
|
|
|
|
2016-05-03 00:56:39 +08:00
|
|
|
const char MakeSmartPtrCheck::PointerType[] = "pointerType";
|
|
|
|
|
2017-08-04 19:18:00 +08:00
|
|
|
MakeSmartPtrCheck::MakeSmartPtrCheck(StringRef Name,
|
|
|
|
ClangTidyContext* Context,
|
2017-07-05 15:49:00 +08:00
|
|
|
StringRef MakeSmartPtrFunctionName)
|
2016-05-03 00:56:39 +08:00
|
|
|
: ClangTidyCheck(Name, Context),
|
2017-07-05 15:49:00 +08:00
|
|
|
IncludeStyle(utils::IncludeSorter::parseIncludeStyle(
|
2017-07-20 20:02:03 +08:00
|
|
|
Options.getLocalOrGlobal("IncludeStyle", "llvm"))),
|
2017-07-05 15:49:00 +08:00
|
|
|
MakeSmartPtrFunctionHeader(
|
|
|
|
Options.get("MakeSmartPtrFunctionHeader", StdMemoryHeader)),
|
|
|
|
MakeSmartPtrFunctionName(
|
2017-08-04 19:18:00 +08:00
|
|
|
Options.get("MakeSmartPtrFunction", MakeSmartPtrFunctionName)),
|
|
|
|
IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true)) {}
|
2017-07-05 15:49:00 +08:00
|
|
|
|
|
|
|
void MakeSmartPtrCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
|
|
|
|
Options.store(Opts, "IncludeStyle", IncludeStyle);
|
|
|
|
Options.store(Opts, "MakeSmartPtrFunctionHeader", MakeSmartPtrFunctionHeader);
|
|
|
|
Options.store(Opts, "MakeSmartPtrFunction", MakeSmartPtrFunctionName);
|
2017-08-04 19:18:00 +08:00
|
|
|
Options.store(Opts, "IgnoreMacros", IgnoreMacros);
|
2017-07-05 15:49:00 +08:00
|
|
|
}
|
|
|
|
|
2018-03-21 22:39:24 +08:00
|
|
|
bool MakeSmartPtrCheck::isLanguageVersionSupported(
|
|
|
|
const LangOptions &LangOpts) const {
|
|
|
|
return LangOpts.CPlusPlus11;
|
|
|
|
}
|
|
|
|
|
2017-07-05 15:49:00 +08:00
|
|
|
void MakeSmartPtrCheck::registerPPCallbacks(CompilerInstance &Compiler) {
|
2018-03-21 22:39:24 +08:00
|
|
|
if (isLanguageVersionSupported(getLangOpts())) {
|
2018-10-09 23:58:18 +08:00
|
|
|
Inserter = llvm::make_unique<utils::IncludeInserter>(
|
|
|
|
Compiler.getSourceManager(), Compiler.getLangOpts(), IncludeStyle);
|
2017-07-05 15:49:00 +08:00
|
|
|
Compiler.getPreprocessor().addPPCallbacks(Inserter->CreatePPCallbacks());
|
|
|
|
}
|
|
|
|
}
|
2016-05-03 00:56:39 +08:00
|
|
|
|
|
|
|
void MakeSmartPtrCheck::registerMatchers(ast_matchers::MatchFinder *Finder) {
|
2018-03-21 22:39:24 +08:00
|
|
|
if (!isLanguageVersionSupported(getLangOpts()))
|
2016-05-03 00:56:39 +08:00
|
|
|
return;
|
|
|
|
|
2016-08-31 08:06:55 +08:00
|
|
|
// Calling make_smart_ptr from within a member function of a type with a
|
|
|
|
// private or protected constructor would be ill-formed.
|
2016-10-31 23:48:01 +08:00
|
|
|
auto CanCallCtor = unless(has(ignoringImpCasts(
|
|
|
|
cxxConstructExpr(hasDeclaration(decl(unless(isPublic())))))));
|
2016-08-31 08:06:55 +08:00
|
|
|
|
2016-05-03 00:56:39 +08:00
|
|
|
Finder->addMatcher(
|
2016-05-31 23:26:56 +08:00
|
|
|
cxxBindTemporaryExpr(has(ignoringParenImpCasts(
|
|
|
|
cxxConstructExpr(
|
|
|
|
hasType(getSmartPointerTypeMatcher()), argumentCountIs(1),
|
|
|
|
hasArgument(0,
|
|
|
|
cxxNewExpr(hasType(pointsTo(qualType(hasCanonicalType(
|
2016-08-31 08:06:55 +08:00
|
|
|
equalsBoundNode(PointerType))))),
|
|
|
|
CanCallCtor)
|
2017-08-17 22:12:38 +08:00
|
|
|
.bind(NewExpression)),
|
|
|
|
unless(isInTemplateInstantiation()))
|
2016-05-31 23:26:56 +08:00
|
|
|
.bind(ConstructorCall)))),
|
2016-05-03 00:56:39 +08:00
|
|
|
this);
|
2016-10-31 23:48:01 +08:00
|
|
|
|
|
|
|
Finder->addMatcher(
|
|
|
|
cxxMemberCallExpr(
|
|
|
|
thisPointerType(getSmartPointerTypeMatcher()),
|
|
|
|
callee(cxxMethodDecl(hasName("reset"))),
|
2017-08-17 22:12:38 +08:00
|
|
|
hasArgument(0, cxxNewExpr(CanCallCtor).bind(NewExpression)),
|
|
|
|
unless(isInTemplateInstantiation()))
|
2016-10-31 23:48:01 +08:00
|
|
|
.bind(ResetCall),
|
|
|
|
this);
|
2016-05-03 00:56:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void MakeSmartPtrCheck::check(const MatchFinder::MatchResult &Result) {
|
|
|
|
// 'smart_ptr' refers to 'std::shared_ptr' or 'std::unique_ptr' or other
|
|
|
|
// pointer, 'make_smart_ptr' refers to 'std::make_shared' or
|
|
|
|
// 'std::make_unique' or other function that creates smart_ptr.
|
|
|
|
|
|
|
|
SourceManager &SM = *Result.SourceManager;
|
|
|
|
const auto *Construct =
|
|
|
|
Result.Nodes.getNodeAs<CXXConstructExpr>(ConstructorCall);
|
2016-10-31 23:48:01 +08:00
|
|
|
const auto *Reset = Result.Nodes.getNodeAs<CXXMemberCallExpr>(ResetCall);
|
2016-05-03 00:56:39 +08:00
|
|
|
const auto *Type = Result.Nodes.getNodeAs<QualType>(PointerType);
|
|
|
|
const auto *New = Result.Nodes.getNodeAs<CXXNewExpr>(NewExpression);
|
|
|
|
|
|
|
|
if (New->getNumPlacementArgs() != 0)
|
|
|
|
return;
|
2018-11-26 20:42:08 +08:00
|
|
|
// Skip when this is a new-expression with `auto`, e.g. new auto(1)
|
|
|
|
if (New->getType()->getPointeeType()->getContainedAutoType())
|
|
|
|
return;
|
2016-05-03 00:56:39 +08:00
|
|
|
|
2018-10-18 17:13:34 +08:00
|
|
|
// Be conservative for cases where we construct an array without any
|
|
|
|
// initalization.
|
|
|
|
// For example,
|
|
|
|
// P.reset(new int[5]) // check fix: P = make_unique<int []>(5)
|
|
|
|
//
|
|
|
|
// The fix of the check has side effect, it introduces default initialization
|
|
|
|
// which maybe unexpected and cause performance regression.
|
|
|
|
if (New->isArray() && !New->hasInitializer())
|
|
|
|
return;
|
2016-10-31 23:48:01 +08:00
|
|
|
if (Construct)
|
2018-10-09 23:58:18 +08:00
|
|
|
checkConstruct(SM, Result.Context, Construct, Type, New);
|
2016-10-31 23:48:01 +08:00
|
|
|
else if (Reset)
|
2018-10-09 23:58:18 +08:00
|
|
|
checkReset(SM, Result.Context, Reset, New);
|
2016-10-31 23:48:01 +08:00
|
|
|
}
|
|
|
|
|
2018-10-09 23:58:18 +08:00
|
|
|
void MakeSmartPtrCheck::checkConstruct(SourceManager &SM, ASTContext *Ctx,
|
2016-10-31 23:48:01 +08:00
|
|
|
const CXXConstructExpr *Construct,
|
|
|
|
const QualType *Type,
|
|
|
|
const CXXNewExpr *New) {
|
2016-05-03 00:56:39 +08:00
|
|
|
SourceLocation ConstructCallStart = Construct->getExprLoc();
|
2017-08-04 19:18:00 +08:00
|
|
|
bool InMacro = ConstructCallStart.isMacroID();
|
|
|
|
|
|
|
|
if (InMacro && IgnoreMacros) {
|
|
|
|
return;
|
|
|
|
}
|
2016-05-03 00:56:39 +08:00
|
|
|
|
|
|
|
bool Invalid = false;
|
|
|
|
StringRef ExprStr = Lexer::getSourceText(
|
|
|
|
CharSourceRange::getCharRange(
|
|
|
|
ConstructCallStart, Construct->getParenOrBraceRange().getBegin()),
|
2017-06-27 16:31:27 +08:00
|
|
|
SM, getLangOpts(), &Invalid);
|
2016-05-03 00:56:39 +08:00
|
|
|
if (Invalid)
|
|
|
|
return;
|
|
|
|
|
|
|
|
auto Diag = diag(ConstructCallStart, "use %0 instead")
|
2017-07-05 15:49:00 +08:00
|
|
|
<< MakeSmartPtrFunctionName;
|
2016-05-03 00:56:39 +08:00
|
|
|
|
2017-08-04 19:18:00 +08:00
|
|
|
// Disable the fix in macros.
|
|
|
|
if (InMacro) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-10-09 23:58:18 +08:00
|
|
|
if (!replaceNew(Diag, New, SM, Ctx)) {
|
2017-08-17 18:14:52 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-05-03 00:56:39 +08:00
|
|
|
// Find the location of the template's left angle.
|
|
|
|
size_t LAngle = ExprStr.find("<");
|
|
|
|
SourceLocation ConstructCallEnd;
|
|
|
|
if (LAngle == StringRef::npos) {
|
|
|
|
// If the template argument is missing (because it is part of the alias)
|
|
|
|
// we have to add it back.
|
|
|
|
ConstructCallEnd = ConstructCallStart.getLocWithOffset(ExprStr.size());
|
|
|
|
Diag << FixItHint::CreateInsertion(
|
2017-06-27 16:31:27 +08:00
|
|
|
ConstructCallEnd,
|
2017-06-28 00:25:05 +08:00
|
|
|
"<" + GetNewExprName(New, SM, getLangOpts()) + ">");
|
2016-05-03 00:56:39 +08:00
|
|
|
} else {
|
|
|
|
ConstructCallEnd = ConstructCallStart.getLocWithOffset(LAngle);
|
|
|
|
}
|
|
|
|
|
|
|
|
Diag << FixItHint::CreateReplacement(
|
|
|
|
CharSourceRange::getCharRange(ConstructCallStart, ConstructCallEnd),
|
2017-07-05 15:49:00 +08:00
|
|
|
MakeSmartPtrFunctionName);
|
2016-05-03 00:56:39 +08:00
|
|
|
|
|
|
|
// If the smart_ptr is built with brace enclosed direct initialization, use
|
|
|
|
// parenthesis instead.
|
|
|
|
if (Construct->isListInitialization()) {
|
|
|
|
SourceRange BraceRange = Construct->getParenOrBraceRange();
|
|
|
|
Diag << FixItHint::CreateReplacement(
|
|
|
|
CharSourceRange::getCharRange(
|
|
|
|
BraceRange.getBegin(), BraceRange.getBegin().getLocWithOffset(1)),
|
|
|
|
"(");
|
|
|
|
Diag << FixItHint::CreateReplacement(
|
|
|
|
CharSourceRange::getCharRange(BraceRange.getEnd(),
|
|
|
|
BraceRange.getEnd().getLocWithOffset(1)),
|
|
|
|
")");
|
|
|
|
}
|
|
|
|
|
2017-07-05 15:49:00 +08:00
|
|
|
insertHeader(Diag, SM.getFileID(ConstructCallStart));
|
2016-10-31 23:48:01 +08:00
|
|
|
}
|
|
|
|
|
2018-10-09 23:58:18 +08:00
|
|
|
void MakeSmartPtrCheck::checkReset(SourceManager &SM, ASTContext *Ctx,
|
2016-10-31 23:48:01 +08:00
|
|
|
const CXXMemberCallExpr *Reset,
|
|
|
|
const CXXNewExpr *New) {
|
|
|
|
const auto *Expr = cast<MemberExpr>(Reset->getCallee());
|
|
|
|
SourceLocation OperatorLoc = Expr->getOperatorLoc();
|
|
|
|
SourceLocation ResetCallStart = Reset->getExprLoc();
|
2018-08-10 06:42:26 +08:00
|
|
|
SourceLocation ExprStart = Expr->getBeginLoc();
|
2016-10-31 23:48:01 +08:00
|
|
|
SourceLocation ExprEnd =
|
2018-08-10 06:43:02 +08:00
|
|
|
Lexer::getLocForEndOfToken(Expr->getEndLoc(), 0, SM, getLangOpts());
|
2016-10-31 23:48:01 +08:00
|
|
|
|
2017-08-04 19:18:00 +08:00
|
|
|
bool InMacro = ExprStart.isMacroID();
|
|
|
|
|
|
|
|
if (InMacro && IgnoreMacros) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-08-10 01:03:42 +08:00
|
|
|
// There are some cases where we don't have operator ("." or "->") of the
|
|
|
|
// "reset" expression, e.g. call "reset()" method directly in the subclass of
|
|
|
|
// "std::unique_ptr<>". We skip these cases.
|
|
|
|
if (OperatorLoc.isInvalid()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-10-31 23:48:01 +08:00
|
|
|
auto Diag = diag(ResetCallStart, "use %0 instead")
|
2017-07-05 15:49:00 +08:00
|
|
|
<< MakeSmartPtrFunctionName;
|
2016-10-31 23:48:01 +08:00
|
|
|
|
2017-08-04 19:18:00 +08:00
|
|
|
// Disable the fix in macros.
|
|
|
|
if (InMacro) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-10-09 23:58:18 +08:00
|
|
|
if (!replaceNew(Diag, New, SM, Ctx)) {
|
2017-08-17 18:14:52 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-10-31 23:48:01 +08:00
|
|
|
Diag << FixItHint::CreateReplacement(
|
|
|
|
CharSourceRange::getCharRange(OperatorLoc, ExprEnd),
|
2017-07-05 15:49:00 +08:00
|
|
|
(llvm::Twine(" = ") + MakeSmartPtrFunctionName + "<" +
|
2017-06-27 16:31:27 +08:00
|
|
|
GetNewExprName(New, SM, getLangOpts()) + ">")
|
2016-10-31 23:48:01 +08:00
|
|
|
.str());
|
|
|
|
|
|
|
|
if (Expr->isArrow())
|
|
|
|
Diag << FixItHint::CreateInsertion(ExprStart, "*");
|
|
|
|
|
2017-07-05 15:49:00 +08:00
|
|
|
insertHeader(Diag, SM.getFileID(OperatorLoc));
|
2016-10-31 23:48:01 +08:00
|
|
|
}
|
|
|
|
|
2017-08-17 18:14:52 +08:00
|
|
|
bool MakeSmartPtrCheck::replaceNew(DiagnosticBuilder &Diag,
|
2018-10-09 23:58:18 +08:00
|
|
|
const CXXNewExpr *New, SourceManager &SM,
|
|
|
|
ASTContext *Ctx) {
|
|
|
|
auto SkipParensParents = [&](const Expr *E) {
|
|
|
|
for (const Expr *OldE = nullptr; E != OldE;) {
|
|
|
|
OldE = E;
|
|
|
|
for (const auto &Node : Ctx->getParents(*E)) {
|
|
|
|
if (const Expr *Parent = Node.get<ParenExpr>()) {
|
|
|
|
E = Parent;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return E;
|
|
|
|
};
|
|
|
|
|
|
|
|
SourceRange NewRange = SkipParensParents(New)->getSourceRange();
|
|
|
|
SourceLocation NewStart = NewRange.getBegin();
|
|
|
|
SourceLocation NewEnd = NewRange.getEnd();
|
2017-06-28 00:25:05 +08:00
|
|
|
|
2018-01-23 19:43:18 +08:00
|
|
|
// Skip when the source location of the new expression is invalid.
|
|
|
|
if (NewStart.isInvalid() || NewEnd.isInvalid())
|
|
|
|
return false;
|
|
|
|
|
2017-06-28 00:25:05 +08:00
|
|
|
std::string ArraySizeExpr;
|
|
|
|
if (const auto* ArraySize = New->getArraySize()) {
|
|
|
|
ArraySizeExpr = Lexer::getSourceText(CharSourceRange::getTokenRange(
|
|
|
|
ArraySize->getSourceRange()),
|
|
|
|
SM, getLangOpts())
|
|
|
|
.str();
|
|
|
|
}
|
2018-11-20 23:45:15 +08:00
|
|
|
// Returns true if the given constructor expression has any braced-init-list
|
|
|
|
// argument, e.g.
|
|
|
|
// Foo({1, 2}, 1) => true
|
|
|
|
// Foo(Bar{1, 2}) => true
|
|
|
|
// Foo(1) => false
|
|
|
|
// Foo{1} => false
|
|
|
|
auto HasListIntializedArgument = [](const CXXConstructExpr *CE) {
|
|
|
|
for (const auto *Arg : CE->arguments()) {
|
|
|
|
if (isa<CXXStdInitializerListExpr>(Arg) || isa<InitListExpr>(Arg))
|
|
|
|
return true;
|
|
|
|
// Check whether we implicitly construct a class from a
|
|
|
|
// std::initializer_list.
|
|
|
|
if (const auto *ImplicitCE =
|
|
|
|
dyn_cast<CXXConstructExpr>(Arg->IgnoreImplicit())) {
|
|
|
|
if (ImplicitCE->isStdInitListInitialization())
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
};
|
2016-05-03 00:56:39 +08:00
|
|
|
switch (New->getInitializationStyle()) {
|
|
|
|
case CXXNewExpr::NoInit: {
|
2017-06-28 00:25:05 +08:00
|
|
|
if (ArraySizeExpr.empty()) {
|
|
|
|
Diag << FixItHint::CreateRemoval(SourceRange(NewStart, NewEnd));
|
|
|
|
} else {
|
|
|
|
// New array expression without written initializer:
|
|
|
|
// smart_ptr<Foo[]>(new Foo[5]);
|
|
|
|
Diag << FixItHint::CreateReplacement(SourceRange(NewStart, NewEnd),
|
|
|
|
ArraySizeExpr);
|
|
|
|
}
|
2016-05-03 00:56:39 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case CXXNewExpr::CallInit: {
|
2017-08-24 21:35:55 +08:00
|
|
|
// FIXME: Add fixes for constructors with parameters that can be created
|
|
|
|
// with a C++11 braced-init-list (e.g. std::vector, std::map).
|
2017-08-17 18:14:52 +08:00
|
|
|
// Unlike ordinal cases, braced list can not be deduced in
|
|
|
|
// std::make_smart_ptr, we need to specify the type explicitly in the fixes:
|
|
|
|
// struct S { S(std::initializer_list<int>, int); };
|
2017-08-24 21:35:55 +08:00
|
|
|
// struct S2 { S2(std::vector<int>); };
|
2018-11-20 23:45:15 +08:00
|
|
|
// struct S3 { S3(S2, int); };
|
2017-08-17 18:14:52 +08:00
|
|
|
// smart_ptr<S>(new S({1, 2, 3}, 1)); // C++98 call-style initialization
|
|
|
|
// smart_ptr<S>(new S({}, 1));
|
2017-08-24 21:35:55 +08:00
|
|
|
// smart_ptr<S2>(new S2({1})); // implicit conversion:
|
|
|
|
// // std::initializer_list => std::vector
|
2018-11-20 23:45:15 +08:00
|
|
|
// smart_ptr<S3>(new S3({1, 2}, 3));
|
2017-08-17 18:14:52 +08:00
|
|
|
// The above samples have to be replaced with:
|
|
|
|
// std::make_smart_ptr<S>(std::initializer_list<int>({1, 2, 3}), 1);
|
|
|
|
// std::make_smart_ptr<S>(std::initializer_list<int>({}), 1);
|
2017-08-24 21:35:55 +08:00
|
|
|
// std::make_smart_ptr<S2>(std::vector<int>({1}));
|
2018-11-20 23:45:15 +08:00
|
|
|
// std::make_smart_ptr<S3>(S2{1, 2}, 3);
|
2017-08-17 18:14:52 +08:00
|
|
|
if (const auto *CE = New->getConstructExpr()) {
|
2018-11-20 23:45:15 +08:00
|
|
|
if (HasListIntializedArgument(CE))
|
|
|
|
return false;
|
2017-08-17 18:14:52 +08:00
|
|
|
}
|
2017-06-28 00:25:05 +08:00
|
|
|
if (ArraySizeExpr.empty()) {
|
|
|
|
SourceRange InitRange = New->getDirectInitRange();
|
|
|
|
Diag << FixItHint::CreateRemoval(
|
|
|
|
SourceRange(NewStart, InitRange.getBegin()));
|
|
|
|
Diag << FixItHint::CreateRemoval(SourceRange(InitRange.getEnd(), NewEnd));
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
// New array expression with default/value initialization:
|
|
|
|
// smart_ptr<Foo[]>(new int[5]());
|
|
|
|
// smart_ptr<Foo[]>(new Foo[5]());
|
|
|
|
Diag << FixItHint::CreateReplacement(SourceRange(NewStart, NewEnd),
|
|
|
|
ArraySizeExpr);
|
|
|
|
}
|
2016-05-03 00:56:39 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case CXXNewExpr::ListInit: {
|
|
|
|
// Range of the substring that we do not want to remove.
|
|
|
|
SourceRange InitRange;
|
|
|
|
if (const auto *NewConstruct = New->getConstructExpr()) {
|
2018-11-20 23:45:15 +08:00
|
|
|
if (NewConstruct->isStdInitListInitialization() ||
|
|
|
|
HasListIntializedArgument(NewConstruct)) {
|
2017-08-17 18:14:52 +08:00
|
|
|
// FIXME: Add fixes for direct initialization with the initializer-list
|
|
|
|
// constructor. Similar to the above CallInit case, the type has to be
|
|
|
|
// specified explicitly in the fixes.
|
|
|
|
// struct S { S(std::initializer_list<int>); };
|
2018-11-20 23:45:15 +08:00
|
|
|
// struct S2 { S2(S, int); };
|
2017-08-17 18:14:52 +08:00
|
|
|
// smart_ptr<S>(new S{1, 2, 3}); // C++11 direct list-initialization
|
|
|
|
// smart_ptr<S>(new S{}); // use initializer-list consturctor
|
2018-11-20 23:45:15 +08:00
|
|
|
// smart_ptr<S2>()new S2{ {1,2}, 3 }; // have a list-initialized arg
|
2017-08-17 18:14:52 +08:00
|
|
|
// The above cases have to be replaced with:
|
|
|
|
// std::make_smart_ptr<S>(std::initializer_list<int>({1, 2, 3}));
|
|
|
|
// std::make_smart_ptr<S>(std::initializer_list<int>({}));
|
2018-11-20 23:45:15 +08:00
|
|
|
// std::make_smart_ptr<S2>(S{1, 2}, 3);
|
2017-08-17 18:14:52 +08:00
|
|
|
return false;
|
2017-08-04 16:07:05 +08:00
|
|
|
} else {
|
|
|
|
// Direct initialization with ordinary constructors.
|
|
|
|
// struct S { S(int x); S(); };
|
|
|
|
// smart_ptr<S>(new S{5});
|
|
|
|
// smart_ptr<S>(new S{}); // use default constructor
|
|
|
|
// The arguments in the initialization list are going to be forwarded to
|
|
|
|
// the constructor, so this has to be replaced with:
|
|
|
|
// std::make_smart_ptr<S>(5);
|
|
|
|
// std::make_smart_ptr<S>();
|
|
|
|
InitRange = SourceRange(
|
|
|
|
NewConstruct->getParenOrBraceRange().getBegin().getLocWithOffset(1),
|
|
|
|
NewConstruct->getParenOrBraceRange().getEnd().getLocWithOffset(-1));
|
|
|
|
}
|
2016-05-03 00:56:39 +08:00
|
|
|
} else {
|
|
|
|
// Aggregate initialization.
|
|
|
|
// smart_ptr<Pair>(new Pair{first, second});
|
|
|
|
// Has to be replaced with:
|
|
|
|
// smart_ptr<Pair>(Pair{first, second});
|
2018-11-26 17:33:08 +08:00
|
|
|
//
|
|
|
|
// The fix (std::make_unique) needs to see copy/move constructor of
|
|
|
|
// Pair. If we found any invisible or deleted copy/move constructor, we
|
|
|
|
// stop generating fixes -- as the C++ rule is complicated and we are less
|
|
|
|
// certain about the correct fixes.
|
|
|
|
if (const CXXRecordDecl *RD = New->getType()->getPointeeCXXRecordDecl()) {
|
|
|
|
if (llvm::find_if(RD->ctors(), [](const CXXConstructorDecl *Ctor) {
|
|
|
|
return Ctor->isCopyOrMoveConstructor() &&
|
|
|
|
(Ctor->isDeleted() || Ctor->getAccess() == AS_private);
|
|
|
|
}) != RD->ctor_end()) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
2016-05-03 00:56:39 +08:00
|
|
|
InitRange = SourceRange(
|
2018-08-10 06:42:26 +08:00
|
|
|
New->getAllocatedTypeSourceInfo()->getTypeLoc().getBeginLoc(),
|
2016-05-03 00:56:39 +08:00
|
|
|
New->getInitializer()->getSourceRange().getEnd());
|
|
|
|
}
|
|
|
|
Diag << FixItHint::CreateRemoval(
|
|
|
|
CharSourceRange::getCharRange(NewStart, InitRange.getBegin()));
|
|
|
|
Diag << FixItHint::CreateRemoval(
|
|
|
|
SourceRange(InitRange.getEnd().getLocWithOffset(1), NewEnd));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2017-08-17 18:14:52 +08:00
|
|
|
return true;
|
2016-05-03 00:56:39 +08:00
|
|
|
}
|
|
|
|
|
2017-07-05 15:49:00 +08:00
|
|
|
void MakeSmartPtrCheck::insertHeader(DiagnosticBuilder &Diag, FileID FD) {
|
|
|
|
if (MakeSmartPtrFunctionHeader.empty()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (auto IncludeFixit = Inserter->CreateIncludeInsertion(
|
|
|
|
FD, MakeSmartPtrFunctionHeader,
|
|
|
|
/*IsAngled=*/MakeSmartPtrFunctionHeader == StdMemoryHeader)) {
|
|
|
|
Diag << *IncludeFixit;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-05-03 00:56:39 +08:00
|
|
|
} // namespace modernize
|
|
|
|
} // namespace tidy
|
|
|
|
} // namespace clang
|