1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
|
//===--- AvoidUnconditionalPreprocessorIfCheck.cpp - clang-tidy -----------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "AvoidUnconditionalPreprocessorIfCheck.h"
#include "clang/AST/ASTContext.h"
#include "clang/Lex/PPCallbacks.h"
#include "clang/Lex/Preprocessor.h"
using namespace clang::ast_matchers;
namespace clang::tidy::readability {
namespace {
struct AvoidUnconditionalPreprocessorIfPPCallbacks : public PPCallbacks {
explicit AvoidUnconditionalPreprocessorIfPPCallbacks(ClangTidyCheck &Check,
Preprocessor &PP)
: Check(Check), PP(PP) {}
void If(SourceLocation Loc, SourceRange ConditionRange,
ConditionValueKind ConditionValue) override {
if (ConditionValue == CVK_NotEvaluated)
return;
SourceManager &SM = PP.getSourceManager();
if (!isImmutable(SM, PP.getLangOpts(), ConditionRange))
return;
if (ConditionValue == CVK_True)
Check.diag(Loc, "preprocessor condition is always 'true', consider "
"removing condition but leaving its contents");
else
Check.diag(Loc, "preprocessor condition is always 'false', consider "
"removing both the condition and its contents");
}
bool isImmutable(SourceManager &SM, const LangOptions &LangOpts,
SourceRange ConditionRange) {
SourceLocation Loc = ConditionRange.getBegin();
if (Loc.isMacroID())
return false;
Token Tok;
if (Lexer::getRawToken(Loc, Tok, SM, LangOpts, true)) {
std::optional<Token> TokOpt = Lexer::findNextToken(Loc, SM, LangOpts);
if (!TokOpt || TokOpt->getLocation().isMacroID())
return false;
Tok = *TokOpt;
}
while (Tok.getLocation() <= ConditionRange.getEnd()) {
if (!isImmutableToken(Tok))
return false;
std::optional<Token> TokOpt =
Lexer::findNextToken(Tok.getLocation(), SM, LangOpts);
if (!TokOpt || TokOpt->getLocation().isMacroID())
return false;
Tok = *TokOpt;
}
return true;
}
bool isImmutableToken(const Token &Tok) {
switch (Tok.getKind()) {
case tok::eod:
case tok::eof:
case tok::numeric_constant:
case tok::char_constant:
case tok::wide_char_constant:
case tok::utf8_char_constant:
case tok::utf16_char_constant:
case tok::utf32_char_constant:
case tok::string_literal:
case tok::wide_string_literal:
case tok::comment:
return true;
case tok::raw_identifier:
return (Tok.getRawIdentifier() == "true" ||
Tok.getRawIdentifier() == "false");
default:
return Tok.getKind() >= tok::l_square &&
Tok.getKind() <= tok::greatergreatergreater;
}
}
ClangTidyCheck &Check;
Preprocessor &PP;
};
} // namespace
void AvoidUnconditionalPreprocessorIfCheck::registerPPCallbacks(
const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) {
PP->addPPCallbacks(
std::make_unique<AvoidUnconditionalPreprocessorIfPPCallbacks>(*this,
*PP));
}
} // namespace clang::tidy::readability
|
