a2e15fa532
Prevent warning when the values are initialized using fields that will be initialized later or VarDecls defined in the constructors body. Both of these cases can't be safely fixed. Also improve logic of finding where to insert member initializers, previously it could be confused by in class member initializers. Reviewed By: aaron.ballman Differential Revision: https://reviews.llvm.org/D97132
297 lines
11 KiB
C++
297 lines
11 KiB
C++
//===--- PreferMemberInitializerCheck.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 "PreferMemberInitializerCheck.h"
|
|
#include "clang/AST/ASTContext.h"
|
|
#include "clang/ASTMatchers/ASTMatchFinder.h"
|
|
#include "clang/Lex/Lexer.h"
|
|
|
|
using namespace clang::ast_matchers;
|
|
|
|
namespace clang {
|
|
namespace tidy {
|
|
namespace cppcoreguidelines {
|
|
|
|
static bool isControlStatement(const Stmt *S) {
|
|
return isa<IfStmt, SwitchStmt, ForStmt, WhileStmt, DoStmt, ReturnStmt,
|
|
GotoStmt, CXXTryStmt, CXXThrowExpr>(S);
|
|
}
|
|
|
|
static bool isNoReturnCallStatement(const Stmt *S) {
|
|
const auto *Call = dyn_cast<CallExpr>(S);
|
|
if (!Call)
|
|
return false;
|
|
|
|
const FunctionDecl *Func = Call->getDirectCallee();
|
|
if (!Func)
|
|
return false;
|
|
|
|
return Func->isNoReturn();
|
|
}
|
|
|
|
static bool isLiteral(const Expr *E) {
|
|
return isa<StringLiteral, CharacterLiteral, IntegerLiteral, FloatingLiteral,
|
|
CXXBoolLiteralExpr, CXXNullPtrLiteralExpr>(E);
|
|
}
|
|
|
|
static bool isUnaryExprOfLiteral(const Expr *E) {
|
|
if (const auto *UnOp = dyn_cast<UnaryOperator>(E))
|
|
return isLiteral(UnOp->getSubExpr());
|
|
return false;
|
|
}
|
|
|
|
static bool shouldBeDefaultMemberInitializer(const Expr *Value) {
|
|
if (isLiteral(Value) || isUnaryExprOfLiteral(Value))
|
|
return true;
|
|
|
|
if (const auto *DRE = dyn_cast<DeclRefExpr>(Value))
|
|
return isa<EnumConstantDecl>(DRE->getDecl());
|
|
|
|
return false;
|
|
}
|
|
|
|
namespace {
|
|
AST_MATCHER_P(FieldDecl, indexNotLessThan, unsigned, Index) {
|
|
return Node.getFieldIndex() >= Index;
|
|
}
|
|
} // namespace
|
|
|
|
// Checks if Field is initialised using a field that will be initialised after
|
|
// it.
|
|
// TODO: Probably should guard against function calls that could have side
|
|
// effects or if they do reference another field that's initialized before this
|
|
// field, but is modified before the assignment.
|
|
static bool isSafeAssignment(const FieldDecl *Field, const Expr *Init,
|
|
const CXXConstructorDecl *Context) {
|
|
|
|
auto MemberMatcher =
|
|
memberExpr(hasObjectExpression(cxxThisExpr()),
|
|
member(fieldDecl(indexNotLessThan(Field->getFieldIndex()))));
|
|
|
|
auto DeclMatcher = declRefExpr(
|
|
to(varDecl(unless(parmVarDecl()), hasDeclContext(equalsNode(Context)))));
|
|
|
|
return match(expr(anyOf(MemberMatcher, DeclMatcher,
|
|
hasDescendant(MemberMatcher),
|
|
hasDescendant(DeclMatcher))),
|
|
*Init, Field->getASTContext())
|
|
.empty();
|
|
}
|
|
|
|
static const std::pair<const FieldDecl *, const Expr *>
|
|
isAssignmentToMemberOf(const CXXRecordDecl *Rec, const Stmt *S,
|
|
const CXXConstructorDecl *Ctor) {
|
|
if (const auto *BO = dyn_cast<BinaryOperator>(S)) {
|
|
if (BO->getOpcode() != BO_Assign)
|
|
return std::make_pair(nullptr, nullptr);
|
|
|
|
const auto *ME = dyn_cast<MemberExpr>(BO->getLHS()->IgnoreParenImpCasts());
|
|
if (!ME)
|
|
return std::make_pair(nullptr, nullptr);
|
|
|
|
const auto *Field = dyn_cast<FieldDecl>(ME->getMemberDecl());
|
|
if (!Field)
|
|
return std::make_pair(nullptr, nullptr);
|
|
|
|
if (!isa<CXXThisExpr>(ME->getBase()))
|
|
return std::make_pair(nullptr, nullptr);
|
|
const Expr *Init = BO->getRHS()->IgnoreParenImpCasts();
|
|
if (isSafeAssignment(Field, Init, Ctor))
|
|
return std::make_pair(Field, Init);
|
|
} else if (const auto *COCE = dyn_cast<CXXOperatorCallExpr>(S)) {
|
|
if (COCE->getOperator() != OO_Equal)
|
|
return std::make_pair(nullptr, nullptr);
|
|
|
|
const auto *ME =
|
|
dyn_cast<MemberExpr>(COCE->getArg(0)->IgnoreParenImpCasts());
|
|
if (!ME)
|
|
return std::make_pair(nullptr, nullptr);
|
|
|
|
const auto *Field = dyn_cast<FieldDecl>(ME->getMemberDecl());
|
|
if (!Field)
|
|
return std::make_pair(nullptr, nullptr);
|
|
|
|
if (!isa<CXXThisExpr>(ME->getBase()))
|
|
return std::make_pair(nullptr, nullptr);
|
|
const Expr *Init = COCE->getArg(1)->IgnoreParenImpCasts();
|
|
if (isSafeAssignment(Field, Init, Ctor))
|
|
return std::make_pair(Field, Init);
|
|
}
|
|
|
|
return std::make_pair(nullptr, nullptr);
|
|
}
|
|
|
|
PreferMemberInitializerCheck::PreferMemberInitializerCheck(
|
|
StringRef Name, ClangTidyContext *Context)
|
|
: ClangTidyCheck(Name, Context),
|
|
IsUseDefaultMemberInitEnabled(
|
|
Context->isCheckEnabled("modernize-use-default-member-init")),
|
|
UseAssignment(OptionsView("modernize-use-default-member-init",
|
|
Context->getOptions().CheckOptions, Context)
|
|
.get("UseAssignment", false)) {}
|
|
|
|
void PreferMemberInitializerCheck::storeOptions(
|
|
ClangTidyOptions::OptionMap &Opts) {
|
|
Options.store(Opts, "UseAssignment", UseAssignment);
|
|
}
|
|
|
|
void PreferMemberInitializerCheck::registerMatchers(MatchFinder *Finder) {
|
|
Finder->addMatcher(
|
|
cxxConstructorDecl(hasBody(compoundStmt()), unless(isInstantiated()))
|
|
.bind("ctor"),
|
|
this);
|
|
}
|
|
|
|
void PreferMemberInitializerCheck::check(
|
|
const MatchFinder::MatchResult &Result) {
|
|
const auto *Ctor = Result.Nodes.getNodeAs<CXXConstructorDecl>("ctor");
|
|
const auto *Body = cast<CompoundStmt>(Ctor->getBody());
|
|
|
|
const CXXRecordDecl *Class = Ctor->getParent();
|
|
bool FirstToCtorInits = true;
|
|
|
|
for (const Stmt *S : Body->body()) {
|
|
if (S->getBeginLoc().isMacroID()) {
|
|
StringRef MacroName = Lexer::getImmediateMacroName(
|
|
S->getBeginLoc(), *Result.SourceManager, getLangOpts());
|
|
if (MacroName.contains_lower("assert"))
|
|
return;
|
|
}
|
|
if (isControlStatement(S))
|
|
return;
|
|
|
|
if (isNoReturnCallStatement(S))
|
|
return;
|
|
|
|
if (const auto *CondOp = dyn_cast<ConditionalOperator>(S)) {
|
|
if (isNoReturnCallStatement(CondOp->getLHS()) ||
|
|
isNoReturnCallStatement(CondOp->getRHS()))
|
|
return;
|
|
}
|
|
|
|
const FieldDecl *Field;
|
|
const Expr *InitValue;
|
|
std::tie(Field, InitValue) = isAssignmentToMemberOf(Class, S, Ctor);
|
|
if (Field) {
|
|
if (IsUseDefaultMemberInitEnabled && getLangOpts().CPlusPlus11 &&
|
|
Ctor->isDefaultConstructor() &&
|
|
(getLangOpts().CPlusPlus20 || !Field->isBitField()) &&
|
|
!Field->hasInClassInitializer() &&
|
|
(!isa<RecordDecl>(Class->getDeclContext()) ||
|
|
!cast<RecordDecl>(Class->getDeclContext())->isUnion()) &&
|
|
shouldBeDefaultMemberInitializer(InitValue)) {
|
|
|
|
bool InvalidFix = false;
|
|
SourceLocation FieldEnd =
|
|
Lexer::getLocForEndOfToken(Field->getSourceRange().getEnd(), 0,
|
|
*Result.SourceManager, getLangOpts());
|
|
InvalidFix |= FieldEnd.isInvalid() || FieldEnd.isMacroID();
|
|
SourceLocation SemiColonEnd;
|
|
if (auto NextToken = Lexer::findNextToken(
|
|
S->getEndLoc(), *Result.SourceManager, getLangOpts()))
|
|
SemiColonEnd = NextToken->getEndLoc();
|
|
else
|
|
InvalidFix = true;
|
|
auto Diag =
|
|
diag(S->getBeginLoc(), "%0 should be initialized in an in-class"
|
|
" default member initializer")
|
|
<< Field;
|
|
if (!InvalidFix) {
|
|
CharSourceRange StmtRange =
|
|
CharSourceRange::getCharRange(S->getBeginLoc(), SemiColonEnd);
|
|
|
|
SmallString<128> Insertion(
|
|
{UseAssignment ? " = " : "{",
|
|
Lexer::getSourceText(
|
|
CharSourceRange(InitValue->getSourceRange(), true),
|
|
*Result.SourceManager, getLangOpts()),
|
|
UseAssignment ? "" : "}"});
|
|
|
|
Diag << FixItHint::CreateInsertion(FieldEnd, Insertion)
|
|
<< FixItHint::CreateRemoval(StmtRange);
|
|
}
|
|
} else {
|
|
StringRef InsertPrefix = "";
|
|
SourceLocation InsertPos;
|
|
bool AddComma = false;
|
|
bool InvalidFix = false;
|
|
unsigned Index = Field->getFieldIndex();
|
|
const CXXCtorInitializer *LastInListInit = nullptr;
|
|
for (const CXXCtorInitializer *Init : Ctor->inits()) {
|
|
if (!Init->isWritten())
|
|
continue;
|
|
if (Init->isMemberInitializer() &&
|
|
Index < Init->getMember()->getFieldIndex()) {
|
|
InsertPos = Init->getSourceLocation();
|
|
// There are initializers after the one we are inserting, so add a
|
|
// comma after this insertion in order to not break anything.
|
|
AddComma = true;
|
|
break;
|
|
}
|
|
LastInListInit = Init;
|
|
}
|
|
if (InsertPos.isInvalid()) {
|
|
if (LastInListInit) {
|
|
InsertPos = Lexer::getLocForEndOfToken(
|
|
LastInListInit->getRParenLoc(), 0, *Result.SourceManager,
|
|
getLangOpts());
|
|
// Inserting after the last constructor initializer, so we need a
|
|
// comma.
|
|
InsertPrefix = ", ";
|
|
} else {
|
|
InsertPos = Lexer::getLocForEndOfToken(
|
|
Ctor->getTypeSourceInfo()
|
|
->getTypeLoc()
|
|
.getAs<clang::FunctionTypeLoc>()
|
|
.getLocalRangeEnd(),
|
|
0, *Result.SourceManager, getLangOpts());
|
|
|
|
// If this is first time in the loop, there are no initializers so
|
|
// `:` declares member initialization list. If this is a subsequent
|
|
// pass then we have already inserted a `:` so continue with a
|
|
// comma.
|
|
InsertPrefix = FirstToCtorInits ? " : " : ", ";
|
|
}
|
|
}
|
|
InvalidFix |= InsertPos.isMacroID();
|
|
|
|
SourceLocation SemiColonEnd;
|
|
if (auto NextToken = Lexer::findNextToken(
|
|
S->getEndLoc(), *Result.SourceManager, getLangOpts()))
|
|
SemiColonEnd = NextToken->getEndLoc();
|
|
else
|
|
InvalidFix = true;
|
|
|
|
auto Diag =
|
|
diag(S->getBeginLoc(), "%0 should be initialized in a member"
|
|
" initializer of the constructor")
|
|
<< Field;
|
|
if (!InvalidFix) {
|
|
|
|
CharSourceRange StmtRange =
|
|
CharSourceRange::getCharRange(S->getBeginLoc(), SemiColonEnd);
|
|
SmallString<128> Insertion(
|
|
{InsertPrefix, Field->getName(), "(",
|
|
Lexer::getSourceText(
|
|
CharSourceRange(InitValue->getSourceRange(), true),
|
|
*Result.SourceManager, getLangOpts()),
|
|
AddComma ? "), " : ")"});
|
|
Diag << FixItHint::CreateInsertion(InsertPos, Insertion,
|
|
FirstToCtorInits)
|
|
<< FixItHint::CreateRemoval(StmtRange);
|
|
FirstToCtorInits = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
} // namespace cppcoreguidelines
|
|
} // namespace tidy
|
|
} // namespace clang
|