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
194
195
196
197
198
199
200
201
202
203
204
|
/*
* Copyright 2000-2013 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.intellij.codeInspection;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.psi.*;
import org.intellij.lang.annotations.Language;
import org.intellij.lang.annotations.Pattern;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.List;
/**
* @author max
*/
public abstract class LocalInspectionTool extends InspectionProfileEntry {
public static final LocalInspectionTool[] EMPTY_ARRAY = new LocalInspectionTool[0];
private static final Logger LOG = Logger.getInstance("#" + LocalInspectionTool.class.getName());
interface LocalDefaultNameProvider extends DefaultNameProvider {
@Nullable
String getDefaultID();
@Nullable
String getDefaultAlternativeID();
}
/**
* Pattern used for inspection ID validation.
*/
@NonNls @Language("RegExp")
public static final String VALID_ID_PATTERN = "[a-zA-Z_0-9.-]+";
public static boolean isValidID(@NotNull String id) {
return !id.isEmpty() && id.matches(VALID_ID_PATTERN);
}
/**
* <p>Inspection tool ID is a descriptive name to be used in "suppress" comments and annotations.
* <p>It must satisfy {@link #VALID_ID_PATTERN} regexp pattern.
* <p>If not defined {@link #getShortName()} is used as tool ID.
*
* @return inspection tool ID.
*/
@Pattern(VALID_ID_PATTERN)
@NonNls
@NotNull
public String getID() {
if (myNameProvider instanceof LocalDefaultNameProvider) {
final String id = ((LocalDefaultNameProvider)myNameProvider).getDefaultID();
if (id != null) {
return id;
}
}
return getShortName();
}
@Override
protected String getSuppressId() {
return getID();
}
@NonNls
@Nullable
public String getAlternativeID() {
if (myNameProvider instanceof LocalDefaultNameProvider) {
return ((LocalDefaultNameProvider)myNameProvider).getDefaultAlternativeID();
}
return null;
}
/**
* Override this method and return true if your inspection (unlike almost all others)
* must be called for every element in the whole file for each change, whatever small it was.
* <p/>
* For example, 'Field can be local' inspection can report the field declaration when reference to it was added inside method hundreds lines below.
* Hence, this inspection must be rerun on every change.
* <p/>
* Please note that re-scanning the whole file can take considerable time and thus seriously impact the responsiveness, so
* beg please use this mechanism once in a blue moon.
*
* @return true if inspection should be called for every element.
*/
public boolean runForWholeFile() {
return false;
}
/**
* Override this to report problems at file level.
*
* @param file to check.
* @param manager InspectionManager to ask for ProblemDescriptor's from.
* @param isOnTheFly true if called during on the fly editor highlighting. Called from Inspect Code action otherwise.
* @return <code>null</code> if no problems found or not applicable at file level.
*/
@Nullable
public ProblemDescriptor[] checkFile(@NotNull PsiFile file, @NotNull InspectionManager manager, boolean isOnTheFly) {
return null;
}
/**
* Override the method to provide your own inspection visitor, if you need to store additional state in the
* LocalInspectionToolSession user data or get information about the inspection scope.
* Visitor created must not be recursive (e.g. it must not inherit {@link com.intellij.psi.PsiRecursiveElementVisitor})
* since it will be fed with every element in the file anyway.
* Visitor created must be thread-safe since it might be called on several elements concurrently.
*
* @param holder where visitor will register problems found.
* @param isOnTheFly true if inspection was run in non-batch mode
* @param session the session in the context of which the tool runs.
* @return not-null visitor for this inspection.
*/
@NotNull
public PsiElementVisitor buildVisitor(@NotNull final ProblemsHolder holder, final boolean isOnTheFly, @NotNull LocalInspectionToolSession session) {
return buildVisitor(holder, isOnTheFly);
}
/**
* Override the method to provide your own inspection visitor.
* Visitor created must not be recursive (e.g. it must not inherit {@link com.intellij.psi.PsiRecursiveElementVisitor})
* since it will be fed with every element in the file anyway.
* Visitor created must be thread-safe since it might be called on several elements concurrently.
*
* @param holder where visitor will register problems found.
* @param isOnTheFly true if inspection was run in non-batch mode
* @return not-null visitor for this inspection.
*/
@NotNull
public PsiElementVisitor buildVisitor(@NotNull final ProblemsHolder holder, final boolean isOnTheFly) {
return new PsiElementVisitor() {
@Override
public void visitFile(PsiFile file) {
addDescriptors(checkFile(file, holder.getManager(), isOnTheFly));
}
private void addDescriptors(final ProblemDescriptor[] descriptors) {
if (descriptors != null) {
for (ProblemDescriptor descriptor : descriptors) {
LOG.assertTrue(descriptor != null, LocalInspectionTool.this.getClass().getName());
holder.registerProblem(descriptor);
}
}
}
};
}
@Nullable
public PsiNamedElement getProblemElement(PsiElement psiElement) {
while (psiElement!=null && !(psiElement instanceof PsiFile)) {
psiElement = psiElement.getParent();
}
return (PsiFile)psiElement;
}
public void inspectionStarted(@NotNull LocalInspectionToolSession session, boolean isOnTheFly) {}
public void inspectionFinished(@NotNull LocalInspectionToolSession session, @NotNull ProblemsHolder problemsHolder) {
inspectionFinished(session);
}
@Deprecated()
public void inspectionFinished(@NotNull LocalInspectionToolSession session) {}
@NotNull
public List<ProblemDescriptor> processFile(@NotNull PsiFile file,
@NotNull InspectionManager manager) {
final ProblemsHolder holder = new ProblemsHolder(manager, file, false);
LocalInspectionToolSession session = new LocalInspectionToolSession(file, 0, file.getTextLength());
final PsiElementVisitor customVisitor = buildVisitor(holder, false, session);
LOG.assertTrue(!(customVisitor instanceof PsiRecursiveElementVisitor),
"The visitor returned from LocalInspectionTool.buildVisitor() must not be recursive");
inspectionStarted(session, false);
file.accept(new PsiRecursiveElementWalkingVisitor() {
@Override
public void visitElement(PsiElement element) {
element.accept(customVisitor);
super.visitElement(element);
}
});
inspectionFinished(session, holder);
return holder.getResults();
}
}
|
