maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang-tools-extra/clang-tidy/readability/ContainerSizeEmptyCheck.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

326 lines
14 KiB
C++
Raw Normal View History

[clang-tidy] Refactor: Rename clang-tidy readability check files and classes to follow naming conventions Classes are named WhateverCheck, files are WhateverCheck.cpp and` WhateverCheck.h` http://reviews.llvm.org/D8144 Patch by Richard Thomson! llvm-svn: 231650
2015-03-09 20:18:39 +08:00
//===--- ContainerSizeEmptyCheck.cpp - clang-tidy -------------------------===//
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
//
Update the file headers across all of the LLVM projects in the monorepo to reflect the new license. We understand that people may be surprised that we're moving the header entirely to discuss the new license. We checked this carefully with the Foundation's lawyer and we believe this is the correct approach. Essentially, all code in the project is now made available by the LLVM project under our new license, so you will see that the license headers include that license only. Some of our contributors have contributed code under our old license, and accordingly, we have retained a copy of our old license notice in the top-level files in each project and repository. llvm-svn: 351636
2019-01-19 16:50:56 +08:00
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
//
//===----------------------------------------------------------------------===//
[clang-tidy] Refactor: Rename clang-tidy readability check files and classes to follow naming conventions Classes are named WhateverCheck, files are WhateverCheck.cpp and` WhateverCheck.h` http://reviews.llvm.org/D8144 Patch by Richard Thomson! llvm-svn: 231650
2015-03-09 20:18:39 +08:00
#include "ContainerSizeEmptyCheck.h"
Extend readability-container-size-empty to add comparisons to empty-state objects. Patch by Josh Zimmerman. llvm-svn: 301185
2017-04-24 22:57:09 +08:00
#include "../utils/ASTUtils.h"
[clang-tidy] Extend readability-container-size-empty to arbitrary class with size() and empty() This patch extends readability-container-size-empty check allowing it to produce warnings not only for STL containers, but also for containers, which provide two functions matching following signatures: * `size_type size() const;` * `bool empty() const;` Where `size_type` can be any kind of integer type. This functionality was proposed in https://llvm.org/bugs/show_bug.cgi?id=26823 by Eugene Zelenko. Approval: alexfh Reviewers: alexfh, aaron.ballman, Eugene.Zelenko Subscribers: etienneb, Prazek, hokein, xazax.hun, cfe-commits Differential Revision: https://reviews.llvm.org/D24349 llvm-svn: 281307
2016-09-13 16:58:11 +08:00
#include "../utils/Matchers.h"
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
#include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/Lex/Lexer.h"
Re-sort includes using the LLVM utils/sort_includes.py script. llvm-svn: 229087
2015-02-13 17:07:58 +08:00
#include "llvm/ADT/StringRef.h"
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
using namespace clang::ast_matchers;
namespace clang {
[clang-tidy] Handle template instantiations in container size check readability-container-size-empty currently modifies source code based on AST nodes in template instantiations, which means that it makes transformations based on substituted types. This can lead to transforming code to be broken. Change the matcher implementation to ignore template instantiations explicitly, and add a matcher to explicitly handle template declarations instead of instantiations. Differential Revision: https://reviews.llvm.org/D91302
2020-10-28 07:24:20 +08:00
namespace ast_matchers {
AST_POLYMORPHIC_MATCHER_P2(hasAnyArgumentWithParam,
AST_POLYMORPHIC_SUPPORTED_TYPES(CallExpr,
CXXConstructExpr),
internal::Matcher<Expr>, ArgMatcher,
internal::Matcher<ParmVarDecl>, ParamMatcher) {
BoundNodesTreeBuilder Result;
// The first argument of an overloaded member operator is the implicit object
// argument of the method which should not be matched against a parameter, so
// we skip over it here.
BoundNodesTreeBuilder Matches;
unsigned ArgIndex = cxxOperatorCallExpr(callee(cxxMethodDecl()))
.matches(Node, Finder, &Matches)
? 1
: 0;
int ParamIndex = 0;
for (; ArgIndex < Node.getNumArgs(); ++ArgIndex) {
BoundNodesTreeBuilder ArgMatches(*Builder);
if (ArgMatcher.matches(*(Node.getArg(ArgIndex)->IgnoreParenCasts()), Finder,
&ArgMatches)) {
BoundNodesTreeBuilder ParamMatches(ArgMatches);
if (expr(anyOf(cxxConstructExpr(hasDeclaration(cxxConstructorDecl(
hasParameter(ParamIndex, ParamMatcher)))),
callExpr(callee(functionDecl(
hasParameter(ParamIndex, ParamMatcher))))))
.matches(Node, Finder, &ParamMatches)) {
Result.addMatch(ParamMatches);
*Builder = std::move(Result);
return true;
}
}
++ParamIndex;
}
return false;
}
AST_MATCHER(Expr, usedInBooleanContext) {
const char *ExprName = "__booleanContextExpr";
auto Result =
expr(expr().bind(ExprName),
[clang-tidy] Use new mapping matchers Use mapAnyOf() and matchers based on it. Use of binaryOperation() means that modernize-loop-convert and readability-container-size-empty can now be used with rewritten binary operators. Differential Revision: https://reviews.llvm.org/D94131
2021-01-03 05:18:29 +08:00
anyOf(hasParent(
mapAnyOf(varDecl, fieldDecl).with(hasType(booleanType()))),
[clang-tidy] Handle template instantiations in container size check readability-container-size-empty currently modifies source code based on AST nodes in template instantiations, which means that it makes transformations based on substituted types. This can lead to transforming code to be broken. Change the matcher implementation to ignore template instantiations explicitly, and add a matcher to explicitly handle template declarations instead of instantiations. Differential Revision: https://reviews.llvm.org/D91302
2020-10-28 07:24:20 +08:00
hasParent(cxxConstructorDecl(
hasAnyConstructorInitializer(cxxCtorInitializer(
withInitializer(expr(equalsBoundNode(ExprName))),
forField(hasType(booleanType())))))),
hasParent(stmt(anyOf(
explicitCastExpr(hasDestinationType(booleanType())),
[clang-tidy] Use new mapping matchers Use mapAnyOf() and matchers based on it. Use of binaryOperation() means that modernize-loop-convert and readability-container-size-empty can now be used with rewritten binary operators. Differential Revision: https://reviews.llvm.org/D94131
2021-01-03 05:18:29 +08:00
mapAnyOf(ifStmt, doStmt, whileStmt, forStmt,
conditionalOperator)
.with(hasCondition(expr(equalsBoundNode(ExprName)))),
[clang-tidy] Handle template instantiations in container size check readability-container-size-empty currently modifies source code based on AST nodes in template instantiations, which means that it makes transformations based on substituted types. This can lead to transforming code to be broken. Change the matcher implementation to ignore template instantiations explicitly, and add a matcher to explicitly handle template declarations instead of instantiations. Differential Revision: https://reviews.llvm.org/D91302
2020-10-28 07:24:20 +08:00
parenListExpr(hasParent(varDecl(hasType(booleanType())))),
parenExpr(hasParent(
explicitCastExpr(hasDestinationType(booleanType())))),
returnStmt(forFunction(returns(booleanType()))),
cxxUnresolvedConstructExpr(hasType(booleanType())),
[clang-tidy] Use new mapping matchers Use mapAnyOf() and matchers based on it. Use of binaryOperation() means that modernize-loop-convert and readability-container-size-empty can now be used with rewritten binary operators. Differential Revision: https://reviews.llvm.org/D94131
2021-01-03 05:18:29 +08:00
invocation(hasAnyArgumentWithParam(
[clang-tidy] Handle template instantiations in container size check readability-container-size-empty currently modifies source code based on AST nodes in template instantiations, which means that it makes transformations based on substituted types. This can lead to transforming code to be broken. Change the matcher implementation to ignore template instantiations explicitly, and add a matcher to explicitly handle template declarations instead of instantiations. Differential Revision: https://reviews.llvm.org/D91302
2020-10-28 07:24:20 +08:00
expr(equalsBoundNode(ExprName)),
parmVarDecl(hasType(booleanType())))),
binaryOperator(hasAnyOperatorName("&&", "||")),
unaryOperator(hasOperatorName("!")).bind("NegOnSize"))))))
.matches(Node, Finder, Builder);
Builder->removeBindings([ExprName](const BoundNodesMap &Nodes) {
return Nodes.getNode(ExprName).getNodeKind().isNone();
});
return Result;
}
[clang-tidy] Simplify implementation of container-size-empty Use IgnoreUnlessSpelledInSource to make the matcher code smaller and more visibly-related to the code. Differential Revision: https://reviews.llvm.org/D91303
2020-12-23 01:45:22 +08:00
AST_MATCHER(CXXConstructExpr, isDefaultConstruction) {
return Node.getConstructor()->isDefaultConstructor();
}
[clang-tidy] Handle template instantiations in container size check readability-container-size-empty currently modifies source code based on AST nodes in template instantiations, which means that it makes transformations based on substituted types. This can lead to transforming code to be broken. Change the matcher implementation to ignore template instantiations explicitly, and add a matcher to explicitly handle template declarations instead of instantiations. Differential Revision: https://reviews.llvm.org/D91302
2020-10-28 07:24:20 +08:00
} // namespace ast_matchers
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
namespace tidy {
namespace readability {
[clang-tidy] Fix lint warnings in clang-tidy source code (NFC) Run clang-tidy on all source files under `clang-tools-extra/clang-tidy` with `-header-filter=clang-tidy.*` and make suggested corrections. Differential Revision: https://reviews.llvm.org/D112864
2021-11-02 15:14:25 +08:00
using utils::isBinaryOrTernary;
Extend readability-container-size-empty to add comparisons to empty-state objects. Patch by Josh Zimmerman. llvm-svn: 301185
2017-04-24 22:57:09 +08:00
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
ContainerSizeEmptyCheck::ContainerSizeEmptyCheck(StringRef Name,
ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {}
void ContainerSizeEmptyCheck::registerMatchers(MatchFinder *Finder) {
[clang-tidy] Handle template instantiations in container size check readability-container-size-empty currently modifies source code based on AST nodes in template instantiations, which means that it makes transformations based on substituted types. This can lead to transforming code to be broken. Change the matcher implementation to ignore template instantiations explicitly, and add a matcher to explicitly handle template declarations instead of instantiations. Differential Revision: https://reviews.llvm.org/D91302
2020-10-28 07:24:20 +08:00
const auto ValidContainerRecord = cxxRecordDecl(isSameOrDerivedFrom(
namedDecl(
has(cxxMethodDecl(isConst(), parameterCountIs(0), isPublic(),
hasName("size"),
returns(qualType(isInteger(), unless(booleanType()),
unless(elaboratedType()))))
.bind("size")),
has(cxxMethodDecl(isConst(), parameterCountIs(0), isPublic(),
hasName("empty"), returns(booleanType()))
.bind("empty")))
.bind("container")));
const auto ValidContainerNonTemplateType =
qualType(hasUnqualifiedDesugaredType(
recordType(hasDeclaration(ValidContainerRecord))));
const auto ValidContainerTemplateType =
qualType(hasUnqualifiedDesugaredType(templateSpecializationType(
hasDeclaration(classTemplateDecl(has(ValidContainerRecord))))));
const auto ValidContainer = qualType(
anyOf(ValidContainerNonTemplateType, ValidContainerTemplateType));
[clang-tidy] Cleanup some ast-matchers and lift some to utils. Summary: Little cleanup to lift-out and to remove some frequently used ast-matchers. Some of theses matchers are candidates to be lifted to ASTMatchers.h. Reviewers: alexfh Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D19200 llvm-svn: 267003
2016-04-22 00:57:56 +08:00
[clang-tidy] Simplify implementation of container-size-empty Use IgnoreUnlessSpelledInSource to make the matcher code smaller and more visibly-related to the code. Differential Revision: https://reviews.llvm.org/D91303
2020-12-23 01:45:22 +08:00
const auto WrongUse =
anyOf(hasParent(binaryOperator(
isComparisonOperator(),
hasEitherOperand(anyOf(integerLiteral(equals(1)),
integerLiteral(equals(0)))))
.bind("SizeBinaryOp")),
usedInBooleanContext());
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
Finder->addMatcher(
[clang-tidy] Simplify implementation of container-size-empty Use IgnoreUnlessSpelledInSource to make the matcher code smaller and more visibly-related to the code. Differential Revision: https://reviews.llvm.org/D91303
2020-12-23 01:45:22 +08:00
cxxMemberCallExpr(on(expr(anyOf(hasType(ValidContainer),
[clang-tidy] Fix naming in container-size-empty. llvm-svn: 281313
2016-09-13 18:19:13 +08:00
hasType(pointsTo(ValidContainer)),
[clang-tidy] Handle template instantiations in container size check readability-container-size-empty currently modifies source code based on AST nodes in template instantiations, which means that it makes transformations based on substituted types. This can lead to transforming code to be broken. Change the matcher implementation to ignore template instantiations explicitly, and add a matcher to explicitly handle template declarations instead of instantiations. Differential Revision: https://reviews.llvm.org/D91302
2020-10-28 07:24:20 +08:00
hasType(references(ValidContainer))))
.bind("MemberCallObject")),
[clang-tidy] Ignore `size() == 0` in the container implementation. llvm-svn: 290289
2016-12-22 07:44:23 +08:00
callee(cxxMethodDecl(hasName("size"))), WrongUse,
unless(hasAncestor(cxxMethodDecl(
ofClass(equalsBoundNode("container"))))))
Refactors AST matching code to use the new AST matcher names. This patch correlates to r247885 which performs the AST matcher rename in Clang. llvm-svn: 247886
2015-09-17 21:31:25 +08:00
.bind("SizeCallExpr"),
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
this);
Extend readability-container-size-empty to add comparisons to empty-state objects. Patch by Josh Zimmerman. llvm-svn: 301185
2017-04-24 22:57:09 +08:00
[clang-tidy] Handle template instantiations in container size check readability-container-size-empty currently modifies source code based on AST nodes in template instantiations, which means that it makes transformations based on substituted types. This can lead to transforming code to be broken. Change the matcher implementation to ignore template instantiations explicitly, and add a matcher to explicitly handle template declarations instead of instantiations. Differential Revision: https://reviews.llvm.org/D91302
2020-10-28 07:24:20 +08:00
Finder->addMatcher(
callExpr(has(cxxDependentScopeMemberExpr(
hasObjectExpression(
expr(anyOf(hasType(ValidContainer),
hasType(pointsTo(ValidContainer)),
hasType(references(ValidContainer))))
.bind("MemberCallObject")),
hasMemberName("size"))),
WrongUse,
unless(hasAncestor(
cxxMethodDecl(ofClass(equalsBoundNode("container"))))))
.bind("SizeCallExpr"),
this);
Extend readability-container-size-empty to add comparisons to empty-state objects. Patch by Josh Zimmerman. llvm-svn: 301185
2017-04-24 22:57:09 +08:00
// Comparison to empty string or empty constructor.
const auto WrongComparend = anyOf(
[clang-tidy] Simplify implementation of container-size-empty Use IgnoreUnlessSpelledInSource to make the matcher code smaller and more visibly-related to the code. Differential Revision: https://reviews.llvm.org/D91303
2020-12-23 01:45:22 +08:00
stringLiteral(hasSize(0)), cxxConstructExpr(isDefaultConstruction()),
[clang-tidy] Handle template instantiations in container size check readability-container-size-empty currently modifies source code based on AST nodes in template instantiations, which means that it makes transformations based on substituted types. This can lead to transforming code to be broken. Change the matcher implementation to ignore template instantiations explicitly, and add a matcher to explicitly handle template declarations instead of instantiations. Differential Revision: https://reviews.llvm.org/D91302
2020-10-28 07:24:20 +08:00
cxxUnresolvedConstructExpr(argumentCountIs(0)));
Extend readability-container-size-empty to add comparisons to empty-state objects. Patch by Josh Zimmerman. llvm-svn: 301185
2017-04-24 22:57:09 +08:00
// Match the object being compared.
const auto STLArg =
anyOf(unaryOperator(
hasOperatorName("*"),
hasUnaryOperand(
expr(hasType(pointsTo(ValidContainer))).bind("Pointee"))),
expr(hasType(ValidContainer)).bind("STLObject"));
Finder->addMatcher(
[clang-tidy] Simplify implementation of container-size-empty Use IgnoreUnlessSpelledInSource to make the matcher code smaller and more visibly-related to the code. Differential Revision: https://reviews.llvm.org/D91303
2020-12-23 01:45:22 +08:00
binaryOperation(hasAnyOperatorName("==", "!="),
hasOperands(WrongComparend,
STLArg),
unless(hasAncestor(cxxMethodDecl(
ofClass(equalsBoundNode("container"))))))
[clang-tidy] Handle template instantiations in container size check readability-container-size-empty currently modifies source code based on AST nodes in template instantiations, which means that it makes transformations based on substituted types. This can lead to transforming code to be broken. Change the matcher implementation to ignore template instantiations explicitly, and add a matcher to explicitly handle template declarations instead of instantiations. Differential Revision: https://reviews.llvm.org/D91302
2020-10-28 07:24:20 +08:00
.bind("BinCmp"),
this);
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
}
void ContainerSizeEmptyCheck::check(const MatchFinder::MatchResult &Result) {
[clang-tidy] Handle template instantiations in container size check readability-container-size-empty currently modifies source code based on AST nodes in template instantiations, which means that it makes transformations based on substituted types. This can lead to transforming code to be broken. Change the matcher implementation to ignore template instantiations explicitly, and add a matcher to explicitly handle template declarations instead of instantiations. Differential Revision: https://reviews.llvm.org/D91302
2020-10-28 07:24:20 +08:00
const auto *MemberCall = Result.Nodes.getNodeAs<Expr>("SizeCallExpr");
const auto *MemberCallObject =
Result.Nodes.getNodeAs<Expr>("MemberCallObject");
Extend readability-container-size-empty to add comparisons to empty-state objects. Patch by Josh Zimmerman. llvm-svn: 301185
2017-04-24 22:57:09 +08:00
const auto *BinCmp = Result.Nodes.getNodeAs<CXXOperatorCallExpr>("BinCmp");
[clang-tidy] Handle template instantiations in container size check readability-container-size-empty currently modifies source code based on AST nodes in template instantiations, which means that it makes transformations based on substituted types. This can lead to transforming code to be broken. Change the matcher implementation to ignore template instantiations explicitly, and add a matcher to explicitly handle template declarations instead of instantiations. Differential Revision: https://reviews.llvm.org/D91302
2020-10-28 07:24:20 +08:00
const auto *BinCmpTempl = Result.Nodes.getNodeAs<BinaryOperator>("BinCmp");
[clang-tidy] Use new mapping matchers Use mapAnyOf() and matchers based on it. Use of binaryOperation() means that modernize-loop-convert and readability-container-size-empty can now be used with rewritten binary operators. Differential Revision: https://reviews.llvm.org/D94131
2021-01-03 05:18:29 +08:00
const auto *BinCmpRewritten =
Result.Nodes.getNodeAs<CXXRewrittenBinaryOperator>("BinCmp");
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
const auto *BinaryOp = Result.Nodes.getNodeAs<BinaryOperator>("SizeBinaryOp");
Extend readability-container-size-empty to add comparisons to empty-state objects. Patch by Josh Zimmerman. llvm-svn: 301185
2017-04-24 22:57:09 +08:00
const auto *Pointee = Result.Nodes.getNodeAs<Expr>("Pointee");
const auto *E =
[clang-tidy] Handle template instantiations in container size check readability-container-size-empty currently modifies source code based on AST nodes in template instantiations, which means that it makes transformations based on substituted types. This can lead to transforming code to be broken. Change the matcher implementation to ignore template instantiations explicitly, and add a matcher to explicitly handle template declarations instead of instantiations. Differential Revision: https://reviews.llvm.org/D91302
2020-10-28 07:24:20 +08:00
MemberCallObject
? MemberCallObject
Extend readability-container-size-empty to add comparisons to empty-state objects. Patch by Josh Zimmerman. llvm-svn: 301185
2017-04-24 22:57:09 +08:00
: (Pointee ? Pointee : Result.Nodes.getNodeAs<Expr>("STLObject"));
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
FixItHint Hint;
Make llvm::StringRef to std::string conversions explicit. This is how it should've been and brings it more in line with std::string_view. There should be no functional change here. This is mostly mechanical from a custom clang-tidy check, with a lot of manual fixups. It uncovers a lot of minor inefficiencies. This doesn't actually modify StringRef yet, I'll do that in a follow-up.
2020-01-29 03:23:46 +08:00
std::string ReplacementText = std::string(
[clang-tidy] Cleaning up language options. Differential Revision: https://reviews.llvm.org/D24881 llvm-svn: 282319
2016-09-24 10:13:45 +08:00
Lexer::getSourceText(CharSourceRange::getTokenRange(E->getSourceRange()),
Make llvm::StringRef to std::string conversions explicit. This is how it should've been and brings it more in line with std::string_view. There should be no functional change here. This is mostly mechanical from a custom clang-tidy check, with a lot of manual fixups. It uncovers a lot of minor inefficiencies. This doesn't actually modify StringRef yet, I'll do that in a follow-up.
2020-01-29 03:23:46 +08:00
*Result.SourceManager, getLangOpts()));
[clang-tidy] Fix lint warnings in clang-tidy source code (NFC) Run clang-tidy on all source files under `clang-tools-extra/clang-tidy` with `-header-filter=clang-tidy.*` and make suggested corrections. Differential Revision: https://reviews.llvm.org/D112864
2021-11-02 15:14:25 +08:00
if (isBinaryOrTernary(E) || isa<UnaryOperator>(E)) {
Extend readability-container-size-empty to add comparisons to empty-state objects. Patch by Josh Zimmerman. llvm-svn: 301185
2017-04-24 22:57:09 +08:00
ReplacementText = "(" + ReplacementText + ")";
}
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
if (E->getType()->isPointerType())
ReplacementText += "->empty()";
else
ReplacementText += ".empty()";
Extend readability-container-size-empty to add comparisons to empty-state objects. Patch by Josh Zimmerman. llvm-svn: 301185
2017-04-24 22:57:09 +08:00
if (BinCmp) {
if (BinCmp->getOperator() == OO_ExclaimEqual) {
ReplacementText = "!" + ReplacementText;
}
Hint =
FixItHint::CreateReplacement(BinCmp->getSourceRange(), ReplacementText);
[clang-tidy] Handle template instantiations in container size check readability-container-size-empty currently modifies source code based on AST nodes in template instantiations, which means that it makes transformations based on substituted types. This can lead to transforming code to be broken. Change the matcher implementation to ignore template instantiations explicitly, and add a matcher to explicitly handle template declarations instead of instantiations. Differential Revision: https://reviews.llvm.org/D91302
2020-10-28 07:24:20 +08:00
} else if (BinCmpTempl) {
if (BinCmpTempl->getOpcode() == BinaryOperatorKind::BO_NE) {
ReplacementText = "!" + ReplacementText;
}
Hint = FixItHint::CreateReplacement(BinCmpTempl->getSourceRange(),
ReplacementText);
[clang-tidy] Use new mapping matchers Use mapAnyOf() and matchers based on it. Use of binaryOperation() means that modernize-loop-convert and readability-container-size-empty can now be used with rewritten binary operators. Differential Revision: https://reviews.llvm.org/D94131
2021-01-03 05:18:29 +08:00
} else if (BinCmpRewritten) {
if (BinCmpRewritten->getOpcode() == BinaryOperatorKind::BO_NE) {
ReplacementText = "!" + ReplacementText;
}
Hint = FixItHint::CreateReplacement(BinCmpRewritten->getSourceRange(),
ReplacementText);
[clang-tidy] Handle template instantiations in container size check readability-container-size-empty currently modifies source code based on AST nodes in template instantiations, which means that it makes transformations based on substituted types. This can lead to transforming code to be broken. Change the matcher implementation to ignore template instantiations explicitly, and add a matcher to explicitly handle template declarations instead of instantiations. Differential Revision: https://reviews.llvm.org/D91302
2020-10-28 07:24:20 +08:00
} else if (BinaryOp) { // Determine the correct transformation.
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
bool Negation = false;
[clang-tidy] Fix PR25812. llvm-svn: 255431
2015-12-12 19:31:25 +08:00
const bool ContainerIsLHS =
!llvm::isa<IntegerLiteral>(BinaryOp->getLHS()->IgnoreImpCasts());
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
const auto OpCode = BinaryOp->getOpcode();
uint64_t Value = 0;
if (ContainerIsLHS) {
[clang-tidy] Fix PR25812. llvm-svn: 255431
2015-12-12 19:31:25 +08:00
if (const auto *Literal = llvm::dyn_cast<IntegerLiteral>(
BinaryOp->getRHS()->IgnoreImpCasts()))
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
Value = Literal->getValue().getLimitedValue();
else
return;
} else {
[clang-tidy] Fix PR25812. llvm-svn: 255431
2015-12-12 19:31:25 +08:00
Value =
llvm::dyn_cast<IntegerLiteral>(BinaryOp->getLHS()->IgnoreImpCasts())
->getValue()
.getLimitedValue();
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
}
// Constant that is not handled.
if (Value > 1)
return;
[clang-tidy] readability-container-size-empty fixes Summary: This patch fixes PR27410 and adds std::basic_string support. Reviewers: Eugene.Zelenko, hokein Subscribers: cfe-commits, o.gyorgy Differential Revision: http://reviews.llvm.org/D19262 llvm-svn: 266734
2016-04-19 21:29:05 +08:00
if (Value == 1 && (OpCode == BinaryOperatorKind::BO_EQ ||
OpCode == BinaryOperatorKind::BO_NE))
return;
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
// Always true, no warnings for that.
if ((OpCode == BinaryOperatorKind::BO_GE && Value == 0 && ContainerIsLHS) ||
(OpCode == BinaryOperatorKind::BO_LE && Value == 0 && !ContainerIsLHS))
return;
[clang-tidy] Fix a false positive case in ContainerSizeEmpty check. llvm-svn: 256504
2015-12-29 01:20:33 +08:00
// Do not warn for size > 1, 1 < size, size <= 1, 1 >= size.
if (Value == 1) {
if ((OpCode == BinaryOperatorKind::BO_GT && ContainerIsLHS) ||
(OpCode == BinaryOperatorKind::BO_LT && !ContainerIsLHS))
return;
if ((OpCode == BinaryOperatorKind::BO_LE && ContainerIsLHS) ||
(OpCode == BinaryOperatorKind::BO_GE && !ContainerIsLHS))
return;
}
Fix a false positive case in ContainerSizeEmpty check (PR25893). llvm-svn: 256142
2015-12-21 17:43:52 +08:00
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
if (OpCode == BinaryOperatorKind::BO_NE && Value == 0)
Negation = true;
if ((OpCode == BinaryOperatorKind::BO_GT ||
OpCode == BinaryOperatorKind::BO_GE) &&
ContainerIsLHS)
Negation = true;
if ((OpCode == BinaryOperatorKind::BO_LT ||
OpCode == BinaryOperatorKind::BO_LE) &&
!ContainerIsLHS)
Negation = true;
if (Negation)
ReplacementText = "!" + ReplacementText;
Hint = FixItHint::CreateReplacement(BinaryOp->getSourceRange(),
ReplacementText);
} else {
// If there is a conversion above the size call to bool, it is safe to just
// replace size with empty.
if (const auto *UnaryOp =
Result.Nodes.getNodeAs<UnaryOperator>("NegOnSize"))
Hint = FixItHint::CreateReplacement(UnaryOp->getSourceRange(),
ReplacementText);
else
Hint = FixItHint::CreateReplacement(MemberCall->getSourceRange(),
"!" + ReplacementText);
}
[clang-tidy] Extend readability-container-size-empty to arbitrary class with size() and empty() This patch extends readability-container-size-empty check allowing it to produce warnings not only for STL containers, but also for containers, which provide two functions matching following signatures: * `size_type size() const;` * `bool empty() const;` Where `size_type` can be any kind of integer type. This functionality was proposed in https://llvm.org/bugs/show_bug.cgi?id=26823 by Eugene Zelenko. Approval: alexfh Reviewers: alexfh, aaron.ballman, Eugene.Zelenko Subscribers: etienneb, Prazek, hokein, xazax.hun, cfe-commits Differential Revision: https://reviews.llvm.org/D24349 llvm-svn: 281307
2016-09-13 16:58:11 +08:00
[clang-tidy] Handle template instantiations in container size check readability-container-size-empty currently modifies source code based on AST nodes in template instantiations, which means that it makes transformations based on substituted types. This can lead to transforming code to be broken. Change the matcher implementation to ignore template instantiations explicitly, and add a matcher to explicitly handle template declarations instead of instantiations. Differential Revision: https://reviews.llvm.org/D91302
2020-10-28 07:24:20 +08:00
auto WarnLoc = MemberCall ? MemberCall->getBeginLoc() : SourceLocation{};
if (WarnLoc.isValid()) {
diag(WarnLoc, "the 'empty' method should be used to check "
"for emptiness instead of 'size'")
Extend readability-container-size-empty to add comparisons to empty-state objects. Patch by Josh Zimmerman. llvm-svn: 301185
2017-04-24 22:57:09 +08:00
<< Hint;
} else {
[clang-tidy] Use new mapping matchers Use mapAnyOf() and matchers based on it. Use of binaryOperation() means that modernize-loop-convert and readability-container-size-empty can now be used with rewritten binary operators. Differential Revision: https://reviews.llvm.org/D94131
2021-01-03 05:18:29 +08:00
WarnLoc = BinCmpTempl
? BinCmpTempl->getBeginLoc()
: (BinCmp ? BinCmp->getBeginLoc()
: (BinCmpRewritten ? BinCmpRewritten->getBeginLoc()
: SourceLocation{}));
[clang-tidy] Handle template instantiations in container size check readability-container-size-empty currently modifies source code based on AST nodes in template instantiations, which means that it makes transformations based on substituted types. This can lead to transforming code to be broken. Change the matcher implementation to ignore template instantiations explicitly, and add a matcher to explicitly handle template declarations instead of instantiations. Differential Revision: https://reviews.llvm.org/D91302
2020-10-28 07:24:20 +08:00
diag(WarnLoc, "the 'empty' method should be used to check "
"for emptiness instead of comparing to an empty object")
Extend readability-container-size-empty to add comparisons to empty-state objects. Patch by Josh Zimmerman. llvm-svn: 301185
2017-04-24 22:57:09 +08:00
<< Hint;
}
[clang-tidy] Extend readability-container-size-empty to arbitrary class with size() and empty() This patch extends readability-container-size-empty check allowing it to produce warnings not only for STL containers, but also for containers, which provide two functions matching following signatures: * `size_type size() const;` * `bool empty() const;` Where `size_type` can be any kind of integer type. This functionality was proposed in https://llvm.org/bugs/show_bug.cgi?id=26823 by Eugene Zelenko. Approval: alexfh Reviewers: alexfh, aaron.ballman, Eugene.Zelenko Subscribers: etienneb, Prazek, hokein, xazax.hun, cfe-commits Differential Revision: https://reviews.llvm.org/D24349 llvm-svn: 281307
2016-09-13 16:58:11 +08:00
const auto *Container = Result.Nodes.getNodeAs<NamedDecl>("container");
[clang-tidy] Avoid inconsistent notes in readability-container-size-empty When a warning is issued in a template instantiation, the check would previously use template arguments in a note, which would result in inconsistent or duplicate warnings (depending on how deduplication was done). This patch removes template arguments from the note. llvm-svn: 347652
2018-11-27 18:53:44 +08:00
if (const auto *CTS = dyn_cast<ClassTemplateSpecializationDecl>(Container)) {
// The definition of the empty() method is the same for all implicit
// instantiations. In order to avoid duplicate or inconsistent warnings
// (depending on how deduplication is done), we use the same class name
// for all implicit instantiations of a template.
if (CTS->getSpecializationKind() == TSK_ImplicitInstantiation)
Container = CTS->getSpecializedTemplate();
}
[clang-tidy] Extend readability-container-size-empty to arbitrary class with size() and empty() This patch extends readability-container-size-empty check allowing it to produce warnings not only for STL containers, but also for containers, which provide two functions matching following signatures: * `size_type size() const;` * `bool empty() const;` Where `size_type` can be any kind of integer type. This functionality was proposed in https://llvm.org/bugs/show_bug.cgi?id=26823 by Eugene Zelenko. Approval: alexfh Reviewers: alexfh, aaron.ballman, Eugene.Zelenko Subscribers: etienneb, Prazek, hokein, xazax.hun, cfe-commits Differential Revision: https://reviews.llvm.org/D24349 llvm-svn: 281307
2016-09-13 16:58:11 +08:00
const auto *Empty = Result.Nodes.getNodeAs<FunctionDecl>("empty");
diag(Empty->getLocation(), "method %0::empty() defined here",
DiagnosticIDs::Note)
<< Container;
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
}
} // namespace readability
} // namespace tidy
} // namespace clang