This is an archive of the discontinued LLVM Phabricator instance.

Differential D26511

[clang-tidy] Rename modernize-use-default to modernize-use-equals-default
ClosedPublic

Authored by malcolm.parsons on Nov 10 2016, 9:07 AM.

Details

Reviewers
aaron.ballman
angelgarcia
alexfh
Commits
rGbcf23661d08a: [clang-tidy] Rename modernize-use-default to modernize-use-equals-default
rCTE288375: [clang-tidy] Rename modernize-use-default to modernize-use-equals-default
rL288375: [clang-tidy] Rename modernize-use-default to modernize-use-equals-default

Diff Detail

Repository
rL LLVM

Event Timeline

malcolm.parsons updated this revision to Diff 77502.Nov 10 2016, 9:07 AM
malcolm.parsons retitled this revision from to [clang-tidy] Rename modernize-use-default to modernize-use-equals-default.
malcolm.parsons added reviewers: aaron.ballman, alexfh, angelgarcia.
malcolm.parsons added a subscriber: cfe-commits.
Herald added a subscriber: mgorny. · View Herald TranscriptNov 10 2016, 9:07 AM
aaron.ballman added inline comments.Nov 10 2016, 9:19 AM
clang-tidy/modernize/ModernizeTidyModule.cpp
58 ↗(On Diff #77502)

What do we want to do, if anything, for people who have scripts using the old name? Do we want to keep the old name as an alias to the new name for some period of time?

malcolm.parsons added inline comments.Nov 10 2016, 9:27 AM
clang-tidy/modernize/ModernizeTidyModule.cpp
58 ↗(On Diff #77502)

An alias helps if the check was enabled by name, but not if it was disabled by name.
If the alias is temporary, would you want a deprecation warning?
I wouldn't want to warn about -checks=modernize*, but maybe warning for -checks=modernize-use-default would be useful.

aaron.ballman added inline comments.Nov 10 2016, 9:42 AM
clang-tidy/modernize/ModernizeTidyModule.cpp
58 ↗(On Diff #77502)

An alias helps if the check was enabled by name, but not if it was disabled by name.

Oye, this is true and unfortunate.

If the alias is temporary, would you want a deprecation warning?
I wouldn't want to warn about -checks=modernize*, but maybe warning for -checks=modernize-use-default would be useful.

I think a deprecation warning would be a helpful feature, but not required. I do agree that I would not want a warning for wildcard matches.

I would also be fine if we simply had the documentation for modernize-use-default forward to the documentation for modernize-use-equals-default and put a note in there about the old name being deprecated and leave in an alias to the old name.

To be complete, I would also be fine if we remove the old name as in this patch. I am mostly thinking about what default policy we want to have when this situation arises. FWIW, the check was exposed under this name around Oct 2015, so it's been in the wild for over a year, and in a public release.

Prazek added a subscriber: Prazek.Nov 10 2016, 11:08 PM

I think this change is not required at first place.
It is introduced because of "modernize-use-delete" was too ambiguous because of operator delete, so it was changed to "modernize-use-equals-delete". But this case is not ambiguous at all, so I don't see point changing that.
Maybe it would be better to find better name for the modernize-use-equals-delete to be modernize-delete-function or something before 4.0 is released.

malcolm.parsons added a comment.Nov 10 2016, 11:28 PM
In D26511#592665, @Prazek wrote:

It is introduced because of "modernize-use-delete" was too ambiguous because of operator delete, so it was changed to "modernize-use-equals-delete". But this case is not ambiguous at all, so I don't see point changing that.

default can also be used in a switch.

aaron.ballman edited edge metadata.Nov 11 2016, 7:15 AM
In D26511#592670, @malcolm.parsons wrote:
In D26511#592665, @Prazek wrote:

It is introduced because of "modernize-use-delete" was too ambiguous because of operator delete, so it was changed to "modernize-use-equals-delete". But this case is not ambiguous at all, so I don't see point changing that.

default can also be used in a switch.

Also, "default" has meaning in English, so it's plausible to read this as a check that modernizes your code to "use the default" for whatever the user might be thinking of when they enable the check, so I think there is existing ambiguity with the current name.

malcolm.parsons updated this revision to Diff 77615.Nov 11 2016, 7:44 AM
malcolm.parsons edited edge metadata.

Fix sorting.
Mention in release notes.

aaron.ballman mentioned this in D23130: [Clang-tidy] Add a check for definitions in the global namespace..Nov 16 2016, 6:45 AM
alexfh added inline comments.Dec 1 2016, 6:33 AM
clang-tidy/modernize/ModernizeTidyModule.cpp
58 ↗(On Diff #77502)

I'd personally prefer to leave the old documentation file with a redirect and a note about the renaming. Similar to how we treat aliases. WDYT?

malcolm.parsons added inline comments.Dec 1 2016, 7:34 AM
clang-tidy/modernize/ModernizeTidyModule.cpp
58 ↗(On Diff #77502)

If it has a redirect then add_new_check.py will add it to list.rst using the same wording as an alias.
Is that what you want?
Should it be an alias?

alexfh added inline comments.Dec 1 2016, 7:53 AM
clang-tidy/modernize/ModernizeTidyModule.cpp
58 ↗(On Diff #77502)

I don't care about leaving the old name for the check (probably, better to remove it right away), but leaving the old documentation page with a proper redirect seems useful as a means to resolve users' confusion. I wouldn't call it "alias" in this case though, and including it to the list doesn't seem to be useful (so the document will need to be marked orphan, IIUC).

alexfh added inline comments.Dec 1 2016, 7:55 AM
clang-tidy/modernize/ModernizeTidyModule.cpp
58 ↗(On Diff #77502)

(So, we can do something close to clang/tools/extra/docs/clang-tidy.rst)

malcolm.parsons updated this revision to Diff 79918.Dec 1 2016, 8:30 AM

Add documentation redirect.
Change add_new_check.py to ignore checks that are orphaned.

Herald added a subscriber: JDevlieghere. · View Herald TranscriptDec 1 2016, 8:30 AM
malcolm.parsons updated this revision to Diff 79919.Dec 1 2016, 8:33 AM

Re-remove doubled space in modernize-use-equals-default.rst.

alexfh accepted this revision.Dec 1 2016, 9:19 AM
alexfh edited edge metadata.

LG. Thanks!

This revision is now accepted and ready to land.Dec 1 2016, 9:19 AM
Closed by commit rL288375: [clang-tidy] Rename modernize-use-default to modernize-use-equals-default (authored by malcolm.parsons). · Explain WhyDec 1 2016, 9:34 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

Diff 79928

clang-tools-extra/trunk/clang-tidy/add_new_check.py

Show First 20 Lines • Show All 220 Lines • ▼ Show 20 Lines with open(filename, 'r') as f:
lines = f.readlines() lines = f.readlines()
doc_files = filter(lambda s: s.endswith('.rst') and s != 'list.rst', doc_files = filter(lambda s: s.endswith('.rst') and s != 'list.rst',
os.listdir(docs_dir)) os.listdir(docs_dir))
doc_files.sort() doc_files.sort()
def format_link(doc_file): def format_link(doc_file):
check_name = doc_file.replace('.rst', '') check_name = doc_file.replace('.rst', '')
with open(os.path.join(docs_dir, doc_file), 'r') as doc: with open(os.path.join(docs_dir, doc_file), 'r') as doc:
content = doc.read()
match = re.search('.*:orphan:.*', content)
if match:
return ''
match = re.search('.*:http-equiv=refresh: \d+;URL=(.*).html.*', match = re.search('.*:http-equiv=refresh: \d+;URL=(.*).html.*',
doc.read()) content)
if match: if match:
return ' %(check)s (redirects to %(target)s) <%(check)s>\n' % { return ' %(check)s (redirects to %(target)s) <%(check)s>\n' % {
'check': check_name, 'check': check_name,
'target': match.group(1) 'target': match.group(1)
} }
return ' %s\n' % check_name return ' %s\n' % check_name
checks = map(format_link, doc_files) checks = map(format_link, doc_files)
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

clang-tools-extra/trunk/clang-tidy/modernize/CMakeLists.txt

Show All 10 Linesadd_clang_library(clangTidyModernizeModule
ModernizeTidyModule.cpp ModernizeTidyModule.cpp
PassByValueCheck.cpp PassByValueCheck.cpp
RawStringLiteralCheck.cpp RawStringLiteralCheck.cpp
RedundantVoidArgCheck.cpp RedundantVoidArgCheck.cpp
ReplaceAutoPtrCheck.cpp ReplaceAutoPtrCheck.cpp
ShrinkToFitCheck.cpp ShrinkToFitCheck.cpp
UseAutoCheck.cpp UseAutoCheck.cpp
UseBoolLiteralsCheck.cpp UseBoolLiteralsCheck.cpp
UseDefaultCheck.cpp
UseEmplaceCheck.cpp UseEmplaceCheck.cpp
UseEqualsDefaultCheck.cpp
UseEqualsDeleteCheck.cpp UseEqualsDeleteCheck.cpp
UseNullptrCheck.cpp UseNullptrCheck.cpp
UseOverrideCheck.cpp UseOverrideCheck.cpp
UseTransparentFunctorsCheck.cpp UseTransparentFunctorsCheck.cpp
UseUsingCheck.cpp UseUsingCheck.cpp
LINK_LIBS LINK_LIBS
clangAST clangAST
clangASTMatchers clangASTMatchers
clangBasic clangBasic
clangLex clangLex
clangTidy clangTidy
clangTidyReadabilityModule clangTidyReadabilityModule
clangTidyUtils clangTidyUtils
) )

clang-tools-extra/trunk/clang-tidy/modernize/ModernizeTidyModule.cpp

Show All 16 Lines
#include "MakeUniqueCheck.h" #include "MakeUniqueCheck.h"
#include "PassByValueCheck.h" #include "PassByValueCheck.h"
#include "RawStringLiteralCheck.h" #include "RawStringLiteralCheck.h"
#include "RedundantVoidArgCheck.h" #include "RedundantVoidArgCheck.h"
#include "ReplaceAutoPtrCheck.h" #include "ReplaceAutoPtrCheck.h"
#include "ShrinkToFitCheck.h" #include "ShrinkToFitCheck.h"
#include "UseAutoCheck.h" #include "UseAutoCheck.h"
#include "UseBoolLiteralsCheck.h" #include "UseBoolLiteralsCheck.h"
#include "UseDefaultCheck.h"
#include "UseEmplaceCheck.h" #include "UseEmplaceCheck.h"
#include "UseEqualsDefaultCheck.h"
#include "UseEqualsDeleteCheck.h" #include "UseEqualsDeleteCheck.h"
#include "UseNullptrCheck.h" #include "UseNullptrCheck.h"
#include "UseOverrideCheck.h" #include "UseOverrideCheck.h"
#include "UseTransparentFunctorsCheck.h" #include "UseTransparentFunctorsCheck.h"
#include "UseUsingCheck.h" #include "UseUsingCheck.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
Show All 16 Lines void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
CheckFactories.registerCheck<RedundantVoidArgCheck>( CheckFactories.registerCheck<RedundantVoidArgCheck>(
"modernize-redundant-void-arg"); "modernize-redundant-void-arg");
CheckFactories.registerCheck<ReplaceAutoPtrCheck>( CheckFactories.registerCheck<ReplaceAutoPtrCheck>(
"modernize-replace-auto-ptr"); "modernize-replace-auto-ptr");
CheckFactories.registerCheck<ShrinkToFitCheck>("modernize-shrink-to-fit"); CheckFactories.registerCheck<ShrinkToFitCheck>("modernize-shrink-to-fit");
CheckFactories.registerCheck<UseAutoCheck>("modernize-use-auto"); CheckFactories.registerCheck<UseAutoCheck>("modernize-use-auto");
CheckFactories.registerCheck<UseBoolLiteralsCheck>( CheckFactories.registerCheck<UseBoolLiteralsCheck>(
"modernize-use-bool-literals"); "modernize-use-bool-literals");
CheckFactories.registerCheck<UseDefaultCheck>("modernize-use-default");
CheckFactories.registerCheck<UseEmplaceCheck>("modernize-use-emplace"); CheckFactories.registerCheck<UseEmplaceCheck>("modernize-use-emplace");
CheckFactories.registerCheck<UseEqualsDefaultCheck>("modernize-use-equals-default");
CheckFactories.registerCheck<UseEqualsDeleteCheck>( CheckFactories.registerCheck<UseEqualsDeleteCheck>(
"modernize-use-equals-delete"); "modernize-use-equals-delete");
CheckFactories.registerCheck<UseNullptrCheck>("modernize-use-nullptr"); CheckFactories.registerCheck<UseNullptrCheck>("modernize-use-nullptr");
CheckFactories.registerCheck<UseOverrideCheck>("modernize-use-override"); CheckFactories.registerCheck<UseOverrideCheck>("modernize-use-override");
CheckFactories.registerCheck<UseTransparentFunctorsCheck>( CheckFactories.registerCheck<UseTransparentFunctorsCheck>(
"modernize-use-transparent-functors"); "modernize-use-transparent-functors");
CheckFactories.registerCheck<UseUsingCheck>("modernize-use-using"); CheckFactories.registerCheck<UseUsingCheck>("modernize-use-using");
} }
Show All 31 Lines

clang-tools-extra/trunk/clang-tidy/modernize/UseDefaultCheck.h

//===--- UseDefaultCheck.h - clang-tidy--------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_DEFAULT_H
#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_DEFAULT_H
#include "../ClangTidy.h"
namespace clang {
namespace tidy {
namespace modernize {
/// \brief Replace default bodies of special member functions with '= default;'.
/// \code
/// struct A {
/// A() {}
/// ~A();
/// };
/// A::~A() {}
/// \endcode
/// Is converted to:
/// \code
/// struct A {
/// A() = default;
/// ~A();
/// };
/// A::~A() = default;
/// \endcode
///
/// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/modernize-use-default.html
class UseDefaultCheck : public ClangTidyCheck {
public:
UseDefaultCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
} // namespace modernize
} // namespace tidy
} // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_DEFAULT_H

clang-tools-extra/trunk/clang-tidy/modernize/UseDefaultCheck.cpp

//===--- UseDefaultCheck.cpp - clang-tidy----------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "UseDefaultCheck.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 modernize {
static const char SpecialFunction[] = "SpecialFunction";
/// \brief Finds all the named non-static fields of \p Record.
static std::set<const FieldDecl *>
getAllNamedFields(const CXXRecordDecl *Record) {
std::set<const FieldDecl *> Result;
for (const auto *Field : Record->fields()) {
// Static data members are not in this range.
if (Field->isUnnamedBitfield())
continue;
Result.insert(Field);
}
return Result;
}
/// \brief Returns the names of the direct bases of \p Record, both virtual and
/// non-virtual.
static std::set<const Type *> getAllDirectBases(const CXXRecordDecl *Record) {
std::set<const Type *> Result;
for (auto Base : Record->bases()) {
// CXXBaseSpecifier.
const auto *BaseType = Base.getTypeSourceInfo()->getType().getTypePtr();
Result.insert(BaseType);
}
return Result;
}
/// \brief Returns a matcher that matches member expressions where the base is
/// the variable declared as \p Var and the accessed member is the one declared
/// as \p Field.
internal::Matcher<Expr> accessToFieldInVar(const FieldDecl *Field,
const ValueDecl *Var) {
return ignoringImpCasts(
memberExpr(hasObjectExpression(declRefExpr(to(varDecl(equalsNode(Var))))),
member(fieldDecl(equalsNode(Field)))));
}
/// \brief Check that the given constructor has copy signature and that it
/// copy-initializes all its bases and members.
static bool isCopyConstructorAndCanBeDefaulted(ASTContext *Context,
const CXXConstructorDecl *Ctor) {
// An explicitly-defaulted constructor cannot have default arguments.
if (Ctor->getMinRequiredArguments() != 1)
return false;
const auto *Record = Ctor->getParent();
const auto *Param = Ctor->getParamDecl(0);
// Base classes and members that have to be copied.
auto BasesToInit = getAllDirectBases(Record);
auto FieldsToInit = getAllNamedFields(Record);
// Ensure that all the bases are copied.
for (const auto *Base : BasesToInit) {
// The initialization of a base class should be a call to a copy
// constructor of the base.
if (match(
cxxConstructorDecl(forEachConstructorInitializer(cxxCtorInitializer(
isBaseInitializer(),
withInitializer(cxxConstructExpr(allOf(
hasType(equalsNode(Base)),
hasDeclaration(cxxConstructorDecl(isCopyConstructor())),
argumentCountIs(1),
hasArgument(
0, declRefExpr(to(varDecl(equalsNode(Param))))))))))),
*Ctor, *Context)
.empty())
return false;
}
// Ensure that all the members are copied.
for (const auto *Field : FieldsToInit) {
auto AccessToFieldInParam = accessToFieldInVar(Field, Param);
// The initialization is a CXXConstructExpr for class types.
if (match(
cxxConstructorDecl(forEachConstructorInitializer(cxxCtorInitializer(
isMemberInitializer(), forField(equalsNode(Field)),
withInitializer(anyOf(
AccessToFieldInParam,
cxxConstructExpr(allOf(
hasDeclaration(cxxConstructorDecl(isCopyConstructor())),
argumentCountIs(1),
hasArgument(0, AccessToFieldInParam)))))))),
*Ctor, *Context)
.empty())
return false;
}
// Ensure that we don't do anything else, like initializing an indirect base.
return Ctor->getNumCtorInitializers() ==
BasesToInit.size() + FieldsToInit.size();
}
/// \brief Checks that the given method is an overloading of the assignment
/// operator, has copy signature, returns a reference to "*this" and copies
/// all its members and subobjects.
static bool isCopyAssignmentAndCanBeDefaulted(ASTContext *Context,
const CXXMethodDecl *Operator) {
const auto *Record = Operator->getParent();
const auto *Param = Operator->getParamDecl(0);
// Base classes and members that have to be copied.
auto BasesToInit = getAllDirectBases(Record);
auto FieldsToInit = getAllNamedFields(Record);
const auto *Compound = cast<CompoundStmt>(Operator->getBody());
// The assignment operator definition has to end with the following return
// statement:
// return *this;
if (Compound->body_empty() ||
match(returnStmt(has(ignoringParenImpCasts(unaryOperator(
hasOperatorName("*"), hasUnaryOperand(cxxThisExpr()))))),
*Compound->body_back(), *Context)
.empty())
return false;
// Ensure that all the bases are copied.
for (const auto *Base : BasesToInit) {
// Assignment operator of a base class:
// Base::operator=(Other);
//
// Clang translates this into:
// ((Base*)this)->operator=((Base)Other);
//
// So we are looking for a member call that fulfills:
if (match(compoundStmt(has(ignoringParenImpCasts(cxxMemberCallExpr(allOf(
// - The object is an implicit cast of 'this' to a pointer to
// a base class.
onImplicitObjectArgument(
implicitCastExpr(hasImplicitDestinationType(
pointsTo(type(equalsNode(Base)))),
hasSourceExpression(cxxThisExpr()))),
// - The called method is the operator=.
callee(cxxMethodDecl(isCopyAssignmentOperator())),
// - The argument is (an implicit cast to a Base of) the
// argument taken by "Operator".
argumentCountIs(1),
hasArgument(0,
declRefExpr(to(varDecl(equalsNode(Param)))))))))),
*Compound, *Context)
.empty())
return false;
}
// Ensure that all the members are copied.
for (const auto *Field : FieldsToInit) {
// The assignment of data members:
// Field = Other.Field;
// Is a BinaryOperator in non-class types, and a CXXOperatorCallExpr
// otherwise.
auto LHS = memberExpr(hasObjectExpression(cxxThisExpr()),
member(fieldDecl(equalsNode(Field))));
auto RHS = accessToFieldInVar(Field, Param);
if (match(
compoundStmt(has(ignoringParenImpCasts(stmt(anyOf(
binaryOperator(hasOperatorName("="), hasLHS(LHS), hasRHS(RHS)),
cxxOperatorCallExpr(hasOverloadedOperatorName("="),
argumentCountIs(2), hasArgument(0, LHS),
hasArgument(1, RHS))))))),
*Compound, *Context)
.empty())
return false;
}
// Ensure that we don't do anything else.
return Compound->size() == BasesToInit.size() + FieldsToInit.size() + 1;
}
/// \brief Returns false if the body has any non-whitespace character.
static bool bodyEmpty(const ASTContext *Context, const CompoundStmt *Body) {
bool Invalid = false;
StringRef Text = Lexer::getSourceText(
CharSourceRange::getCharRange(Body->getLBracLoc().getLocWithOffset(1),
Body->getRBracLoc()),
Context->getSourceManager(), Context->getLangOpts(), &Invalid);
return !Invalid && std::strspn(Text.data(), " \t\r\n") == Text.size();
}
void UseDefaultCheck::registerMatchers(MatchFinder *Finder) {
if (getLangOpts().CPlusPlus) {
// Destructor.
Finder->addMatcher(cxxDestructorDecl(isDefinition()).bind(SpecialFunction),
this);
Finder->addMatcher(
cxxConstructorDecl(
isDefinition(),
anyOf(
// Default constructor.
allOf(unless(hasAnyConstructorInitializer(isWritten())),
parameterCountIs(0)),
// Copy constructor.
allOf(isCopyConstructor(),
// Discard constructors that can be used as a copy
// constructor because all the other arguments have
// default values.
parameterCountIs(1))))
.bind(SpecialFunction),
this);
// Copy-assignment operator.
Finder->addMatcher(
cxxMethodDecl(isDefinition(), isCopyAssignmentOperator(),
// isCopyAssignmentOperator() allows the parameter to be
// passed by value, and in this case it cannot be
// defaulted.
hasParameter(0, hasType(lValueReferenceType())))
.bind(SpecialFunction),
this);
}
}
void UseDefaultCheck::check(const MatchFinder::MatchResult &Result) {
std::string SpecialFunctionName;
// Both CXXConstructorDecl and CXXDestructorDecl inherit from CXXMethodDecl.
const auto *SpecialFunctionDecl =
Result.Nodes.getNodeAs<CXXMethodDecl>(SpecialFunction);
// Discard explicitly deleted/defaulted special member functions and those
// that are not user-provided (automatically generated).
if (SpecialFunctionDecl->isDeleted() ||
SpecialFunctionDecl->isExplicitlyDefaulted() ||
SpecialFunctionDecl->isLateTemplateParsed() ||
SpecialFunctionDecl->isTemplateInstantiation() ||
!SpecialFunctionDecl->isUserProvided() || !SpecialFunctionDecl->hasBody())
return;
const auto *Body = dyn_cast<CompoundStmt>(SpecialFunctionDecl->getBody());
if (!Body)
return;
// If there is code inside the body, don't warn.
if (!SpecialFunctionDecl->isCopyAssignmentOperator() && !Body->body_empty())
return;
// If there are comments inside the body, don't do the change.
bool ApplyFix = SpecialFunctionDecl->isCopyAssignmentOperator() ||
bodyEmpty(Result.Context, Body);
std::vector<FixItHint> RemoveInitializers;
if (const auto *Ctor = dyn_cast<CXXConstructorDecl>(SpecialFunctionDecl)) {
if (Ctor->getNumParams() == 0) {
SpecialFunctionName = "default constructor";
} else {
if (!isCopyConstructorAndCanBeDefaulted(Result.Context, Ctor))
return;
SpecialFunctionName = "copy constructor";
// If there are constructor initializers, they must be removed.
for (const auto *Init : Ctor->inits()) {
RemoveInitializers.emplace_back(
FixItHint::CreateRemoval(Init->getSourceRange()));
}
}
} else if (isa<CXXDestructorDecl>(SpecialFunctionDecl)) {
SpecialFunctionName = "destructor";
} else {
if (!isCopyAssignmentAndCanBeDefaulted(Result.Context, SpecialFunctionDecl))
return;
SpecialFunctionName = "copy-assignment operator";
}
// The location of the body is more useful inside a macro as spelling and
// expansion locations are reported.
SourceLocation Location = SpecialFunctionDecl->getLocation();
if (Location.isMacroID())
Location = Body->getLocStart();
auto Diag = diag(Location, "use '= default' to define a trivial " +
SpecialFunctionName);
if (ApplyFix)
Diag << FixItHint::CreateReplacement(Body->getSourceRange(), "= default;")
<< RemoveInitializers;
}
} // namespace modernize
} // namespace tidy
} // namespace clang

clang-tools-extra/trunk/clang-tidy/modernize/UseEqualsDefaultCheck.h

//===--- UseEqualsDefaultCheck.h - clang-tidy--------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_EQUALS_DEFAULT_H
#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_EQUALS_DEFAULT_H
#include "../ClangTidy.h"
namespace clang {
namespace tidy {
namespace modernize {
/// \brief Replace default bodies of special member functions with '= default;'.
/// \code
/// struct A {
/// A() {}
/// ~A();
/// };
/// A::~A() {}
/// \endcode
/// Is converted to:
/// \code
/// struct A {
/// A() = default;
/// ~A();
/// };
/// A::~A() = default;
/// \endcode
///
/// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/modernize-use-equals-default.html
class UseEqualsDefaultCheck : public ClangTidyCheck {
public:
UseEqualsDefaultCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
} // namespace modernize
} // namespace tidy
} // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_EQUALS_DEFAULT_H

clang-tools-extra/trunk/clang-tidy/modernize/UseEqualsDefaultCheck.cpp

//===--- UseEqualsDefaultCheck.cpp - clang-tidy----------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "UseEqualsDefaultCheck.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 modernize {
static const char SpecialFunction[] = "SpecialFunction";
/// \brief Finds all the named non-static fields of \p Record.
static std::set<const FieldDecl *>
getAllNamedFields(const CXXRecordDecl *Record) {
std::set<const FieldDecl *> Result;
for (const auto *Field : Record->fields()) {
// Static data members are not in this range.
if (Field->isUnnamedBitfield())
continue;
Result.insert(Field);
}
return Result;
}
/// \brief Returns the names of the direct bases of \p Record, both virtual and
/// non-virtual.
static std::set<const Type *> getAllDirectBases(const CXXRecordDecl *Record) {
std::set<const Type *> Result;
for (auto Base : Record->bases()) {
// CXXBaseSpecifier.
const auto *BaseType = Base.getTypeSourceInfo()->getType().getTypePtr();
Result.insert(BaseType);
}
return Result;
}
/// \brief Returns a matcher that matches member expressions where the base is
/// the variable declared as \p Var and the accessed member is the one declared
/// as \p Field.
internal::Matcher<Expr> accessToFieldInVar(const FieldDecl *Field,
const ValueDecl *Var) {
return ignoringImpCasts(
memberExpr(hasObjectExpression(declRefExpr(to(varDecl(equalsNode(Var))))),
member(fieldDecl(equalsNode(Field)))));
}
/// \brief Check that the given constructor has copy signature and that it
/// copy-initializes all its bases and members.
static bool isCopyConstructorAndCanBeDefaulted(ASTContext *Context,
const CXXConstructorDecl *Ctor) {
// An explicitly-defaulted constructor cannot have default arguments.
if (Ctor->getMinRequiredArguments() != 1)
return false;
const auto *Record = Ctor->getParent();
const auto *Param = Ctor->getParamDecl(0);
// Base classes and members that have to be copied.
auto BasesToInit = getAllDirectBases(Record);
auto FieldsToInit = getAllNamedFields(Record);
// Ensure that all the bases are copied.
for (const auto *Base : BasesToInit) {
// The initialization of a base class should be a call to a copy
// constructor of the base.
if (match(
cxxConstructorDecl(forEachConstructorInitializer(cxxCtorInitializer(
isBaseInitializer(),
withInitializer(cxxConstructExpr(allOf(
hasType(equalsNode(Base)),
hasDeclaration(cxxConstructorDecl(isCopyConstructor())),
argumentCountIs(1),
hasArgument(
0, declRefExpr(to(varDecl(equalsNode(Param))))))))))),
*Ctor, *Context)
.empty())
return false;
}
// Ensure that all the members are copied.
for (const auto *Field : FieldsToInit) {
auto AccessToFieldInParam = accessToFieldInVar(Field, Param);
// The initialization is a CXXConstructExpr for class types.
if (match(
cxxConstructorDecl(forEachConstructorInitializer(cxxCtorInitializer(
isMemberInitializer(), forField(equalsNode(Field)),
withInitializer(anyOf(
AccessToFieldInParam,
cxxConstructExpr(allOf(
hasDeclaration(cxxConstructorDecl(isCopyConstructor())),
argumentCountIs(1),
hasArgument(0, AccessToFieldInParam)))))))),
*Ctor, *Context)
.empty())
return false;
}
// Ensure that we don't do anything else, like initializing an indirect base.
return Ctor->getNumCtorInitializers() ==
BasesToInit.size() + FieldsToInit.size();
}
/// \brief Checks that the given method is an overloading of the assignment
/// operator, has copy signature, returns a reference to "*this" and copies
/// all its members and subobjects.
static bool isCopyAssignmentAndCanBeDefaulted(ASTContext *Context,
const CXXMethodDecl *Operator) {
const auto *Record = Operator->getParent();
const auto *Param = Operator->getParamDecl(0);
// Base classes and members that have to be copied.
auto BasesToInit = getAllDirectBases(Record);
auto FieldsToInit = getAllNamedFields(Record);
const auto *Compound = cast<CompoundStmt>(Operator->getBody());
// The assignment operator definition has to end with the following return
// statement:
// return *this;
if (Compound->body_empty() ||
match(returnStmt(has(ignoringParenImpCasts(unaryOperator(
hasOperatorName("*"), hasUnaryOperand(cxxThisExpr()))))),
*Compound->body_back(), *Context)
.empty())
return false;
// Ensure that all the bases are copied.
for (const auto *Base : BasesToInit) {
// Assignment operator of a base class:
// Base::operator=(Other);
//
// Clang translates this into:
// ((Base*)this)->operator=((Base)Other);
//
// So we are looking for a member call that fulfills:
if (match(compoundStmt(has(ignoringParenImpCasts(cxxMemberCallExpr(allOf(
// - The object is an implicit cast of 'this' to a pointer to
// a base class.
onImplicitObjectArgument(
implicitCastExpr(hasImplicitDestinationType(
pointsTo(type(equalsNode(Base)))),
hasSourceExpression(cxxThisExpr()))),
// - The called method is the operator=.
callee(cxxMethodDecl(isCopyAssignmentOperator())),
// - The argument is (an implicit cast to a Base of) the
// argument taken by "Operator".
argumentCountIs(1),
hasArgument(0,
declRefExpr(to(varDecl(equalsNode(Param)))))))))),
*Compound, *Context)
.empty())
return false;
}
// Ensure that all the members are copied.
for (const auto *Field : FieldsToInit) {
// The assignment of data members:
// Field = Other.Field;
// Is a BinaryOperator in non-class types, and a CXXOperatorCallExpr
// otherwise.
auto LHS = memberExpr(hasObjectExpression(cxxThisExpr()),
member(fieldDecl(equalsNode(Field))));
auto RHS = accessToFieldInVar(Field, Param);
if (match(
compoundStmt(has(ignoringParenImpCasts(stmt(anyOf(
binaryOperator(hasOperatorName("="), hasLHS(LHS), hasRHS(RHS)),
cxxOperatorCallExpr(hasOverloadedOperatorName("="),
argumentCountIs(2), hasArgument(0, LHS),
hasArgument(1, RHS))))))),
*Compound, *Context)
.empty())
return false;
}
// Ensure that we don't do anything else.
return Compound->size() == BasesToInit.size() + FieldsToInit.size() + 1;
}
/// \brief Returns false if the body has any non-whitespace character.
static bool bodyEmpty(const ASTContext *Context, const CompoundStmt *Body) {
bool Invalid = false;
StringRef Text = Lexer::getSourceText(
CharSourceRange::getCharRange(Body->getLBracLoc().getLocWithOffset(1),
Body->getRBracLoc()),
Context->getSourceManager(), Context->getLangOpts(), &Invalid);
return !Invalid && std::strspn(Text.data(), " \t\r\n") == Text.size();
}
void UseEqualsDefaultCheck::registerMatchers(MatchFinder *Finder) {
if (getLangOpts().CPlusPlus) {
// Destructor.
Finder->addMatcher(cxxDestructorDecl(isDefinition()).bind(SpecialFunction),
this);
Finder->addMatcher(
cxxConstructorDecl(
isDefinition(),
anyOf(
// Default constructor.
allOf(unless(hasAnyConstructorInitializer(isWritten())),
parameterCountIs(0)),
// Copy constructor.
allOf(isCopyConstructor(),
// Discard constructors that can be used as a copy
// constructor because all the other arguments have
// default values.
parameterCountIs(1))))
.bind(SpecialFunction),
this);
// Copy-assignment operator.
Finder->addMatcher(
cxxMethodDecl(isDefinition(), isCopyAssignmentOperator(),
// isCopyAssignmentOperator() allows the parameter to be
// passed by value, and in this case it cannot be
// defaulted.
hasParameter(0, hasType(lValueReferenceType())))
.bind(SpecialFunction),
this);
}
}
void UseEqualsDefaultCheck::check(const MatchFinder::MatchResult &Result) {
std::string SpecialFunctionName;
// Both CXXConstructorDecl and CXXDestructorDecl inherit from CXXMethodDecl.
const auto *SpecialFunctionDecl =
Result.Nodes.getNodeAs<CXXMethodDecl>(SpecialFunction);
// Discard explicitly deleted/defaulted special member functions and those
// that are not user-provided (automatically generated).
if (SpecialFunctionDecl->isDeleted() ||
SpecialFunctionDecl->isExplicitlyDefaulted() ||
SpecialFunctionDecl->isLateTemplateParsed() ||
SpecialFunctionDecl->isTemplateInstantiation() ||
!SpecialFunctionDecl->isUserProvided() || !SpecialFunctionDecl->hasBody())
return;
const auto *Body = dyn_cast<CompoundStmt>(SpecialFunctionDecl->getBody());
if (!Body)
return;
// If there is code inside the body, don't warn.
if (!SpecialFunctionDecl->isCopyAssignmentOperator() && !Body->body_empty())
return;
// If there are comments inside the body, don't do the change.
bool ApplyFix = SpecialFunctionDecl->isCopyAssignmentOperator() ||
bodyEmpty(Result.Context, Body);
std::vector<FixItHint> RemoveInitializers;
if (const auto *Ctor = dyn_cast<CXXConstructorDecl>(SpecialFunctionDecl)) {
if (Ctor->getNumParams() == 0) {
SpecialFunctionName = "default constructor";
} else {
if (!isCopyConstructorAndCanBeDefaulted(Result.Context, Ctor))
return;
SpecialFunctionName = "copy constructor";
// If there are constructor initializers, they must be removed.
for (const auto *Init : Ctor->inits()) {
RemoveInitializers.emplace_back(
FixItHint::CreateRemoval(Init->getSourceRange()));
}
}
} else if (isa<CXXDestructorDecl>(SpecialFunctionDecl)) {
SpecialFunctionName = "destructor";
} else {
if (!isCopyAssignmentAndCanBeDefaulted(Result.Context, SpecialFunctionDecl))
return;
SpecialFunctionName = "copy-assignment operator";
}
// The location of the body is more useful inside a macro as spelling and
// expansion locations are reported.
SourceLocation Location = SpecialFunctionDecl->getLocation();
if (Location.isMacroID())
Location = Body->getLocStart();
auto Diag = diag(Location, "use '= default' to define a trivial " +
SpecialFunctionName);
if (ApplyFix)
Diag << FixItHint::CreateReplacement(Body->getSourceRange(), "= default;")
<< RemoveInitializers;
}
} // namespace modernize
} // namespace tidy
} // namespace clang

