@NotNull
private static List<PsiMethod> findMethodsBySignature(
@NotNull PsiClass aClass,
@NotNull PsiMethod patternMethod,
boolean checkBases,
boolean stopOnFirst) {
final PsiMethod[] methodsByName = aClass.findMethodsByName(patternMethod.getName(), checkBases);
if (methodsByName.length == 0) return Collections.emptyList();
final List<PsiMethod> methods = new SmartList<PsiMethod>();
final MethodSignature patternSignature = patternMethod.getSignature(PsiSubstitutor.EMPTY);
for (final PsiMethod method : methodsByName) {
final PsiClass superClass = method.getContainingClass();
final PsiSubstitutor substitutor;
if (checkBases && !aClass.equals(superClass)) {
substitutor =
TypeConversionUtil.getSuperClassSubstitutor(superClass, aClass, PsiSubstitutor.EMPTY);
} else {
substitutor = PsiSubstitutor.EMPTY;
}
final MethodSignature signature = method.getSignature(substitutor);
if (signature.equals(patternSignature)) {
methods.add(method);
if (stopOnFirst) {
break;
}
}
}
return methods;
}
@Nullable
private ProblemDescriptor createDescription(
@NotNull PsiTypeCastExpression cast, @NotNull InspectionManager manager, boolean onTheFly) {
PsiExpression operand = cast.getOperand();
PsiTypeElement castType = cast.getCastType();
if (operand == null || castType == null) return null;
PsiElement parent = cast.getParent();
while (parent instanceof PsiParenthesizedExpression) {
parent = parent.getParent();
}
if (parent instanceof PsiReferenceExpression) {
if (IGNORE_ANNOTATED_METHODS) {
final PsiElement gParent = parent.getParent();
if (gParent instanceof PsiMethodCallExpression) {
final PsiMethod psiMethod = ((PsiMethodCallExpression) gParent).resolveMethod();
if (psiMethod != null && NullableNotNullManager.isNotNull(psiMethod)) {
final PsiClass superClass = PsiUtil.resolveClassInType(operand.getType());
final PsiClass containingClass = psiMethod.getContainingClass();
if (containingClass != null
&& superClass != null
&& containingClass.isInheritor(superClass, true)) {
for (PsiMethod method : psiMethod.findSuperMethods(superClass)) {
if (NullableNotNullManager.isNullable(method)) {
return null;
}
}
}
}
}
}
} else if (parent instanceof PsiExpressionList) {
final PsiElement gParent = parent.getParent();
if (gParent instanceof PsiMethodCallExpression && IGNORE_SUSPICIOUS_METHOD_CALLS) {
final String message =
SuspiciousCollectionsMethodCallsInspection.getSuspiciousMethodCallMessage(
(PsiMethodCallExpression) gParent,
operand.getType(),
true,
new ArrayList<PsiMethod>(),
new IntArrayList());
if (message != null) {
return null;
}
}
}
String message =
InspectionsBundle.message(
"inspection.redundant.cast.problem.descriptor",
"<code>" + operand.getText() + "</code>",
"<code>#ref</code> #loc");
return manager.createProblemDescriptor(
castType, message, myQuickFixAction, ProblemHighlightType.LIKE_UNUSED_SYMBOL, onTheFly);
}
public static boolean isMethodEquivalentTo(@NotNull PsiMethod method1, PsiElement another) {
if (method1 == another) return true;
if (!(another instanceof PsiMethod)) return false;
PsiMethod method2 = (PsiMethod) another;
if (!another.isValid()) return false;
if (!method1.getName().equals(method2.getName())) return false;
PsiClass aClass1 = method1.getContainingClass();
PsiClass aClass2 = method2.getContainingClass();
PsiManager manager = method1.getManager();
if (!(aClass1 != null && aClass2 != null && manager.areElementsEquivalent(aClass1, aClass2)))
return false;
PsiParameter[] parameters1 = method1.getParameterList().getParameters();
PsiParameter[] parameters2 = method2.getParameterList().getParameters();
if (parameters1.length != parameters2.length) return false;
for (int i = 0; i < parameters1.length; i++) {
PsiParameter parameter1 = parameters1[i];
PsiParameter parameter2 = parameters2[i];
PsiType type1 = parameter1.getType();
PsiType type2 = parameter2.getType();
if (!compareParamTypes(manager, type1, type2)) return false;
}
return true;
}
private static void addSuperSignatureElements(
final PsiClass parent,
boolean implemented,
CompletionResultSet result,
Set<MethodSignature> addedSignatures) {
for (CandidateInfo candidate :
OverrideImplementExploreUtil.getMethodsToOverrideImplement(parent, implemented)) {
PsiMethod baseMethod = (PsiMethod) candidate.getElement();
PsiClass baseClass = baseMethod.getContainingClass();
PsiSubstitutor substitutor = candidate.getSubstitutor();
if (!baseMethod.isConstructor()
&& baseClass != null
&& addedSignatures.add(baseMethod.getSignature(substitutor))) {
result.addElement(
createOverridingLookupElement(implemented, baseMethod, baseClass, substitutor));
}
}
}
private boolean hasGoodToString(PsiClass aClass) {
final PsiMethod[] methods =
aClass.findMethodsByName(HardcodedMethodConstants.TO_STRING, true);
for (PsiMethod method : methods) {
final PsiClass containingClass = method.getContainingClass();
if (containingClass == null) {
continue;
}
final String name = containingClass.getQualifiedName();
if (CommonClassNames.JAVA_LANG_OBJECT.equals(name)) {
continue;
}
final PsiParameterList parameterList = method.getParameterList();
if (parameterList.getParametersCount() == 0) {
return true;
}
}
return false;
}
@Override
public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) {
if (!FileModificationService.getInstance()
.preparePsiElementForWrite(descriptor.getPsiElement())) return;
final PsiModifierListOwner element =
PsiTreeUtil.getParentOfType(descriptor.getPsiElement(), PsiModifierListOwner.class);
if (element != null) {
RefElement refElement = null;
if (myManager != null) {
refElement = myManager.getReference(element);
}
try {
if (element instanceof PsiVariable) {
((PsiVariable) element).normalizeDeclaration();
}
PsiModifierList list = element.getModifierList();
LOG.assertTrue(list != null);
if (element instanceof PsiMethod) {
PsiMethod psiMethod = (PsiMethod) element;
PsiClass containingClass = psiMethod.getContainingClass();
if (containingClass != null
&& containingClass.getParent() instanceof PsiFile
&& myHint == PsiModifier.PRIVATE
&& list.hasModifierProperty(PsiModifier.FINAL)) {
list.setModifierProperty(PsiModifier.FINAL, false);
}
}
list.setModifierProperty(myHint, true);
if (refElement instanceof RefJavaElement) {
RefJavaUtil.getInstance().setAccessModifier((RefJavaElement) refElement, myHint);
}
} catch (IncorrectOperationException e) {
LOG.error(e);
}
}
}
private static boolean areGroovyObjectMethodsOverridden(GrReferenceExpression ref) {
PsiType qualifierType = GrReferenceResolveUtil.getQualifierType(ref);
if (!(qualifierType instanceof PsiClassType)) return false;
PsiClass resolved = ((PsiClassType) qualifierType).resolve();
if (resolved == null) return false;
PsiClass groovyObject =
JavaPsiFacade.getInstance(ref.getProject())
.findClass(GroovyCommonClassNames.GROOVY_OBJECT, ref.getResolveScope());
if (groovyObject == null) return false;
String methodName;
if (ref.getParent() instanceof GrCall) {
methodName = "invokeMethod";
} else if (PsiUtil.isLValue(ref)) {
methodName = "setProperty";
} else {
methodName = "getProperty";
}
PsiMethod[] patternMethods = groovyObject.findMethodsByName(methodName, false);
if (patternMethods.length != 1) return false;
PsiMethod patternMethod = patternMethods[0];
PsiMethod found = resolved.findMethodBySignature(patternMethod, true);
if (found == null) return false;
PsiClass aClass = found.getContainingClass();
if (aClass == null) return false;
String qname = aClass.getQualifiedName();
if (GroovyCommonClassNames.GROOVY_OBJECT.equals(qname)) return false;
if (GroovyCommonClassNames.GROOVY_OBJECT_SUPPORT.equals(qname)) return false;
return true;
}
@NotNull
private List<PsiMethod> getMethodsToImport() {
PsiShortNamesCache cache = PsiShortNamesCache.getInstance(myMethodCall.getProject());
PsiMethodCallExpression element = myMethodCall.getElement();
PsiReferenceExpression reference = element.getMethodExpression();
PsiExpressionList argumentList = element.getArgumentList();
String name = reference.getReferenceName();
List<PsiMethod> list = new ArrayList<PsiMethod>();
if (name == null) return list;
GlobalSearchScope scope = element.getResolveScope();
PsiMethod[] methods = cache.getMethodsByNameIfNotMoreThan(name, scope, 20);
List<PsiMethod> applicableList = new ArrayList<PsiMethod>();
final PsiResolveHelper resolveHelper =
JavaPsiFacade.getInstance(element.getProject()).getResolveHelper();
for (PsiMethod method : methods) {
ProgressManager.checkCanceled();
if (JavaCompletionUtil.isInExcludedPackage(method)) continue;
if (!method.hasModifierProperty(PsiModifier.STATIC)) continue;
PsiFile file = method.getContainingFile();
if (file instanceof PsiJavaFile
// do not show methods from default package
&& ((PsiJavaFile) file).getPackageName().length() != 0
&& PsiUtil.isAccessible(method, element, method.getContainingClass())) {
list.add(method);
PsiSubstitutor substitutorForMethod =
resolveHelper.inferTypeArguments(
method.getTypeParameters(),
method.getParameterList().getParameters(),
argumentList.getExpressions(),
PsiSubstitutor.EMPTY,
element.getParent(),
DefaultParameterTypeInferencePolicy.INSTANCE);
if (PsiUtil.isApplicable(method, substitutorForMethod, argumentList)) {
applicableList.add(method);
}
}
}
List<PsiMethod> result = applicableList.isEmpty() ? list : applicableList;
for (int i = result.size() - 1; i >= 0; i--) {
ProgressManager.checkCanceled();
PsiMethod method = result.get(i);
PsiClass containingClass = method.getContainingClass();
for (int j = i + 1; j < result.size(); j++) {
PsiMethod exMethod = result.get(j);
if (!Comparing.strEqual(exMethod.getName(), method.getName())) continue;
PsiClass exContainingClass = exMethod.getContainingClass();
if (containingClass != null
&& exContainingClass != null
&& !Comparing.equal(
containingClass.getQualifiedName(), exContainingClass.getQualifiedName())) continue;
// same named methods, drop one
result.remove(i);
break;
}
// check for manually excluded
if (isExcluded(method)) {
result.remove(i);
}
}
Collections.sort(result, new PsiProximityComparator(argumentList));
return result;
}
private static boolean processCachedMembersByName(
@NotNull PsiClass aClass,
@NotNull PsiScopeProcessor processor,
@NotNull ResolveState state,
@Nullable Set<PsiClass> visited,
PsiElement last,
@NotNull PsiElement place,
boolean isRaw,
@NotNull PsiSubstitutor substitutor,
@NotNull MembersMap value,
String name,
@NotNull LanguageLevel languageLevel) {
final ElementClassHint classHint = processor.getHint(ElementClassHint.KEY);
PsiElementFactory factory = JavaPsiFacade.getInstance(aClass.getProject()).getElementFactory();
if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclarationKind.FIELD)) {
final PsiField fieldByName = aClass.findFieldByName(name, false);
if (fieldByName != null) {
processor.handleEvent(PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, aClass);
if (!processor.execute(fieldByName, state)) return false;
} else {
final Map<String, List<Pair<PsiMember, PsiSubstitutor>>> allFieldsMap =
value.get(MemberType.FIELD);
final List<Pair<PsiMember, PsiSubstitutor>> list = allFieldsMap.get(name);
if (list != null) {
for (final Pair<PsiMember, PsiSubstitutor> candidate : list) {
PsiMember candidateField = candidate.getFirst();
PsiSubstitutor finalSubstitutor =
obtainFinalSubstitutor(
candidateField.getContainingClass(),
candidate.getSecond(),
aClass,
substitutor,
factory,
languageLevel);
processor.handleEvent(
PsiScopeProcessor.Event.SET_DECLARATION_HOLDER,
candidateField.getContainingClass());
if (!processor.execute(candidateField, state.put(PsiSubstitutor.KEY, finalSubstitutor)))
return false;
}
}
}
}
if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclarationKind.CLASS)) {
if (last != null && last.getParent() == aClass) {
if (last instanceof PsiClass) {
if (!processor.execute(last, state)) return false;
}
// Parameters
final PsiTypeParameterList list = aClass.getTypeParameterList();
if (list != null && !list.processDeclarations(processor, state, last, place)) return false;
}
if (!(last instanceof PsiReferenceList)) {
final PsiClass classByName = aClass.findInnerClassByName(name, false);
if (classByName != null) {
processor.handleEvent(PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, aClass);
if (!processor.execute(classByName, state)) return false;
} else {
Map<String, List<Pair<PsiMember, PsiSubstitutor>>> allClassesMap =
value.get(MemberType.CLASS);
List<Pair<PsiMember, PsiSubstitutor>> list = allClassesMap.get(name);
if (list != null) {
for (final Pair<PsiMember, PsiSubstitutor> candidate : list) {
PsiMember inner = candidate.getFirst();
PsiClass containingClass = inner.getContainingClass();
if (containingClass != null) {
PsiSubstitutor finalSubstitutor =
obtainFinalSubstitutor(
containingClass,
candidate.getSecond(),
aClass,
substitutor,
factory,
languageLevel);
processor.handleEvent(
PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, containingClass);
if (!processor.execute(inner, state.put(PsiSubstitutor.KEY, finalSubstitutor)))
return false;
}
}
}
}
}
}
if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclarationKind.METHOD)) {
if (processor instanceof MethodResolverProcessor) {
final MethodResolverProcessor methodResolverProcessor = (MethodResolverProcessor) processor;
if (methodResolverProcessor.isConstructor()) {
final PsiMethod[] constructors = aClass.getConstructors();
methodResolverProcessor.handleEvent(
PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, aClass);
for (PsiMethod constructor : constructors) {
if (!methodResolverProcessor.execute(constructor, state)) return false;
}
return true;
}
}
Map<String, List<Pair<PsiMember, PsiSubstitutor>>> allMethodsMap =
value.get(MemberType.METHOD);
List<Pair<PsiMember, PsiSubstitutor>> list = allMethodsMap.get(name);
if (list != null) {
for (final Pair<PsiMember, PsiSubstitutor> candidate : list) {
ProgressIndicatorProvider.checkCanceled();
PsiMethod candidateMethod = (PsiMethod) candidate.getFirst();
if (processor instanceof MethodResolverProcessor) {
if (candidateMethod.isConstructor()
!= ((MethodResolverProcessor) processor).isConstructor()) continue;
}
final PsiClass containingClass = candidateMethod.getContainingClass();
if (visited != null && visited.contains(candidateMethod.getContainingClass())) {
continue;
}
PsiSubstitutor finalSubstitutor =
obtainFinalSubstitutor(
containingClass,
candidate.getSecond(),
aClass,
substitutor,
factory,
languageLevel);
finalSubstitutor = checkRaw(isRaw, factory, candidateMethod, finalSubstitutor);
processor.handleEvent(PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, containingClass);
if (!processor.execute(candidateMethod, state.put(PsiSubstitutor.KEY, finalSubstitutor)))
return false;
}
if (visited != null) {
for (Pair<PsiMember, PsiSubstitutor> aList : list) {
visited.add(aList.getFirst().getContainingClass());
}
}
}
}
return true;
}