|
236
|
1 //===--- IdentifierLengthCheck.cpp - clang-tidy
|
|
|
2 //-----------------------------===//
|
|
|
3 //
|
|
|
4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
|
5 // See https://llvm.org/LICENSE.txt for license information.
|
|
|
6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
|
7 //
|
|
|
8 //===----------------------------------------------------------------------===//
|
|
|
9
|
|
|
10 #include "IdentifierLengthCheck.h"
|
|
|
11 #include "../utils/OptionsUtils.h"
|
|
|
12 #include "clang/AST/ASTContext.h"
|
|
|
13 #include "clang/ASTMatchers/ASTMatchFinder.h"
|
|
|
14
|
|
|
15 using namespace clang::ast_matchers;
|
|
|
16
|
|
252
|
17 namespace clang::tidy::readability {
|
|
236
|
18
|
|
|
19 const unsigned DefaultMinimumVariableNameLength = 3;
|
|
|
20 const unsigned DefaultMinimumLoopCounterNameLength = 2;
|
|
|
21 const unsigned DefaultMinimumExceptionNameLength = 2;
|
|
|
22 const unsigned DefaultMinimumParameterNameLength = 3;
|
|
|
23 const char DefaultIgnoredLoopCounterNames[] = "^[ijk_]$";
|
|
|
24 const char DefaultIgnoredVariableNames[] = "";
|
|
|
25 const char DefaultIgnoredExceptionVariableNames[] = "^[e]$";
|
|
|
26 const char DefaultIgnoredParameterNames[] = "^[n]$";
|
|
|
27
|
|
|
28 const char ErrorMessage[] =
|
|
|
29 "%select{variable|exception variable|loop variable|"
|
|
|
30 "parameter}0 name %1 is too short, expected at least %2 characters";
|
|
|
31
|
|
|
32 IdentifierLengthCheck::IdentifierLengthCheck(StringRef Name,
|
|
|
33 ClangTidyContext *Context)
|
|
|
34 : ClangTidyCheck(Name, Context),
|
|
|
35 MinimumVariableNameLength(Options.get("MinimumVariableNameLength",
|
|
|
36 DefaultMinimumVariableNameLength)),
|
|
|
37 MinimumLoopCounterNameLength(Options.get(
|
|
|
38 "MinimumLoopCounterNameLength", DefaultMinimumLoopCounterNameLength)),
|
|
|
39 MinimumExceptionNameLength(Options.get(
|
|
|
40 "MinimumExceptionNameLength", DefaultMinimumExceptionNameLength)),
|
|
|
41 MinimumParameterNameLength(Options.get(
|
|
|
42 "MinimumParameterNameLength", DefaultMinimumParameterNameLength)),
|
|
|
43 IgnoredVariableNamesInput(
|
|
|
44 Options.get("IgnoredVariableNames", DefaultIgnoredVariableNames)),
|
|
|
45 IgnoredVariableNames(IgnoredVariableNamesInput),
|
|
|
46 IgnoredLoopCounterNamesInput(Options.get("IgnoredLoopCounterNames",
|
|
|
47 DefaultIgnoredLoopCounterNames)),
|
|
|
48 IgnoredLoopCounterNames(IgnoredLoopCounterNamesInput),
|
|
|
49 IgnoredExceptionVariableNamesInput(
|
|
|
50 Options.get("IgnoredExceptionVariableNames",
|
|
|
51 DefaultIgnoredExceptionVariableNames)),
|
|
|
52 IgnoredExceptionVariableNames(IgnoredExceptionVariableNamesInput),
|
|
|
53 IgnoredParameterNamesInput(
|
|
|
54 Options.get("IgnoredParameterNames", DefaultIgnoredParameterNames)),
|
|
|
55 IgnoredParameterNames(IgnoredParameterNamesInput) {}
|
|
|
56
|
|
|
57 void IdentifierLengthCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
|
|
|
58 Options.store(Opts, "MinimumVariableNameLength", MinimumVariableNameLength);
|
|
|
59 Options.store(Opts, "MinimumLoopCounterNameLength",
|
|
|
60 MinimumLoopCounterNameLength);
|
|
|
61 Options.store(Opts, "MinimumExceptionNameLength", MinimumExceptionNameLength);
|
|
|
62 Options.store(Opts, "MinimumParameterNameLength", MinimumParameterNameLength);
|
|
|
63 Options.store(Opts, "IgnoredLoopCounterNames", IgnoredLoopCounterNamesInput);
|
|
|
64 Options.store(Opts, "IgnoredVariableNames", IgnoredVariableNamesInput);
|
|
|
65 Options.store(Opts, "IgnoredExceptionVariableNames",
|
|
|
66 IgnoredExceptionVariableNamesInput);
|
|
|
67 Options.store(Opts, "IgnoredParameterNames", IgnoredParameterNamesInput);
|
|
|
68 }
|
|
|
69
|
|
|
70 void IdentifierLengthCheck::registerMatchers(MatchFinder *Finder) {
|
|
|
71 if (MinimumLoopCounterNameLength > 1)
|
|
|
72 Finder->addMatcher(
|
|
|
73 forStmt(hasLoopInit(declStmt(forEach(varDecl().bind("loopVar"))))),
|
|
|
74 this);
|
|
|
75
|
|
|
76 if (MinimumExceptionNameLength > 1)
|
|
|
77 Finder->addMatcher(varDecl(hasParent(cxxCatchStmt())).bind("exceptionVar"),
|
|
|
78 this);
|
|
|
79
|
|
|
80 if (MinimumParameterNameLength > 1)
|
|
|
81 Finder->addMatcher(parmVarDecl().bind("paramVar"), this);
|
|
|
82
|
|
|
83 if (MinimumVariableNameLength > 1)
|
|
|
84 Finder->addMatcher(
|
|
|
85 varDecl(unless(anyOf(hasParent(declStmt(hasParent(forStmt()))),
|
|
|
86 hasParent(cxxCatchStmt()), parmVarDecl())))
|
|
|
87 .bind("standaloneVar"),
|
|
|
88 this);
|
|
|
89 }
|
|
|
90
|
|
|
91 void IdentifierLengthCheck::check(const MatchFinder::MatchResult &Result) {
|
|
|
92 const auto *StandaloneVar = Result.Nodes.getNodeAs<VarDecl>("standaloneVar");
|
|
|
93 if (StandaloneVar) {
|
|
|
94 if (!StandaloneVar->getIdentifier())
|
|
|
95 return;
|
|
|
96
|
|
|
97 StringRef VarName = StandaloneVar->getName();
|
|
|
98
|
|
|
99 if (VarName.size() >= MinimumVariableNameLength ||
|
|
|
100 IgnoredVariableNames.match(VarName))
|
|
|
101 return;
|
|
|
102
|
|
|
103 diag(StandaloneVar->getLocation(), ErrorMessage)
|
|
|
104 << 0 << StandaloneVar << MinimumVariableNameLength;
|
|
|
105 }
|
|
|
106
|
|
|
107 auto *ExceptionVarName = Result.Nodes.getNodeAs<VarDecl>("exceptionVar");
|
|
|
108 if (ExceptionVarName) {
|
|
|
109 if (!ExceptionVarName->getIdentifier())
|
|
|
110 return;
|
|
|
111
|
|
|
112 StringRef VarName = ExceptionVarName->getName();
|
|
|
113 if (VarName.size() >= MinimumExceptionNameLength ||
|
|
|
114 IgnoredExceptionVariableNames.match(VarName))
|
|
|
115 return;
|
|
|
116
|
|
|
117 diag(ExceptionVarName->getLocation(), ErrorMessage)
|
|
|
118 << 1 << ExceptionVarName << MinimumExceptionNameLength;
|
|
|
119 }
|
|
|
120
|
|
|
121 const auto *LoopVar = Result.Nodes.getNodeAs<VarDecl>("loopVar");
|
|
|
122 if (LoopVar) {
|
|
|
123 if (!LoopVar->getIdentifier())
|
|
|
124 return;
|
|
|
125
|
|
|
126 StringRef VarName = LoopVar->getName();
|
|
|
127
|
|
|
128 if (VarName.size() >= MinimumLoopCounterNameLength ||
|
|
|
129 IgnoredLoopCounterNames.match(VarName))
|
|
|
130 return;
|
|
|
131
|
|
|
132 diag(LoopVar->getLocation(), ErrorMessage)
|
|
|
133 << 2 << LoopVar << MinimumLoopCounterNameLength;
|
|
|
134 }
|
|
|
135
|
|
|
136 const auto *ParamVar = Result.Nodes.getNodeAs<VarDecl>("paramVar");
|
|
|
137 if (ParamVar) {
|
|
|
138 if (!ParamVar->getIdentifier())
|
|
|
139 return;
|
|
|
140
|
|
|
141 StringRef VarName = ParamVar->getName();
|
|
|
142
|
|
|
143 if (VarName.size() >= MinimumParameterNameLength ||
|
|
|
144 IgnoredParameterNames.match(VarName))
|
|
|
145 return;
|
|
|
146
|
|
|
147 diag(ParamVar->getLocation(), ErrorMessage)
|
|
|
148 << 3 << ParamVar << MinimumParameterNameLength;
|
|
|
149 }
|
|
|
150 }
|
|
|
151
|
|
252
|
152 } // namespace clang::tidy::readability
|