clang-tools-extra/trunk/docs/ReleaseNotes.rst

Show First 20 Lines • Show All 85 Lines • ▼ Show 20 Lines- `modernize-make-unique
and `modernize-make-shared and `modernize-make-shared
<http://clang.llvm.org/extra/clang-tidy/checks/modernize-make-shared.html>`_ <http://clang.llvm.org/extra/clang-tidy/checks/modernize-make-shared.html>`_
now handle calls to the smart pointer's ``reset()`` method. now handle calls to the smart pointer's ``reset()`` method.
- The `modernize-use-auto - The `modernize-use-auto
<http://clang.llvm.org/extra/clang-tidy/checks/modernize-use-auto.html>`_ check <http://clang.llvm.org/extra/clang-tidy/checks/modernize-use-auto.html>`_ check
now warns about variable declarations that are initialized with a cast. now warns about variable declarations that are initialized with a cast.
- The modernize-use-default check has been renamed to `modernize-use-equals-default
<http://clang.llvm.org/extra/clang-tidy/checks/modernize-use-equals-default.html>`_.
- New `modernize-use-equals-delete - New `modernize-use-equals-delete
<http://clang.llvm.org/extra/clang-tidy/checks/modernize-use-equals-delete.html>`_ check <http://clang.llvm.org/extra/clang-tidy/checks/modernize-use-equals-delete.html>`_ check
Adds ``= delete`` to unimplemented private special member functions. Adds ``= delete`` to unimplemented private special member functions.
- New `modernize-use-transparent-functors - New `modernize-use-transparent-functors
<http://clang.llvm.org/extra/clang-tidy/checks/modernize-use-transparent-functors.html>`_ check <http://clang.llvm.org/extra/clang-tidy/checks/modernize-use-transparent-functors.html>`_ check
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

