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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
|
////////////////////////////////////////////////////////////////////////////////
// checkstyle: Checks Java source code for adherence to a set of rules.
// Copyright (C) 2001-2017 the original author or authors.
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
////////////////////////////////////////////////////////////////////////////////
package com.puppycrawl.tools.checkstyle.checks.naming;
import java.util.Arrays;
import java.util.Optional;
import com.puppycrawl.tools.checkstyle.api.DetailAST;
import com.puppycrawl.tools.checkstyle.api.TokenTypes;
import com.puppycrawl.tools.checkstyle.utils.CheckUtils;
import com.puppycrawl.tools.checkstyle.utils.ScopeUtils;
/**
* <p>
* Checks that method and {@code catch} parameter names conform to a format specified
* by the format property. The format is a
* {@link java.util.regex.Pattern regular expression}
* and defaults to
* <strong>^[a-z][a-zA-Z0-9]*$</strong>.
* </p>
* <p>The check has the following options:</p>
* <p><b>ignoreOverridden</b> - allows to skip methods with Override annotation from
* validation. Default values is <b>false</b> .</p>
* <p><b>accessModifiers</b> - access modifiers of methods which should to be checked.
* Default value is <b>public, protected, package, private</b> .</p>
* An example of how to configure the check:
* <pre>
* <module name="ParameterName"/>
* </pre>
* <p>
* An example of how to configure the check for names that begin with
* a lower case letter, followed by letters, digits, and underscores:
* </p>
* <pre>
* <module name="ParameterName">
* <property name="format" value="^[a-z][_a-zA-Z0-9]+$"/>
* </module>
* </pre>
* <p>
* An example of how to configure the check to skip methods with Override annotation from
* validation:
* </p>
* <pre>
* <module name="ParameterName">
* <property name="ignoreOverridden" value="true"/>
* </module>
* </pre>
*
* @author Oliver Burn
* @author Andrei Selkin
*/
public class ParameterNameCheck extends AbstractNameCheck {
/**
* Allows to skip methods with Override annotation from validation.
*/
private boolean ignoreOverridden;
/** Access modifiers of methods which should be checked. */
private AccessModifier[] accessModifiers = {
AccessModifier.PUBLIC,
AccessModifier.PROTECTED,
AccessModifier.PACKAGE,
AccessModifier.PRIVATE,
};
/**
* Creates a new {@code ParameterNameCheck} instance.
*/
public ParameterNameCheck() {
super("^[a-z][a-zA-Z0-9]*$");
}
/**
* Sets whether to skip methods with Override annotation from validation.
* @param ignoreOverridden Flag for skipping methods with Override annotation.
*/
public void setIgnoreOverridden(boolean ignoreOverridden) {
this.ignoreOverridden = ignoreOverridden;
}
/**
* Sets access modifiers of methods which should be checked.
* @param accessModifiers access modifiers of methods which should be checked.
*/
public void setAccessModifiers(AccessModifier... accessModifiers) {
this.accessModifiers =
Arrays.copyOf(accessModifiers, accessModifiers.length);
}
@Override
public int[] getDefaultTokens() {
return getRequiredTokens();
}
@Override
public int[] getAcceptableTokens() {
return getRequiredTokens();
}
@Override
public int[] getRequiredTokens() {
return new int[] {TokenTypes.PARAMETER_DEF};
}
@Override
protected boolean mustCheckName(DetailAST ast) {
boolean checkName = true;
if (ignoreOverridden && isOverriddenMethod(ast)
|| ast.getParent().getType() == TokenTypes.LITERAL_CATCH
|| CheckUtils.isReceiverParameter(ast)
|| !matchAccessModifiers(getAccessModifier(ast))) {
checkName = false;
}
return checkName;
}
/**
* Returns the access modifier of the method/constructor at the specified AST. If
* the method is in an interface or annotation block, the access modifier is assumed
* to be public.
*
* @param ast the token of the method/constructor.
* @return the access modifier of the method/constructor.
*/
private static AccessModifier getAccessModifier(final DetailAST ast) {
final DetailAST params = ast.getParent();
final DetailAST meth = params.getParent();
AccessModifier accessModifier = AccessModifier.PRIVATE;
if (meth.getType() == TokenTypes.METHOD_DEF
|| meth.getType() == TokenTypes.CTOR_DEF) {
if (ScopeUtils.isInInterfaceOrAnnotationBlock(ast)) {
accessModifier = AccessModifier.PUBLIC;
}
else {
final DetailAST modsToken = meth.findFirstToken(TokenTypes.MODIFIERS);
accessModifier = CheckUtils.getAccessModifierFromModifiersToken(modsToken);
}
}
return accessModifier;
}
/**
* Checks whether a method has the correct access modifier to be checked.
* @param accessModifier the access modifier of the method.
* @return whether the method matches the expected access modifier.
*/
private boolean matchAccessModifiers(final AccessModifier accessModifier) {
return Arrays.stream(accessModifiers).anyMatch(el -> el == accessModifier);
}
/**
* Checks whether a method is annotated with Override annotation.
* @param ast method parameter definition token.
* @return true if a method is annotated with Override annotation.
*/
private static boolean isOverriddenMethod(DetailAST ast) {
boolean overridden = false;
final DetailAST parent = ast.getParent().getParent();
final Optional<DetailAST> annotation =
Optional.ofNullable(parent.getFirstChild().getFirstChild());
if (annotation.isPresent()
&& annotation.get().getType() == TokenTypes.ANNOTATION) {
final Optional<DetailAST> overrideToken =
Optional.ofNullable(annotation.get().findFirstToken(TokenTypes.IDENT));
if (overrideToken.isPresent() && "Override".equals(overrideToken.get().getText())) {
overridden = true;
}
}
return overridden;
}
}
|
