@Nullable
public CommonProblemDescriptor[] checkElement(
RefEntity refEntity,
AnalysisScope scope,
InspectionManager manager,
GlobalInspectionContext globalContext,
ProblemDescriptionsProcessor processor) {
ArrayList<ProblemDescriptor> problems = null;
if (refEntity instanceof RefMethod) {
final RefMethod refMethod = (RefMethod) refEntity;
if (refMethod.hasSuperMethods()) return null;
if (refMethod.isEntry()) return null;
RefParameter[] parameters = refMethod.getParameters();
for (RefParameter refParameter : parameters) {
String value = refParameter.getActualValueIfSame();
if (value != null) {
if (problems == null) problems = new ArrayList<ProblemDescriptor>(1);
final String paramName = refParameter.getName();
problems.add(
manager.createProblemDescriptor(
refParameter.getElement(),
InspectionsBundle.message(
"inspection.same.parameter.problem.descriptor",
"<code>" + paramName + "</code>",
"<code>" + value + "</code>"),
new InlineParameterValueFix(paramName, value),
ProblemHighlightType.GENERIC_ERROR_OR_WARNING,
false));
}
}
}
return problems == null ? null : problems.toArray(new CommonProblemDescriptor[problems.size()]);
}
@Override
public void onReferencesBuild(RefElement refElement) {
if (refElement instanceof RefClass) {
final PsiClass psiClass = (PsiClass) refElement.getElement();
if (psiClass != null) {
if (refElement.isEntry()) {
((RefClassImpl) refElement).setFlag(false, CAN_BE_FINAL_MASK);
}
PsiMethod[] psiMethods = psiClass.getMethods();
PsiField[] psiFields = psiClass.getFields();
HashSet<PsiVariable> allFields = new HashSet<PsiVariable>();
ContainerUtil.addAll(allFields, psiFields);
ArrayList<PsiVariable> instanceInitializerInitializedFields = new ArrayList<PsiVariable>();
boolean hasInitializers = false;
for (PsiClassInitializer initializer : psiClass.getInitializers()) {
PsiCodeBlock body = initializer.getBody();
hasInitializers = true;
ControlFlow flow;
try {
flow =
ControlFlowFactory.getInstance(body.getProject())
.getControlFlow(
body, LocalsOrMyInstanceFieldsControlFlowPolicy.getInstance(), false);
} catch (AnalysisCanceledException e) {
flow = ControlFlow.EMPTY;
}
Collection<PsiVariable> writtenVariables = new ArrayList<PsiVariable>();
ControlFlowUtil.getWrittenVariables(flow, 0, flow.getSize(), false, writtenVariables);
for (PsiVariable psiVariable : writtenVariables) {
if (allFields.contains(psiVariable)) {
if (instanceInitializerInitializedFields.contains(psiVariable)) {
allFields.remove(psiVariable);
instanceInitializerInitializedFields.remove(psiVariable);
} else {
instanceInitializerInitializedFields.add(psiVariable);
}
}
}
for (PsiVariable psiVariable : writtenVariables) {
if (!instanceInitializerInitializedFields.contains(psiVariable)) {
allFields.remove(psiVariable);
}
}
}
for (PsiMethod psiMethod : psiMethods) {
if (psiMethod.isConstructor()) {
PsiCodeBlock body = psiMethod.getBody();
if (body != null) {
hasInitializers = true;
ControlFlow flow;
try {
flow =
ControlFlowFactory.getInstance(body.getProject())
.getControlFlow(
body, LocalsOrMyInstanceFieldsControlFlowPolicy.getInstance(), false);
} catch (AnalysisCanceledException e) {
flow = ControlFlow.EMPTY;
}
Collection<PsiVariable> writtenVariables =
ControlFlowUtil.getWrittenVariables(flow, 0, flow.getSize(), false);
for (PsiVariable psiVariable : writtenVariables) {
if (instanceInitializerInitializedFields.contains(psiVariable)) {
allFields.remove(psiVariable);
instanceInitializerInitializedFields.remove(psiVariable);
}
}
List<PsiMethod> redirectedConstructors =
HighlightControlFlowUtil.getChainedConstructors(psiMethod);
if (redirectedConstructors == null || redirectedConstructors.isEmpty()) {
List<PsiVariable> ssaVariables = ControlFlowUtil.getSSAVariables(flow);
ArrayList<PsiVariable> good = new ArrayList<PsiVariable>(ssaVariables);
good.addAll(instanceInitializerInitializedFields);
allFields.retainAll(good);
} else {
allFields.removeAll(writtenVariables);
}
}
}
}
for (PsiField psiField : psiFields) {
if ((!hasInitializers || !allFields.contains(psiField))
&& psiField.getInitializer() == null) {
final RefFieldImpl refField = (RefFieldImpl) myManager.getReference(psiField);
if (refField != null) {
refField.setFlag(false, CAN_BE_FINAL_MASK);
}
}
}
}
} else if (refElement instanceof RefMethod) {
final RefMethod refMethod = (RefMethod) refElement;
if (refMethod.isEntry()) {
((RefMethodImpl) refMethod).setFlag(false, CAN_BE_FINAL_MASK);
}
}
}
@Override
@Nullable
public CommonProblemDescriptor[] checkElement(
@NotNull final RefEntity refEntity,
@NotNull final AnalysisScope scope,
@NotNull final InspectionManager manager,
@NotNull final GlobalInspectionContext globalContext,
@NotNull final ProblemDescriptionsProcessor processor) {
if (refEntity instanceof RefJavaElement) {
final RefJavaElement refElement = (RefJavaElement) refEntity;
if (refElement instanceof RefParameter) return null;
if (refElement.isSyntheticJSP()) return null;
// ignore entry points.
if (refElement.isEntry()) return null;
// ignore implicit constructors. User should not be able to see them.
if (refElement instanceof RefImplicitConstructor) return null;
if (refElement instanceof RefField
&& ((RefField) refElement).getElement() instanceof PsiEnumConstant) return null;
// ignore library override methods.
if (refElement instanceof RefMethod) {
RefMethod refMethod = (RefMethod) refElement;
if (refMethod.isExternalOverride()) return null;
if (refMethod.isEntry()) return null;
}
// ignore anonymous classes. They do not have access modifiers.
if (refElement instanceof RefClass) {
RefClass refClass = (RefClass) refElement;
if (refClass.isAnonymous()
|| refClass.isEntry()
|| refClass.isTestCase()
|| refClass.isServlet()
|| refClass.isApplet()
|| refClass.isLocalClass()) return null;
if (isTopLevelClass(refClass) && !SUGGEST_PACKAGE_LOCAL_FOR_TOP_CLASSES) return null;
}
// ignore unreferenced code. They could be a potential entry points.
if (refElement.getInReferences().isEmpty()) return null;
// ignore interface members. They always have public access modifier.
if (refElement.getOwner() instanceof RefClass) {
RefClass refClass = (RefClass) refElement.getOwner();
if (refClass.isInterface()) return null;
}
String access = getPossibleAccess(refElement);
if (access != refElement.getAccessModifier() && access != null) {
final PsiElement element = refElement.getElement();
final PsiElement nameIdentifier =
element != null ? HighlightUsagesHandler.getNameIdentifier(element) : null;
if (nameIdentifier != null) {
return new ProblemDescriptor[] {
manager.createProblemDescriptor(
nameIdentifier,
access.equals(PsiModifier.PRIVATE)
? CAN_BE_PRIVATE
: access.equals(PsiModifier.PACKAGE_LOCAL)
? CAN_BE_PACKAGE_LOCAL
: CAN_BE_PROTECTED,
new AcceptSuggestedAccess(globalContext.getRefManager(), access),
ProblemHighlightType.GENERIC_ERROR_OR_WARNING,
false)
};
}
}
}
return null;
}