clang-tools-extra/trunk/docs/clang-tidy/checks/list.rst

Show All 12 Lines.. toctree::
cert-err09-cpp (redirects to misc-throw-by-value-catch-by-reference) <cert-err09-cpp> cert-err09-cpp (redirects to misc-throw-by-value-catch-by-reference) <cert-err09-cpp>
cert-err34-c cert-err34-c
cert-err52-cpp cert-err52-cpp
cert-err58-cpp cert-err58-cpp
cert-err60-cpp cert-err60-cpp
cert-err61-cpp (redirects to misc-throw-by-value-catch-by-reference) <cert-err61-cpp> cert-err61-cpp (redirects to misc-throw-by-value-catch-by-reference) <cert-err61-cpp>
cert-fio38-c (redirects to misc-non-copyable-objects) <cert-fio38-c> cert-fio38-c (redirects to misc-non-copyable-objects) <cert-fio38-c>
cert-flp30-c cert-flp30-c
cert-msc30-c (redirects to cert-limited-randomness) <cert-msc30-c> cert-msc30-c (redirects to cert-msc50-cpp) <cert-msc30-c>
cert-msc50-cpp cert-msc50-cpp
cert-oop11-cpp (redirects to misc-move-constructor-init) <cert-oop11-cpp> cert-oop11-cpp (redirects to misc-move-constructor-init) <cert-oop11-cpp>
cppcoreguidelines-interfaces-global-init cppcoreguidelines-interfaces-global-init
cppcoreguidelines-pro-bounds-array-to-pointer-decay cppcoreguidelines-pro-bounds-array-to-pointer-decay
cppcoreguidelines-pro-bounds-constant-array-index cppcoreguidelines-pro-bounds-constant-array-index
cppcoreguidelines-pro-bounds-pointer-arithmetic cppcoreguidelines-pro-bounds-pointer-arithmetic
cppcoreguidelines-pro-type-const-cast cppcoreguidelines-pro-type-const-cast
cppcoreguidelines-pro-type-cstyle-cast cppcoreguidelines-pro-type-cstyle-cast
▲ Show 20 Lines • Show All 74 Lines • ▼ Show 20 Lines.. toctree::
modernize-make-unique modernize-make-unique
modernize-pass-by-value modernize-pass-by-value
modernize-raw-string-literal modernize-raw-string-literal
modernize-redundant-void-arg modernize-redundant-void-arg
modernize-replace-auto-ptr modernize-replace-auto-ptr
modernize-shrink-to-fit modernize-shrink-to-fit
modernize-use-auto modernize-use-auto
modernize-use-bool-literals modernize-use-bool-literals
modernize-use-default
modernize-use-emplace modernize-use-emplace
modernize-use-equals-default
modernize-use-equals-delete modernize-use-equals-delete
modernize-use-nullptr modernize-use-nullptr
modernize-use-override modernize-use-override
modernize-use-transparent-functors modernize-use-transparent-functors
modernize-use-using modernize-use-using
mpi-buffer-deref mpi-buffer-deref
mpi-type-mismatch mpi-type-mismatch
performance-faster-string-find performance-faster-string-find
Show All 26 Lines

