clang-tools 17.0.0git
UseNodiscardCheck.cpp
Go to the documentation of this file.
1//===--- UseNodiscardCheck.cpp - clang-tidy -------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "UseNodiscardCheck.h"
10#include "clang/AST/ASTContext.h"
11#include "clang/AST/Decl.h"
12#include "clang/AST/Type.h"
13#include "clang/ASTMatchers/ASTMatchFinder.h"
14
15using namespace clang::ast_matchers;
16
17namespace clang::tidy::modernize {
18
19static bool doesNoDiscardMacroExist(ASTContext &Context,
20 const llvm::StringRef &MacroId) {
21 // Don't check for the Macro existence if we are using an attribute
22 // either a C++17 standard attribute or pre C++17 syntax
23 if (MacroId.startswith("[[") || MacroId.startswith("__attribute__"))
24 return true;
25
26 // Otherwise look up the macro name in the context to see if its defined.
27 return Context.Idents.get(MacroId).hasMacroDefinition();
28}
29
30namespace {
31AST_MATCHER(CXXMethodDecl, isOverloadedOperator) {
32 // Don't put ``[[nodiscard]]`` in front of operators.
33 return Node.isOverloadedOperator();
34}
35AST_MATCHER(CXXMethodDecl, isConversionOperator) {
36 // Don't put ``[[nodiscard]]`` in front of a conversion decl
37 // like operator bool().
38 return isa<CXXConversionDecl>(Node);
39}
40AST_MATCHER(CXXMethodDecl, hasClassMutableFields) {
41 // Don't put ``[[nodiscard]]`` on functions on classes with
42 // mutable member variables.
43 return Node.getParent()->hasMutableFields();
44}
45AST_MATCHER(ParmVarDecl, hasParameterPack) {
46 // Don't put ``[[nodiscard]]`` on functions with parameter pack arguments.
47 return Node.isParameterPack();
48}
49AST_MATCHER(CXXMethodDecl, hasTemplateReturnType) {
50 // Don't put ``[[nodiscard]]`` in front of functions returning a template
51 // type.
52 return Node.getReturnType()->isTemplateTypeParmType() ||
53 Node.getReturnType()->isInstantiationDependentType();
54}
55AST_MATCHER(CXXMethodDecl, isDefinitionOrInline) {
56 // A function definition, with optional inline but not the declaration.
57 return !(Node.isThisDeclarationADefinition() && Node.isOutOfLine());
58}
59AST_MATCHER(QualType, isInstantiationDependentType) {
60 return Node->isInstantiationDependentType();
61}
62AST_MATCHER(QualType, isNonConstReferenceOrPointer) {
63 // If the function has any non-const-reference arguments
64 // bool foo(A &a)
65 // or pointer arguments
66 // bool foo(A*)
67 // then they may not care about the return value because of passing data
68 // via the arguments.
69 return (Node->isTemplateTypeParmType() || Node->isPointerType() ||
70 (Node->isReferenceType() &&
71 !Node.getNonReferenceType().isConstQualified()) ||
72 Node->isInstantiationDependentType());
73}
74} // namespace
75
77 : ClangTidyCheck(Name, Context),
78 NoDiscardMacro(Options.get("ReplacementString", "[[nodiscard]]")) {}
79
81 Options.store(Opts, "ReplacementString", NoDiscardMacro);
82}
83
84void UseNodiscardCheck::registerMatchers(MatchFinder *Finder) {
85 auto FunctionObj =
86 cxxRecordDecl(hasAnyName("::std::function", "::boost::function"));
87
88 // Find all non-void const methods which have not already been marked to
89 // warn on unused result.
90 Finder->addMatcher(
91 cxxMethodDecl(
92 allOf(isConst(), isDefinitionOrInline(),
93 unless(anyOf(
94 returns(voidType()),
95 returns(hasDeclaration(decl(hasAttr(clang::attr::WarnUnusedResult)))),
96 isNoReturn(), isOverloadedOperator(),
97 isVariadic(), hasTemplateReturnType(),
98 hasClassMutableFields(), isConversionOperator(),
99 hasAttr(clang::attr::WarnUnusedResult),
100 hasType(isInstantiationDependentType()),
101 hasAnyParameter(anyOf(
102 parmVarDecl(anyOf(hasType(FunctionObj),
103 hasType(references(FunctionObj)))),
104 hasType(isNonConstReferenceOrPointer()),
105 hasParameterPack()))))))
106 .bind("no_discard"),
107 this);
108}
109
110void UseNodiscardCheck::check(const MatchFinder::MatchResult &Result) {
111 const auto *MatchedDecl = Result.Nodes.getNodeAs<CXXMethodDecl>("no_discard");
112 // Don't make replacements if the location is invalid or in a macro.
113 SourceLocation Loc = MatchedDecl->getLocation();
114 if (Loc.isInvalid() || Loc.isMacroID())
115 return;
116
117 SourceLocation RetLoc = MatchedDecl->getInnerLocStart();
118
119 ASTContext &Context = *Result.Context;
120
121 auto Diag = diag(RetLoc, "function %0 should be marked %1")
122 << MatchedDecl << NoDiscardMacro;
123
124 // Check for the existence of the keyword being used as the ``[[nodiscard]]``.
125 if (!doesNoDiscardMacroExist(Context, NoDiscardMacro))
126 return;
127
128 // Possible false positives include:
129 // 1. A const member function which returns a variable which is ignored
130 // but performs some external I/O operation and the return value could be
131 // ignored.
132 Diag << FixItHint::CreateInsertion(RetLoc, (NoDiscardMacro + " ").str());
133}
134
136 const LangOptions &LangOpts) const {
137 // If we use ``[[nodiscard]]`` attribute, we require at least C++17. Use a
138 // macro or ``__attribute__`` with pre c++17 compilers by using
139 // ReplacementString option.
140
141 if (NoDiscardMacro == "[[nodiscard]]")
142 return LangOpts.CPlusPlus17;
143
144 return LangOpts.CPlusPlus;
145}
146
147} // namespace clang::tidy::modernize
SourceLocation Loc
Token Name
void store(ClangTidyOptions::OptionMap &Options, StringRef LocalName, StringRef Value) const
Stores an option with the check-local name LocalName with string value Value to Options.
Base class for all clang-tidy checks.
DiagnosticBuilder diag(SourceLocation Loc, StringRef Description, DiagnosticIDs::Level Level=DiagnosticIDs::Warning)
Add a diagnostic with the check's name.
Every ClangTidyCheck reports errors through a DiagnosticsEngine provided by this context.
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override
Override this to disable registering matchers and PP callbacks if an invalid language version is bein...
void storeOptions(ClangTidyOptions::OptionMap &Opts) override
Should store all options supported by this check with their current values or default values for opti...
void check(const ast_matchers::MatchFinder::MatchResult &Result) override
ClangTidyChecks that register ASTMatchers should do the actual work in here.
void registerMatchers(ast_matchers::MatchFinder *Finder) override
Override this to register AST matchers with Finder.
UseNodiscardCheck(StringRef Name, ClangTidyContext *Context)
AST_MATCHER(Decl, declHasNoReturnAttr)
matches a Decl if it has a "no return" attribute of any kind
static bool doesNoDiscardMacroExist(ASTContext &Context, const llvm::StringRef &MacroId)
llvm::StringMap< ClangTidyValue > OptionMap