369 lines
13 KiB
C++
369 lines
13 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/AST/Decl.h"
|
|
#include "clang/ASTMatchers/ASTMatchFinder.h"
|
|
#include "clang/Lex/Lexer.h"
|
|
#include "llvm/ADT/DenseMap.h"
|
|
|
|
using namespace clang::ast_matchers;
|
|
|
|
namespace clang::tidy::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;
|
|
}
|
|
|
|
enum class AssignedLevel {
|
|
// Field is not assigned.
|
|
None,
|
|
// Field is assigned.
|
|
Default,
|
|
// Assignment of field has side effect:
|
|
// - assign to reference.
|
|
// FIXME: support other side effect.
|
|
HasSideEffect,
|
|
// Assignment of field has data dependence.
|
|
HasDependence,
|
|
};
|
|
|
|
} // namespace
|
|
|
|
static bool canAdvanceAssignment(AssignedLevel Level) {
|
|
return Level == AssignedLevel::None || Level == AssignedLevel::Default;
|
|
}
|
|
|
|
// 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 void updateAssignmentLevel(
|
|
const FieldDecl *Field, const Expr *Init, const CXXConstructorDecl *Ctor,
|
|
llvm::DenseMap<const FieldDecl *, AssignedLevel> &AssignedFields) {
|
|
auto It = AssignedFields.find(Field);
|
|
if (It == AssignedFields.end())
|
|
It = AssignedFields.insert({Field, AssignedLevel::None}).first;
|
|
|
|
if (!canAdvanceAssignment(It->second))
|
|
// fast path for already decided field.
|
|
return;
|
|
|
|
if (Field->getType().getCanonicalType()->isReferenceType()) {
|
|
// assign to reference type twice cannot be simplified to once.
|
|
It->second = AssignedLevel::HasSideEffect;
|
|
return;
|
|
}
|
|
|
|
auto MemberMatcher =
|
|
memberExpr(hasObjectExpression(cxxThisExpr()),
|
|
member(fieldDecl(indexNotLessThan(Field->getFieldIndex()))));
|
|
auto DeclMatcher = declRefExpr(
|
|
to(varDecl(unless(parmVarDecl()), hasDeclContext(equalsNode(Ctor)))));
|
|
const bool HasDependence = !match(expr(anyOf(MemberMatcher, DeclMatcher,
|
|
hasDescendant(MemberMatcher),
|
|
hasDescendant(DeclMatcher))),
|
|
*Init, Field->getASTContext())
|
|
.empty();
|
|
if (HasDependence) {
|
|
It->second = AssignedLevel::HasDependence;
|
|
return;
|
|
}
|
|
}
|
|
|
|
struct AssignmentPair {
|
|
const FieldDecl *Field;
|
|
const Expr *Init;
|
|
};
|
|
|
|
static std::optional<AssignmentPair>
|
|
isAssignmentToMemberOf(const CXXRecordDecl *Rec, const Stmt *S,
|
|
const CXXConstructorDecl *Ctor) {
|
|
if (const auto *BO = dyn_cast<BinaryOperator>(S)) {
|
|
if (BO->getOpcode() != BO_Assign)
|
|
return {};
|
|
|
|
const auto *ME = dyn_cast<MemberExpr>(BO->getLHS()->IgnoreParenImpCasts());
|
|
if (!ME)
|
|
return {};
|
|
|
|
const auto *Field = dyn_cast<FieldDecl>(ME->getMemberDecl());
|
|
if (!Field)
|
|
return {};
|
|
|
|
if (!isa<CXXThisExpr>(ME->getBase()))
|
|
return {};
|
|
const Expr *Init = BO->getRHS()->IgnoreParenImpCasts();
|
|
return AssignmentPair{Field, Init};
|
|
}
|
|
if (const auto *COCE = dyn_cast<CXXOperatorCallExpr>(S)) {
|
|
if (COCE->getOperator() != OO_Equal)
|
|
return {};
|
|
|
|
const auto *ME =
|
|
dyn_cast<MemberExpr>(COCE->getArg(0)->IgnoreParenImpCasts());
|
|
if (!ME)
|
|
return {};
|
|
|
|
const auto *Field = dyn_cast<FieldDecl>(ME->getMemberDecl());
|
|
if (!Field)
|
|
return {};
|
|
|
|
if (!isa<CXXThisExpr>(ME->getBase()))
|
|
return {};
|
|
const Expr *Init = COCE->getArg(1)->IgnoreParenImpCasts();
|
|
return AssignmentPair{Field, Init};
|
|
}
|
|
return {};
|
|
}
|
|
|
|
PreferMemberInitializerCheck::PreferMemberInitializerCheck(
|
|
StringRef Name, ClangTidyContext *Context)
|
|
: ClangTidyCheck(Name, Context),
|
|
IsUseDefaultMemberInitEnabled(
|
|
Context->isCheckEnabled("modernize-use-default-member-init")),
|
|
UseAssignment(
|
|
Options.get("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()),
|
|
unless(isDelegatingConstructor()))
|
|
.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;
|
|
|
|
llvm::DenseMap<const FieldDecl *, AssignedLevel> AssignedFields{};
|
|
|
|
for (const CXXCtorInitializer *Init : Ctor->inits())
|
|
if (FieldDecl *Field = Init->getMember())
|
|
updateAssignmentLevel(Field, Init->getInit(), Ctor, AssignedFields);
|
|
|
|
for (const Stmt *S : Body->body()) {
|
|
if (S->getBeginLoc().isMacroID()) {
|
|
StringRef MacroName = Lexer::getImmediateMacroName(
|
|
S->getBeginLoc(), *Result.SourceManager, getLangOpts());
|
|
if (MacroName.contains_insensitive("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;
|
|
}
|
|
|
|
std::optional<AssignmentPair> AssignmentToMember =
|
|
isAssignmentToMemberOf(Class, S, Ctor);
|
|
if (!AssignmentToMember)
|
|
continue;
|
|
const FieldDecl *Field = AssignmentToMember->Field;
|
|
const Expr *InitValue = AssignmentToMember->Init;
|
|
updateAssignmentLevel(Field, InitValue, Ctor, AssignedFields);
|
|
if (!canAdvanceAssignment(AssignedFields[Field]))
|
|
continue;
|
|
const bool IsInDefaultMemberInitializer =
|
|
IsUseDefaultMemberInitEnabled && getLangOpts().CPlusPlus11 &&
|
|
Ctor->isDefaultConstructor() &&
|
|
(getLangOpts().CPlusPlus20 || !Field->isBitField()) &&
|
|
!Field->hasInClassInitializer() &&
|
|
(!isa<RecordDecl>(Class->getDeclContext()) ||
|
|
!cast<RecordDecl>(Class->getDeclContext())->isUnion()) &&
|
|
shouldBeDefaultMemberInitializer(InitValue);
|
|
if (IsInDefaultMemberInitializer) {
|
|
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)
|
|
continue;
|
|
CharSourceRange StmtRange =
|
|
CharSourceRange::getCharRange(S->getBeginLoc(), SemiColonEnd);
|
|
|
|
SmallString<128> Insertion(
|
|
{UseAssignment ? " = " : "{",
|
|
Lexer::getSourceText(Result.SourceManager->getExpansionRange(
|
|
InitValue->getSourceRange()),
|
|
*Result.SourceManager, getLangOpts()),
|
|
UseAssignment ? "" : "}"});
|
|
|
|
Diag << FixItHint::CreateInsertion(FieldEnd, Insertion)
|
|
<< FixItHint::CreateRemoval(StmtRange);
|
|
|
|
} else {
|
|
StringRef InsertPrefix = "";
|
|
bool HasInitAlready = false;
|
|
SourceLocation InsertPos;
|
|
SourceRange ReplaceRange;
|
|
bool AddComma = false;
|
|
bool InvalidFix = false;
|
|
unsigned Index = Field->getFieldIndex();
|
|
const CXXCtorInitializer *LastInListInit = nullptr;
|
|
for (const CXXCtorInitializer *Init : Ctor->inits()) {
|
|
if (!Init->isWritten() || Init->isInClassMemberInitializer())
|
|
continue;
|
|
if (Init->getMember() == Field) {
|
|
HasInitAlready = true;
|
|
if (isa<ImplicitValueInitExpr>(Init->getInit()))
|
|
InsertPos = Init->getRParenLoc();
|
|
else {
|
|
ReplaceRange = Init->getInit()->getSourceRange();
|
|
}
|
|
break;
|
|
}
|
|
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 (HasInitAlready) {
|
|
if (InsertPos.isValid())
|
|
InvalidFix |= InsertPos.isMacroID();
|
|
else
|
|
InvalidFix |= ReplaceRange.getBegin().isMacroID() ||
|
|
ReplaceRange.getEnd().isMacroID();
|
|
} else {
|
|
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)
|
|
continue;
|
|
StringRef NewInit = Lexer::getSourceText(
|
|
Result.SourceManager->getExpansionRange(InitValue->getSourceRange()),
|
|
*Result.SourceManager, getLangOpts());
|
|
if (HasInitAlready) {
|
|
if (InsertPos.isValid())
|
|
Diag << FixItHint::CreateInsertion(InsertPos, NewInit);
|
|
else
|
|
Diag << FixItHint::CreateReplacement(ReplaceRange, NewInit);
|
|
} else {
|
|
SmallString<128> Insertion({InsertPrefix, Field->getName(), "(",
|
|
NewInit, AddComma ? "), " : ")"});
|
|
Diag << FixItHint::CreateInsertion(InsertPos, Insertion,
|
|
FirstToCtorInits);
|
|
FirstToCtorInits = areDiagsSelfContained();
|
|
}
|
|
Diag << FixItHint::CreateRemoval(
|
|
CharSourceRange::getCharRange(S->getBeginLoc(), SemiColonEnd));
|
|
}
|
|
}
|
|
}
|
|
|
|
} // namespace clang::tidy::cppcoreguidelines
|