clang-tools-extra/trunk/docs/clang-tidy/checks/modernize-use-default.rst

:orphan:
.. title:: clang-tidy - modernize-use-default .. title:: clang-tidy - modernize-use-default
.. meta::
:http-equiv=refresh: 5;URL=modernize-use-equals-default.html
modernize-use-default modernize-use-default
===================== =====================
This check replaces default bodies of special member functions with ``= This check has been renamed to
default;``. The explicitly defaulted function declarations enable more `modernize-use-equals-default <modernize-use-equals-default.html>`_.
opportunities in optimization, because the compiler might treat explicitly
defaulted functions as trivial.
.. code-block:: c++
struct A {
A() {}
~A();
};
A::~A() {}
// becomes
struct A {
A() = default;
~A();
};
A::~A() = default;
.. note::
Move-constructor and move-assignment operator are not supported yet.

clang-tools-extra/trunk/docs/clang-tidy/checks/modernize-use-equals-default.rst

.. title:: clang-tidy - modernize-use-equals-default
modernize-use-equals-default
============================
This check replaces default bodies of special member functions with ``=
default;``. The explicitly defaulted function declarations enable more
opportunities in optimization, because the compiler might treat explicitly
defaulted functions as trivial.
.. code-block:: c++
struct A {
A() {}
~A();
};
A::~A() {}
// becomes
struct A {
A() = default;
~A();
};
A::~A() = default;
.. note::
Move-constructor and move-assignment operator are not supported yet.

clang-tools-extra/trunk/test/clang-tidy/modernize-use-default-copy.cpp

// RUN: %check_clang_tidy %s modernize-use-default %t -- -- -std=c++11 -fno-delayed-template-parsing -fexceptions
// Out of line definition.
struct OL {
OL(const OL &);
OL &operator=(const OL &);
int Field;
};
OL::OL(const OL &Other) : Field(Other.Field) {}
// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use '= default' to define a trivial copy constructor [modernize-use-default]
// CHECK-FIXES: OL::OL(const OL &Other) = default;
OL &OL::operator=(const OL &Other) {
Field = Other.Field;
return *this;
}
// CHECK-MESSAGES: :[[@LINE-4]]:9: warning: use '= default' to define a trivial copy-assignment operator [modernize-use-default]
// CHECK-FIXES: OL &OL::operator=(const OL &Other) = default;
// Inline.
struct IL {
IL(const IL &Other) : Field(Other.Field) {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default'
// CHECK-FIXES: IL(const IL &Other) = default;
IL &operator=(const IL &Other) {
Field = Other.Field;
return *this;
}
// CHECK-MESSAGES: :[[@LINE-4]]:7: warning: use '= default'
// CHECK-FIXES: IL &operator=(const IL &Other) = default;
int Field;
};
// Wrong type.
struct WT {
WT(const IL &Other) {}
WT &operator=(const IL &);
};
WT &WT::operator=(const IL &Other) { return *this; }
// Qualifiers.
struct Qual {
Qual(const Qual &Other) : Field(Other.Field), Volatile(Other.Volatile),
Mutable(Other.Mutable), Reference(Other.Reference),
Const(Other.Const) {}
// CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use '= default'
// CHECK-FIXES: Qual(const Qual &Other)
// CHECK-FIXES: = default;
int Field;
volatile char Volatile;
mutable bool Mutable;
const OL &Reference; // This makes this class non-assignable.
const IL Const; // This also makes this class non-assignable.
static int Static;
};
// Wrong init arguments.
struct WI {
WI(const WI &Other) : Field1(Other.Field1), Field2(Other.Field1) {}
WI &operator=(const WI &);
int Field1, Field2;
};
WI &WI::operator=(const WI &Other) {
Field1 = Other.Field1;
Field2 = Other.Field1;
return *this;
}
// Missing field.
struct MF {
MF(const MF &Other) : Field1(Other.Field1), Field2(Other.Field2) {}
MF &operator=(const MF &);
int Field1, Field2, Field3;
};
MF &MF::operator=(const MF &Other) {
Field1 = Other.Field1;
Field2 = Other.Field2;
return *this;
}
struct Comments {
Comments(const Comments &Other)
/* don't delete */ : /* this comment */ Field(Other.Field) {}
// CHECK-MESSAGES: :[[@LINE-2]]:3: warning: use '= default'
// CHECK-FIXES: /* don't delete */ = default;
int Field;
};
struct MoreComments {
MoreComments(const MoreComments &Other) /* this comment is OK */
: Field(Other.Field) {}
// CHECK-MESSAGES: :[[@LINE-2]]:3: warning: use '= default'
// CHECK-FIXES: MoreComments(const MoreComments &Other) /* this comment is OK */
// CHECK-FIXES-NEXT: = default;
int Field;
};
struct ColonInComment {
ColonInComment(const ColonInComment &Other) /* : */ : Field(Other.Field) {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default'
// CHECK-FIXES: ColonInComment(const ColonInComment &Other) /* : */ = default;
int Field;
};
// No members or bases (in particular, no colon).
struct Empty {
Empty(const Empty &Other) {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default'
// CHECK-FIXES: Empty(const Empty &Other) = default;
Empty &operator=(const Empty &);
};
Empty &Empty::operator=(const Empty &Other) { return *this; }
// CHECK-MESSAGES: :[[@LINE-1]]:15: warning: use '= default'
// CHECK-FIXES: Empty &Empty::operator=(const Empty &Other) = default;
// Bit fields.
struct BF {
BF() = default;
BF(const BF &Other) : Field1(Other.Field1), Field2(Other.Field2), Field3(Other.Field3),
Field4(Other.Field4) {}
// CHECK-MESSAGES: :[[@LINE-2]]:3: warning: use '= default'
// CHECK-FIXES: BF(const BF &Other) {{$}}
// CHECK-FIXES: = default;
BF &operator=(const BF &);
unsigned Field1 : 3;
int : 7;
char Field2 : 6;
int : 0;
int Field3 : 24;
unsigned char Field4;
};
BF &BF::operator=(const BF &Other) {
Field1 = Other.Field1;
Field2 = Other.Field2;
Field3 = Other.Field3;
Field4 = Other.Field4;
return *this;
}
// CHECK-MESSAGES: :[[@LINE-7]]:9: warning: use '= default'
// CHECK-FIXES: BF &BF::operator=(const BF &Other) = default;
// Base classes.
struct BC : IL, OL, BF {
BC(const BC &Other) : IL(Other), OL(Other), BF(Other) {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default'
// CHECK-FIXES: BC(const BC &Other) = default;
BC &operator=(const BC &Other);
};
BC &BC::operator=(const BC &Other) {
IL::operator=(Other);
OL::operator=(Other);
BF::operator=(Other);
return *this;
}
// CHECK-MESSAGES: :[[@LINE-6]]:9: warning: use '= default'
// CHECK-FIXES: BC &BC::operator=(const BC &Other) = default;
// Base classes with member.
struct BCWM : IL, OL {
BCWM(const BCWM &Other) : IL(Other), OL(Other), Bf(Other.Bf) {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default'
// CHECK-FIXES: BCWM(const BCWM &Other) = default;
BCWM &operator=(const BCWM &);
BF Bf;
};
BCWM &BCWM::operator=(const BCWM &Other) {
IL::operator=(Other);
OL::operator=(Other);
Bf = Other.Bf;
return *this;
}
// CHECK-MESSAGES: :[[@LINE-6]]:13: warning: use '= default'
// CHECK-FIXES: BCWM &BCWM::operator=(const BCWM &Other) = default;
// Missing base class.
struct MBC : IL, OL, BF {
MBC(const MBC &Other) : IL(Other), OL(Other) {}
MBC &operator=(const MBC &);
};
MBC &MBC::operator=(const MBC &Other) {
IL::operator=(Other);
OL::operator=(Other);
return *this;
}
// Base classes, incorrect parameter.
struct BCIP : BCWM, BF {
BCIP(const BCIP &Other) : BCWM(Other), BF(Other.Bf) {}
BCIP &operator=(const BCIP &);
};
BCIP &BCIP::operator=(const BCIP &Other) {
BCWM::operator=(Other);
BF::operator=(Other.Bf);
return *this;
}
// Virtual base classes.
struct VA : virtual OL {};
struct VB : virtual OL {};
struct VBC : VA, VB, virtual OL {
// OL is the first thing that is going to be initialized, despite the fact
// that it is the last in the list of bases, because it is virtual and there
// is a virtual OL at the beginning of VA (which is the same).
VBC(const VBC &Other) : OL(Other), VA(Other), VB(Other) {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default'
// CHECK-FIXES: VBC(const VBC &Other) = default;
VBC &operator=(const VBC &Other);
};
VBC &VBC::operator=(const VBC &Other) {
OL::operator=(Other);
VA::operator=(Other);
VB::operator=(Other);
return *this;
}
// CHECK-MESSAGES: :[[@LINE-6]]:11: warning: use '= default'
// CHECK-FIXES: VBC &VBC::operator=(const VBC &Other) = default;
// Indirect base.
struct IB : VBC {
IB(const IB &Other) : OL(Other), VBC(Other) {}
IB &operator=(const IB &);
};
IB &IB::operator=(const IB &Other) {
OL::operator=(Other);
VBC::operator=(Other);
return *this;
}
// Class template.
template <class T>
struct Template {
Template() = default;
Template(const Template &Other) : Field(Other.Field) {}
Template &operator=(const Template &Other);
void foo(const T &t);
int Field;
};
template <class T>
Template<T> &Template<T>::operator=(const Template<T> &Other) {
Field = Other.Field;
return *this;
}
Template<int> T1;
// Dependent types.
template <class T>
struct DT1 {
DT1() = default;
DT1(const DT1 &Other) : Field(Other.Field) {}
DT1 &operator=(const DT1 &);
T Field;
};
template <class T>
DT1<T> &DT1<T>::operator=(const DT1<T> &Other) {
Field = Other.Field;
return *this;
}
DT1<int> Dt1;
template <class T>
struct DT2 {
DT2() = default;
DT2(const DT2 &Other) : Field(Other.Field), Dependent(Other.Dependent) {}
DT2 &operator=(const DT2 &);
T Field;
typename T::TT Dependent;
};
template <class T>
DT2<T> &DT2<T>::operator=(const DT2<T> &Other) {
Field = Other.Field;
Dependent = Other.Dependent;
return *this;
}
struct T {
typedef int TT;
};
DT2<T> Dt2;
// Default arguments.
struct DA {
DA(int Int);
DA(const DA &Other = DA(0)) : Field1(Other.Field1), Field2(Other.Field2) {}
DA &operator=(const DA &);
int Field1;
char Field2;
};
// Overloaded operator= cannot have a default argument.
DA &DA::operator=(const DA &Other) {
Field1 = Other.Field1;
Field2 = Other.Field2;
return *this;
}
// CHECK-MESSAGES: :[[@LINE-5]]:9: warning: use '= default'
// CHECK-FIXES: DA &DA::operator=(const DA &Other) = default;
struct DA2 {
// Can be used as copy-constructor but cannot be explicitly defaulted.
DA2(const DA &Other, int Def = 0) {}
};
// Default initialization.
struct DI {
DI(const DI &Other) : Field1(Other.Field1), Field2(Other.Field2) {}
int Field1;
int Field2 = 0;
int Fiedl3;
};
// Statement inside body.
void foo();
struct SIB {
SIB(const SIB &Other) : Field(Other.Field) { foo(); }
SIB &operator=(const SIB &);
int Field;
};
SIB &SIB::operator=(const SIB &Other) {
Field = Other.Field;
foo();
return *this;
}
// Comment inside body.
struct CIB {
CIB(const CIB &Other) : Field(Other.Field) { /* Don't erase this */
}
// CHECK-MESSAGES: :[[@LINE-2]]:3: warning: use '= default'
CIB &operator=(const CIB &);
int Field;
};
CIB &CIB::operator=(const CIB &Other) {
Field = Other.Field;
// FIXME: don't erase this comment.
return *this;
}
// CHECK-MESSAGES: :[[@LINE-5]]:11: warning: use '= default'
// CHECK-FIXES: CIB &CIB::operator=(const CIB &Other) = default;
// Take non-const reference as argument.
struct NCRef {
NCRef(NCRef &Other) : Field1(Other.Field1), Field2(Other.Field2) {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default'
// CHECK-FIXES: NCRef(NCRef &Other) = default;
NCRef &operator=(NCRef &);
int Field1, Field2;
};
NCRef &NCRef::operator=(NCRef &Other) {
Field1 = Other.Field1;
Field2 = Other.Field2;
return *this;
}
// CHECK-MESSAGES: :[[@LINE-5]]:15: warning: use '= default'
// CHECK-FIXES: NCRef &NCRef::operator=(NCRef &Other) = default;
// Already defaulted.
struct IAD {
IAD(const IAD &Other) = default;
IAD &operator=(const IAD &Other) = default;
};
struct OAD {
OAD(const OAD &Other);
OAD &operator=(const OAD &);
};
OAD::OAD(const OAD &Other) = default;
OAD &OAD::operator=(const OAD &Other) = default;
// Deleted.
struct ID {
ID(const ID &Other) = delete;
ID &operator=(const ID &Other) = delete;
};
// Non-reference parameter.
struct NRef {
NRef &operator=(NRef Other);
int Field1;
};
NRef &NRef::operator=(NRef Other) {
Field1 = Other.Field1;
return *this;
}
// RValue reference parameter.
struct RVR {
RVR(RVR &&Other) {}
RVR &operator=(RVR &&);
};
RVR &RVR::operator=(RVR &&Other) { return *this; }
// Similar function.
struct SF {
SF &foo(const SF &);
int Field1;
};
SF &SF::foo(const SF &Other) {
Field1 = Other.Field1;
return *this;
}
// No return.
struct NR {
NR &operator=(const NR &);
};
NR &NR::operator=(const NR &Other) {}
// Return misplaced.
struct RM {
RM &operator=(const RM &);
int Field;
};
RM &RM::operator=(const RM &Other) {
return *this;
Field = Other.Field;
}
// Wrong return value.
struct WRV {
WRV &operator=(WRV &);
};
WRV &WRV::operator=(WRV &Other) {
return Other;
}
// Wrong return type.
struct WRT : IL {
IL &operator=(const WRT &);
};
IL &WRT::operator=(const WRT &Other) {
return *this;
}
// Try-catch.
struct ITC {
ITC(const ITC &Other)
try : Field(Other.Field) {
} catch (...) {
}
ITC &operator=(const ITC &Other) try {
Field = Other.Field;
} catch (...) {
}
int Field;
};
struct OTC {
OTC(const OTC &);
OTC &operator=(const OTC &);
int Field;
};
OTC::OTC(const OTC &Other) try : Field(Other.Field) {
} catch (...) {
}
OTC &OTC::operator=(const OTC &Other) try {
Field = Other.Field;
} catch (...) {
}
// FIXME: the check is not able to detect exception specification.
// noexcept(true).
struct NET {
// This is the default.
//NET(const NET &Other) noexcept {}
NET &operator=(const NET &Other) noexcept;
};
//NET &NET::operator=(const NET &Other) noexcept { return *this; }
// noexcept(false).
struct NEF {
// This is the default.
//NEF(const NEF &Other) noexcept(false) {}
NEF &operator=(const NEF &Other) noexcept(false);
};
//NEF &NEF::operator=(const NEF &Other) noexcept(false) { return *this; }
#define STRUCT_WITH_COPY_CONSTRUCT(_base, _type) \
struct _type { \
_type(const _type &v) : value(v.value) {} \
_base value; \
};
STRUCT_WITH_COPY_CONSTRUCT(unsigned char, Hex8CopyConstruct)
// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: use '= default' to define a trivial copy constructor
// CHECK-MESSAGES: :[[@LINE-6]]:44: note:
#define STRUCT_WITH_COPY_ASSIGN(_base, _type) \
struct _type { \
_type &operator=(const _type &rhs) { \
value = rhs.value; \
return *this; \
} \
_base value; \
};
STRUCT_WITH_COPY_ASSIGN(unsigned char, Hex8CopyAssign)
// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: use '= default' to define a trivial copy-assignment operator
// CHECK-MESSAGES: :[[@LINE-9]]:40: note:

clang-tools-extra/trunk/test/clang-tidy/modernize-use-default-delayed.cpp

// RUN: clang-tidy %s -checks=-*,modernize-use-default -- -std=c++11 -fdelayed-template-parsing -fexceptions | count 0
// Note: this test expects no diagnostics, but FileCheck cannot handle that,
// hence the use of | count 0.
template <typename Ty>
struct S {
S<Ty>& operator=(const S<Ty>&) { return *this; }
};

clang-tools-extra/trunk/test/clang-tidy/modernize-use-default.cpp

// RUN: %check_clang_tidy %s modernize-use-default %t -- -- -std=c++11 -fno-delayed-template-parsing -fexceptions
// Out of line definition.
class OL {
public:
OL();
~OL();
};
OL::OL() {}
// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use '= default' to define a trivial default constructor [modernize-use-default]
// CHECK-FIXES: OL::OL() = default;
OL::~OL() {}
// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use '= default' to define a trivial destructor [modernize-use-default]
// CHECK-FIXES: OL::~OL() = default;
// Inline definitions.
class IL {
public:
IL() {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default'
// CHECK-FIXES: IL() = default;
~IL() {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default'
// CHECK-FIXES: ~IL() = default;
};
// Non-empty body.
void f();
class NE {
public:
NE() { f(); }
~NE() { f(); }
};
// Initializer or arguments.
class IA {
public:
// Constructor with initializer.
IA() : Field(5) {}
// Constructor with arguments.
IA(int Arg1, int Arg2) {}
int Field;
};
// Default member initializer
class DMI {
public:
DMI() {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default'
// CHECK-FIXES: DMI() = default;
int Field = 5;
};
// Class member
class CM {
public:
CM() {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default'
// CHECK-FIXES: CM() = default;
OL o;
};
// Private constructor/destructor.
class Priv {
Priv() {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default'
// CHECK-FIXES: Priv() = default;
~Priv() {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default'
// CHECK-FIXES: ~Priv() = default;
};
// struct.
struct ST {
ST() {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default'
// CHECK-FIXES: ST() = default;
~ST() {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default'
// CHECK-FIXES: ST() = default;
};
// Deleted constructor/destructor.
class Del {
public:
Del() = delete;
~Del() = delete;
};
// Do not remove other keywords.
class KW {
public:
explicit KW() {}
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use '= default'
// CHECK-FIXES: explicit KW() = default;
virtual ~KW() {}
// CHECK-MESSAGES: :[[@LINE-1]]:11: warning: use '= default'
// CHECK-FIXES: virtual ~KW() = default;
};
// Nested class.
struct N {
struct NN {
NN() {}
// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use '= default'
// CHECK-FIXES: NN() = default;
~NN() {}
// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use '= default'
// CHECK-FIXES: ~NN() = default;
};
int Int;
};
// Class template.
template <class T>
class Temp {
public:
Temp() {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default'
// CHECK-FIXES: Temp() = default;
~Temp() {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default'
// CHECK-FIXES: ~Temp() = default;
};
// Class template out of line with explicit instantiation.
template <class T>
class TempODef {
public:
TempODef();
~TempODef();
};
template <class T>
TempODef<T>::TempODef() {}
// CHECK-MESSAGES: :[[@LINE-1]]:14: warning: use '= default'
// CHECK-FIXES: TempODef<T>::TempODef() = default;
template <class T>
TempODef<T>::~TempODef() {}
// CHECK-MESSAGES: :[[@LINE-1]]:14: warning: use '= default'
// CHECK-FIXES: TempODef<T>::~TempODef() = default;
template class TempODef<int>;
template class TempODef<double>;
// Non user-provided constructor/destructor.
struct Imp {
int Int;
};
void g() {
Imp *PtrImp = new Imp();
PtrImp->~Imp();
delete PtrImp;
}
// Already using default.
struct IDef {
IDef() = default;
~IDef() = default;
};
struct ODef {
ODef();
~ODef();
};
ODef::ODef() = default;
ODef::~ODef() = default;
// Delegating constructor and overriden destructor.
struct DC : KW {
DC() : KW() {}
~DC() override {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default'
// CHECK-FIXES: ~DC() override = default;
};
struct Comments {
Comments() {
// Don't erase comments inside the body.
}
// CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use '= default'
~Comments() {
// Don't erase comments inside the body.
}
// CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use '= default'
};
// Try-catch.
struct ITC {
ITC() try {} catch(...) {}
~ITC() try {} catch(...) {}
};
struct OTC {
OTC();
~OTC();
};
OTC::OTC() try {} catch(...) {}
OTC::~OTC() try {} catch(...) {}
#define STRUCT_WITH_DEFAULT(_base, _type) \
struct _type { \
_type() {} \
_base value; \
};
STRUCT_WITH_DEFAULT(unsigned char, Hex8Default)
// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: use '= default' to define a trivial default constructor
// CHECK-MESSAGES: :[[@LINE-6]]:13: note:

clang-tools-extra/trunk/test/clang-tidy/modernize-use-equals-default-copy.cpp

// RUN: %check_clang_tidy %s modernize-use-equals-default %t -- -- -std=c++11 -fno-delayed-template-parsing -fexceptions
// Out of line definition.
struct OL {
OL(const OL &);
OL &operator=(const OL &);
int Field;
};
OL::OL(const OL &Other) : Field(Other.Field) {}
// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use '= default' to define a trivial copy constructor [modernize-use-equals-default]
// CHECK-FIXES: OL::OL(const OL &Other) = default;
OL &OL::operator=(const OL &Other) {
Field = Other.Field;
return *this;
}
// CHECK-MESSAGES: :[[@LINE-4]]:9: warning: use '= default' to define a trivial copy-assignment operator [modernize-use-equals-default]
// CHECK-FIXES: OL &OL::operator=(const OL &Other) = default;
// Inline.
struct IL {
IL(const IL &Other) : Field(Other.Field) {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default'
// CHECK-FIXES: IL(const IL &Other) = default;
IL &operator=(const IL &Other) {
Field = Other.Field;
return *this;
}
// CHECK-MESSAGES: :[[@LINE-4]]:7: warning: use '= default'
// CHECK-FIXES: IL &operator=(const IL &Other) = default;
int Field;
};
// Wrong type.
struct WT {
WT(const IL &Other) {}
WT &operator=(const IL &);
};
WT &WT::operator=(const IL &Other) { return *this; }
// Qualifiers.
struct Qual {
Qual(const Qual &Other) : Field(Other.Field), Volatile(Other.Volatile),
Mutable(Other.Mutable), Reference(Other.Reference),
Const(Other.Const) {}
// CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use '= default'
// CHECK-FIXES: Qual(const Qual &Other)
// CHECK-FIXES: = default;
int Field;
volatile char Volatile;
mutable bool Mutable;
const OL &Reference; // This makes this class non-assignable.
const IL Const; // This also makes this class non-assignable.
static int Static;
};
// Wrong init arguments.
struct WI {
WI(const WI &Other) : Field1(Other.Field1), Field2(Other.Field1) {}
WI &operator=(const WI &);
int Field1, Field2;
};
WI &WI::operator=(const WI &Other) {
Field1 = Other.Field1;
Field2 = Other.Field1;
return *this;
}
// Missing field.
struct MF {
MF(const MF &Other) : Field1(Other.Field1), Field2(Other.Field2) {}
MF &operator=(const MF &);
int Field1, Field2, Field3;
};
MF &MF::operator=(const MF &Other) {
Field1 = Other.Field1;
Field2 = Other.Field2;
return *this;
}
struct Comments {
Comments(const Comments &Other)
/* don't delete */ : /* this comment */ Field(Other.Field) {}
// CHECK-MESSAGES: :[[@LINE-2]]:3: warning: use '= default'
// CHECK-FIXES: /* don't delete */ = default;
int Field;
};
struct MoreComments {
MoreComments(const MoreComments &Other) /* this comment is OK */
: Field(Other.Field) {}
// CHECK-MESSAGES: :[[@LINE-2]]:3: warning: use '= default'
// CHECK-FIXES: MoreComments(const MoreComments &Other) /* this comment is OK */
// CHECK-FIXES-NEXT: = default;
int Field;
};
struct ColonInComment {
ColonInComment(const ColonInComment &Other) /* : */ : Field(Other.Field) {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default'
// CHECK-FIXES: ColonInComment(const ColonInComment &Other) /* : */ = default;
int Field;
};
// No members or bases (in particular, no colon).
struct Empty {
Empty(const Empty &Other) {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default'
// CHECK-FIXES: Empty(const Empty &Other) = default;
Empty &operator=(const Empty &);
};
Empty &Empty::operator=(const Empty &Other) { return *this; }
// CHECK-MESSAGES: :[[@LINE-1]]:15: warning: use '= default'
// CHECK-FIXES: Empty &Empty::operator=(const Empty &Other) = default;
// Bit fields.
struct BF {
BF() = default;
BF(const BF &Other) : Field1(Other.Field1), Field2(Other.Field2), Field3(Other.Field3),
Field4(Other.Field4) {}
// CHECK-MESSAGES: :[[@LINE-2]]:3: warning: use '= default'
// CHECK-FIXES: BF(const BF &Other) {{$}}
// CHECK-FIXES: = default;
BF &operator=(const BF &);
unsigned Field1 : 3;
int : 7;
char Field2 : 6;
int : 0;
int Field3 : 24;
unsigned char Field4;
};
BF &BF::operator=(const BF &Other) {
Field1 = Other.Field1;
Field2 = Other.Field2;
Field3 = Other.Field3;
Field4 = Other.Field4;
return *this;
}
// CHECK-MESSAGES: :[[@LINE-7]]:9: warning: use '= default'
// CHECK-FIXES: BF &BF::operator=(const BF &Other) = default;
// Base classes.
struct BC : IL, OL, BF {
BC(const BC &Other) : IL(Other), OL(Other), BF(Other) {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default'
// CHECK-FIXES: BC(const BC &Other) = default;
BC &operator=(const BC &Other);
};
BC &BC::operator=(const BC &Other) {
IL::operator=(Other);
OL::operator=(Other);
BF::operator=(Other);
return *this;
}
// CHECK-MESSAGES: :[[@LINE-6]]:9: warning: use '= default'
// CHECK-FIXES: BC &BC::operator=(const BC &Other) = default;
// Base classes with member.
struct BCWM : IL, OL {
BCWM(const BCWM &Other) : IL(Other), OL(Other), Bf(Other.Bf) {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default'
// CHECK-FIXES: BCWM(const BCWM &Other) = default;
BCWM &operator=(const BCWM &);
BF Bf;
};
BCWM &BCWM::operator=(const BCWM &Other) {
IL::operator=(Other);
OL::operator=(Other);
Bf = Other.Bf;
return *this;
}
// CHECK-MESSAGES: :[[@LINE-6]]:13: warning: use '= default'
// CHECK-FIXES: BCWM &BCWM::operator=(const BCWM &Other) = default;
// Missing base class.
struct MBC : IL, OL, BF {
MBC(const MBC &Other) : IL(Other), OL(Other) {}
MBC &operator=(const MBC &);
};
MBC &MBC::operator=(const MBC &Other) {
IL::operator=(Other);
OL::operator=(Other);
return *this;
}
// Base classes, incorrect parameter.
struct BCIP : BCWM, BF {
BCIP(const BCIP &Other) : BCWM(Other), BF(Other.Bf) {}
BCIP &operator=(const BCIP &);
};
BCIP &BCIP::operator=(const BCIP &Other) {
BCWM::operator=(Other);
BF::operator=(Other.Bf);
return *this;
}
// Virtual base classes.
struct VA : virtual OL {};
struct VB : virtual OL {};
struct VBC : VA, VB, virtual OL {
// OL is the first thing that is going to be initialized, despite the fact
// that it is the last in the list of bases, because it is virtual and there
// is a virtual OL at the beginning of VA (which is the same).
VBC(const VBC &Other) : OL(Other), VA(Other), VB(Other) {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default'
// CHECK-FIXES: VBC(const VBC &Other) = default;
VBC &operator=(const VBC &Other);
};
VBC &VBC::operator=(const VBC &Other) {
OL::operator=(Other);
VA::operator=(Other);
VB::operator=(Other);
return *this;
}
// CHECK-MESSAGES: :[[@LINE-6]]:11: warning: use '= default'
// CHECK-FIXES: VBC &VBC::operator=(const VBC &Other) = default;
// Indirect base.
struct IB : VBC {
IB(const IB &Other) : OL(Other), VBC(Other) {}
IB &operator=(const IB &);
};
IB &IB::operator=(const IB &Other) {
OL::operator=(Other);
VBC::operator=(Other);
return *this;
}
// Class template.
template <class T>
struct Template {
Template() = default;
Template(const Template &Other) : Field(Other.Field) {}
Template &operator=(const Template &Other);
void foo(const T &t);
int Field;
};
template <class T>
Template<T> &Template<T>::operator=(const Template<T> &Other) {
Field = Other.Field;
return *this;
}
Template<int> T1;
// Dependent types.
template <class T>
struct DT1 {
DT1() = default;
DT1(const DT1 &Other) : Field(Other.Field) {}
DT1 &operator=(const DT1 &);
T Field;
};
template <class T>
DT1<T> &DT1<T>::operator=(const DT1<T> &Other) {
Field = Other.Field;
return *this;
}
DT1<int> Dt1;
template <class T>
struct DT2 {
DT2() = default;
DT2(const DT2 &Other) : Field(Other.Field), Dependent(Other.Dependent) {}
DT2 &operator=(const DT2 &);
T Field;
typename T::TT Dependent;
};
template <class T>
DT2<T> &DT2<T>::operator=(const DT2<T> &Other) {
Field = Other.Field;
Dependent = Other.Dependent;
return *this;
}
struct T {
typedef int TT;
};
DT2<T> Dt2;
// Default arguments.
struct DA {
DA(int Int);
DA(const DA &Other = DA(0)) : Field1(Other.Field1), Field2(Other.Field2) {}
DA &operator=(const DA &);
int Field1;
char Field2;
};
// Overloaded operator= cannot have a default argument.
DA &DA::operator=(const DA &Other) {
Field1 = Other.Field1;
Field2 = Other.Field2;
return *this;
}
// CHECK-MESSAGES: :[[@LINE-5]]:9: warning: use '= default'
// CHECK-FIXES: DA &DA::operator=(const DA &Other) = default;
struct DA2 {
// Can be used as copy-constructor but cannot be explicitly defaulted.
DA2(const DA &Other, int Def = 0) {}
};
// Default initialization.
struct DI {
DI(const DI &Other) : Field1(Other.Field1), Field2(Other.Field2) {}
int Field1;
int Field2 = 0;
int Fiedl3;
};
// Statement inside body.
void foo();
struct SIB {
SIB(const SIB &Other) : Field(Other.Field) { foo(); }
SIB &operator=(const SIB &);
int Field;
};
SIB &SIB::operator=(const SIB &Other) {
Field = Other.Field;
foo();
return *this;
}
// Comment inside body.
struct CIB {
CIB(const CIB &Other) : Field(Other.Field) { /* Don't erase this */
}
// CHECK-MESSAGES: :[[@LINE-2]]:3: warning: use '= default'
CIB &operator=(const CIB &);
int Field;
};
CIB &CIB::operator=(const CIB &Other) {
Field = Other.Field;
// FIXME: don't erase this comment.
return *this;
}
// CHECK-MESSAGES: :[[@LINE-5]]:11: warning: use '= default'
// CHECK-FIXES: CIB &CIB::operator=(const CIB &Other) = default;
// Take non-const reference as argument.
struct NCRef {
NCRef(NCRef &Other) : Field1(Other.Field1), Field2(Other.Field2) {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default'
// CHECK-FIXES: NCRef(NCRef &Other) = default;
NCRef &operator=(NCRef &);
int Field1, Field2;
};
NCRef &NCRef::operator=(NCRef &Other) {
Field1 = Other.Field1;
Field2 = Other.Field2;
return *this;
}
// CHECK-MESSAGES: :[[@LINE-5]]:15: warning: use '= default'
// CHECK-FIXES: NCRef &NCRef::operator=(NCRef &Other) = default;
// Already defaulted.
struct IAD {
IAD(const IAD &Other) = default;
IAD &operator=(const IAD &Other) = default;
};
struct OAD {
OAD(const OAD &Other);
OAD &operator=(const OAD &);
};
OAD::OAD(const OAD &Other) = default;
OAD &OAD::operator=(const OAD &Other) = default;
// Deleted.
struct ID {
ID(const ID &Other) = delete;
ID &operator=(const ID &Other) = delete;
};
// Non-reference parameter.
struct NRef {
NRef &operator=(NRef Other);
int Field1;
};
NRef &NRef::operator=(NRef Other) {
Field1 = Other.Field1;
return *this;
}
// RValue reference parameter.
struct RVR {
RVR(RVR &&Other) {}
RVR &operator=(RVR &&);
};
RVR &RVR::operator=(RVR &&Other) { return *this; }
// Similar function.
struct SF {
SF &foo(const SF &);
int Field1;
};
SF &SF::foo(const SF &Other) {
Field1 = Other.Field1;
return *this;
}
// No return.
struct NR {
NR &operator=(const NR &);
};
NR &NR::operator=(const NR &Other) {}
// Return misplaced.
struct RM {
RM &operator=(const RM &);
int Field;
};
RM &RM::operator=(const RM &Other) {
return *this;
Field = Other.Field;
}
// Wrong return value.
struct WRV {
WRV &operator=(WRV &);
};
WRV &WRV::operator=(WRV &Other) {
return Other;
}
// Wrong return type.
struct WRT : IL {
IL &operator=(const WRT &);
};
IL &WRT::operator=(const WRT &Other) {
return *this;
}
// Try-catch.
struct ITC {
ITC(const ITC &Other)
try : Field(Other.Field) {
} catch (...) {
}
ITC &operator=(const ITC &Other) try {
Field = Other.Field;
} catch (...) {
}
int Field;
};
struct OTC {
OTC(const OTC &);
OTC &operator=(const OTC &);
int Field;
};
OTC::OTC(const OTC &Other) try : Field(Other.Field) {
} catch (...) {
}
OTC &OTC::operator=(const OTC &Other) try {
Field = Other.Field;
} catch (...) {
}
// FIXME: the check is not able to detect exception specification.
// noexcept(true).
struct NET {
// This is the default.
//NET(const NET &Other) noexcept {}
NET &operator=(const NET &Other) noexcept;
};
//NET &NET::operator=(const NET &Other) noexcept { return *this; }
// noexcept(false).
struct NEF {
// This is the default.
//NEF(const NEF &Other) noexcept(false) {}
NEF &operator=(const NEF &Other) noexcept(false);
};
//NEF &NEF::operator=(const NEF &Other) noexcept(false) { return *this; }
#define STRUCT_WITH_COPY_CONSTRUCT(_base, _type) \
struct _type { \
_type(const _type &v) : value(v.value) {} \
_base value; \
};
STRUCT_WITH_COPY_CONSTRUCT(unsigned char, Hex8CopyConstruct)
// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: use '= default' to define a trivial copy constructor
// CHECK-MESSAGES: :[[@LINE-6]]:44: note:
#define STRUCT_WITH_COPY_ASSIGN(_base, _type) \
struct _type { \
_type &operator=(const _type &rhs) { \
value = rhs.value; \
return *this; \
} \
_base value; \
};
STRUCT_WITH_COPY_ASSIGN(unsigned char, Hex8CopyAssign)
// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: use '= default' to define a trivial copy-assignment operator
// CHECK-MESSAGES: :[[@LINE-9]]:40: note:

clang-tools-extra/trunk/test/clang-tidy/modernize-use-equals-default-delayed.cpp

// RUN: clang-tidy %s -checks=-*,modernize-use-equals-default -- -std=c++11 -fdelayed-template-parsing -fexceptions | count 0
// Note: this test expects no diagnostics, but FileCheck cannot handle that,
// hence the use of | count 0.
template <typename Ty>
struct S {
S<Ty>& operator=(const S<Ty>&) { return *this; }
};

clang-tools-extra/trunk/test/clang-tidy/modernize-use-equals-default.cpp

// RUN: %check_clang_tidy %s modernize-use-equals-default %t -- -- -std=c++11 -fno-delayed-template-parsing -fexceptions
// Out of line definition.
class OL {
public:
OL();
~OL();
};
OL::OL() {}
// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use '= default' to define a trivial default constructor [modernize-use-equals-default]
// CHECK-FIXES: OL::OL() = default;
OL::~OL() {}
// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use '= default' to define a trivial destructor [modernize-use-equals-default]
// CHECK-FIXES: OL::~OL() = default;
// Inline definitions.
class IL {
public:
IL() {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default'
// CHECK-FIXES: IL() = default;
~IL() {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default'
// CHECK-FIXES: ~IL() = default;
};
// Non-empty body.
void f();
class NE {
public:
NE() { f(); }
~NE() { f(); }
};
// Initializer or arguments.
class IA {
public:
// Constructor with initializer.
IA() : Field(5) {}
// Constructor with arguments.
IA(int Arg1, int Arg2) {}
int Field;
};
// Default member initializer
class DMI {
public:
DMI() {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default'
// CHECK-FIXES: DMI() = default;
int Field = 5;
};
// Class member
class CM {
public:
CM() {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default'
// CHECK-FIXES: CM() = default;
OL o;
};
// Private constructor/destructor.
class Priv {
Priv() {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default'
// CHECK-FIXES: Priv() = default;
~Priv() {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default'
// CHECK-FIXES: ~Priv() = default;
};
// struct.
struct ST {
ST() {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default'
// CHECK-FIXES: ST() = default;
~ST() {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default'
// CHECK-FIXES: ST() = default;
};
// Deleted constructor/destructor.
class Del {
public:
Del() = delete;
~Del() = delete;
};
// Do not remove other keywords.
class KW {
public:
explicit KW() {}
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use '= default'
// CHECK-FIXES: explicit KW() = default;
virtual ~KW() {}
// CHECK-MESSAGES: :[[@LINE-1]]:11: warning: use '= default'
// CHECK-FIXES: virtual ~KW() = default;
};
// Nested class.
struct N {
struct NN {
NN() {}
// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use '= default'
// CHECK-FIXES: NN() = default;
~NN() {}
// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use '= default'
// CHECK-FIXES: ~NN() = default;
};
int Int;
};
// Class template.
template <class T>
class Temp {
public:
Temp() {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default'
// CHECK-FIXES: Temp() = default;
~Temp() {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default'
// CHECK-FIXES: ~Temp() = default;
};
// Class template out of line with explicit instantiation.
template <class T>
class TempODef {
public:
TempODef();
~TempODef();
};
template <class T>
TempODef<T>::TempODef() {}
// CHECK-MESSAGES: :[[@LINE-1]]:14: warning: use '= default'
// CHECK-FIXES: TempODef<T>::TempODef() = default;
template <class T>
TempODef<T>::~TempODef() {}
// CHECK-MESSAGES: :[[@LINE-1]]:14: warning: use '= default'
// CHECK-FIXES: TempODef<T>::~TempODef() = default;
template class TempODef<int>;
template class TempODef<double>;
// Non user-provided constructor/destructor.
struct Imp {
int Int;
};
void g() {
Imp *PtrImp = new Imp();
PtrImp->~Imp();
delete PtrImp;
}
// Already using default.
struct IDef {
IDef() = default;
~IDef() = default;
};
struct ODef {
ODef();
~ODef();
};
ODef::ODef() = default;
ODef::~ODef() = default;
// Delegating constructor and overriden destructor.
struct DC : KW {
DC() : KW() {}
~DC() override {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default'
// CHECK-FIXES: ~DC() override = default;
};
struct Comments {
Comments() {
// Don't erase comments inside the body.
}
// CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use '= default'
~Comments() {
// Don't erase comments inside the body.
}
// CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use '= default'
};
// Try-catch.
struct ITC {
ITC() try {} catch(...) {}
~ITC() try {} catch(...) {}
};
struct OTC {
OTC();
~OTC();
};
OTC::OTC() try {} catch(...) {}
OTC::~OTC() try {} catch(...) {}
#define STRUCT_WITH_DEFAULT(_base, _type) \
struct _type { \
_type() {} \
_base value; \
};
STRUCT_WITH_DEFAULT(unsigned char, Hex8Default)
// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: use '= default' to define a trivial default constructor
// CHECK-MESSAGES: :[[@LINE-6]]:13: note:
clang-tools-extra/trunk/test/clang-tidy/modernize-use-default-copy.cpp