@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 static PsiElement doResolveMember(PsiClass aClass, String memberName) {
PsiMember member = aClass.findFieldByName(memberName, true);
if (member != null) return member;
PsiMethod[] methods = aClass.findMethodsByName(memberName, true);
return methods.length == 0 ? null : methods[0];
}
public boolean isMethodSignatureExists() {
PsiClass target = myTargetMethod.getContainingClass();
LOG.assertTrue(target != null);
PsiMethod[] methods = target.findMethodsByName(myTargetMethod.getName(), false);
for (PsiMethod method : methods) {
if (PsiUtil.isApplicable(method, PsiSubstitutor.EMPTY, myExpressions)) return true;
}
return false;
}
@Nullable
private static PsiMethod getMethod(PsiClass psiClass, MethodSignature methodSignature) {
final PsiMethod[] methodsByName = psiClass.findMethodsByName(methodSignature.getName(), true);
for (PsiMethod psiMethod : methodsByName) {
if (MethodSignatureUtil.areSignaturesEqual(
getMethodSignature(psiMethod, psiClass, psiMethod.getContainingClass()),
methodSignature)) {
return psiMethod;
}
}
return null;
}
@Override
public void visitAnnotationNameValuePair(GrAnnotationNameValuePair nameValuePair) {
if (myExpression.equals(nameValuePair.getValue())) {
final PsiClass annot = ResolveUtil.resolveAnnotation(nameValuePair.getParent());
if (annot != null) {
final String name = nameValuePair.getName();
if (name != null) {
final PsiMethod[] attrs = annot.findMethodsByName(name, false);
if (attrs.length > 0) {
PsiType type = attrs[0].getReturnType();
while (type instanceof PsiArrayType) type = ((PsiArrayType) type).getComponentType();
if (type != null && isAcceptableAnnotationValueType(type)) {
myResult = createSimpleSubTypeResult(type);
}
}
} else {
final PsiMethod[] valueAttr = annot.findMethodsByName("value", false);
boolean canHaveSimpleExpr = valueAttr.length > 0;
final PsiMethod[] methods = annot.getMethods();
for (PsiMethod method : methods) {
if (!("value".equals(method.getName())
|| method instanceof PsiAnnotationMethod
&& ((PsiAnnotationMethod) method).getDefaultValue() != null)) {
canHaveSimpleExpr = false;
}
}
if (canHaveSimpleExpr) {
PsiType type = valueAttr[0].getReturnType();
while (type instanceof PsiArrayType) type = ((PsiArrayType) type).getComponentType();
if (type != null && isAcceptableAnnotationValueType(type)) {
myResult = createSimpleSubTypeResult(type);
}
}
}
}
}
}
@NotNull
public static List<PsiMethod> getSetters(
@NotNull final PsiClass psiClass, final String propertyName) {
final String setterName = suggestSetterName(propertyName);
final PsiMethod[] psiMethods = psiClass.findMethodsByName(setterName, true);
final ArrayList<PsiMethod> list = new ArrayList<PsiMethod>(psiMethods.length);
for (PsiMethod method : psiMethods) {
if (filterMethods(method)) continue;
if (PropertyUtil.isSimplePropertySetter(method)) {
list.add(method);
}
}
return list;
}
private static void checkAnnotationsJarAttached(@NotNull LocalInspectionToolSession session) {
PsiFile file = session.getFile();
final Project project = file.getProject();
PsiClass event =
JavaPsiFacade.getInstance(project)
.findClass("java.awt.event.InputEvent", GlobalSearchScope.allScope(project));
if (event == null) return; // no jdk to attach
PsiMethod[] methods = event.findMethodsByName("getModifiers", false);
if (methods.length != 1) return; // no jdk to attach
PsiMethod getModifiers = methods[0];
PsiAnnotation annotation =
ExternalAnnotationsManager.getInstance(project)
.findExternalAnnotation(getModifiers, MagicConstant.class.getName());
if (annotation != null) return;
final VirtualFile virtualFile = PsiUtilCore.getVirtualFile(getModifiers);
if (virtualFile == null) return; // no jdk to attach
final List<OrderEntry> entries =
ProjectRootManager.getInstance(project).getFileIndex().getOrderEntriesForFile(virtualFile);
Sdk jdk = null;
for (OrderEntry orderEntry : entries) {
if (orderEntry instanceof JdkOrderEntry) {
jdk = ((JdkOrderEntry) orderEntry).getJdk();
if (jdk != null) break;
}
}
if (jdk == null) return; // no jdk to attach
if (!ApplicationManager.getApplication().isUnitTestMode()) {
final Sdk finalJdk = jdk;
ApplicationManager.getApplication()
.invokeLater(
new Runnable() {
@Override
public void run() {
ApplicationManager.getApplication()
.runWriteAction(
new Runnable() {
public void run() {
attachJdkAnnotations(finalJdk);
}
});
}
},
ModalityState.NON_MODAL,
project.getDisposed());
}
}
@Override
public void visitAnnotationArrayInitializer(GrAnnotationArrayInitializer arrayInitializer) {
final GrAnnotationNameValuePair nameValuePair =
PsiTreeUtil.getParentOfType(
arrayInitializer,
GrAnnotationNameValuePair.class,
true,
GrDefaultAnnotationValue.class);
if (nameValuePair != null) {
final PsiClass annot = ResolveUtil.resolveAnnotation(arrayInitializer);
if (annot == null) return;
final String name = nameValuePair.getName();
if (name == null) return;
final PsiMethod[] attrs = annot.findMethodsByName(name, false);
if (attrs.length > 0) {
PsiType type = attrs[0].getReturnType();
while (type instanceof PsiArrayType) type = ((PsiArrayType) type).getComponentType();
if (type != null && isAcceptableAnnotationValueType(type)) {
myResult = createSimpleSubTypeResult(type);
}
}
} else {
final GrAnnotationMethod method =
PsiTreeUtil.getParentOfType(arrayInitializer, GrAnnotationMethod.class);
assert method != null;
PsiType type = method.getReturnType();
int count = 1;
PsiElement parent = arrayInitializer.getParent();
while (parent instanceof GrAnnotationArrayInitializer) {
count++;
parent = parent.getParent();
}
while (type instanceof PsiArrayType && count > 0) {
type = ((PsiArrayType) type).getComponentType();
count--;
}
if (type != null && isAcceptableAnnotationValueType(type)) {
myResult = createSimpleSubTypeResult(type);
}
}
}
@NotNull
public static List<Pair<PsiMethod, PsiSubstitutor>> findMethodsAndTheirSubstitutorsByName(
@NotNull PsiClass psiClass, String name, boolean checkBases) {
if (!checkBases) {
final PsiMethod[] methodsByName = psiClass.findMethodsByName(name, false);
final List<Pair<PsiMethod, PsiSubstitutor>> ret =
new ArrayList<Pair<PsiMethod, PsiSubstitutor>>(methodsByName.length);
for (final PsiMethod method : methodsByName) {
ret.add(new Pair<PsiMethod, PsiSubstitutor>(method, PsiSubstitutor.EMPTY));
}
return ret;
}
Map<String, List<Pair<PsiMember, PsiSubstitutor>>> map = getMap(psiClass, MemberType.METHOD);
@SuppressWarnings("unchecked")
List<Pair<PsiMethod, PsiSubstitutor>> list = (List) map.get(name);
return list == null
? Collections.<Pair<PsiMethod, PsiSubstitutor>>emptyList()
: Collections.unmodifiableList(list);
}
private static boolean usesDefaultClone(PsiClass aClass) {
final Project project = aClass.getProject();
final PsiManager manager = aClass.getManager();
final GlobalSearchScope scope = GlobalSearchScope.allScope(project);
final PsiClass cloneable =
JavaPsiFacade.getInstance(manager.getProject()).findClass("java.lang.Cloneable", scope);
if (!InheritanceUtil.isInheritorOrSelf(aClass, cloneable, true)) {
return false;
}
final PsiMethod[] methods = aClass.findMethodsByName("clone", false);
for (PsiMethod method : methods) {
final PsiParameterList parameterList = method.getParameterList();
final PsiParameter[] parameters = parameterList.getParameters();
if (parameters.length == 0) {
return false;
}
}
return true;
}
private static boolean nameCanBeStaticallyImported(
@NotNull String fqName, @NotNull String memberName, @NotNull PsiElement context) {
final PsiClass containingClass = PsiTreeUtil.getParentOfType(context, PsiClass.class);
if (containingClass == null) {
return false;
}
if (InheritanceUtil.isInheritor(containingClass, fqName)) {
return true;
}
final PsiField field = containingClass.findFieldByName(memberName, true);
if (field != null) {
return false;
}
final PsiMethod[] methods = containingClass.findMethodsByName(memberName, true);
if (methods.length > 0) {
return false;
}
return !hasOnDemandImportStaticConflict(fqName, memberName, context, true)
&& !hasExactImportStaticConflict(fqName, memberName, context);
}
@Nullable
private SiblingInfo findSibling(PsiClass inheritor, PsiClass anInterface, PsiMethod method) {
for (PsiMethod superMethod : anInterface.findMethodsByName(method.getName(), true)) {
PsiElement navigationElement = superMethod.getNavigationElement();
if (!(navigationElement instanceof PsiMethod)) continue; // Kotlin
superMethod = (PsiMethod) navigationElement;
ProgressManager.checkCanceled();
PsiClass superInterface = superMethod.getContainingClass();
if (superInterface == null || myContainingClass.isInheritor(superInterface, true)) {
// if containingClass implements the superInterface then it's not a sibling inheritance
// but a pretty boring the usual one
continue;
}
if (isOverridden(inheritor, method, superMethod, superInterface)) {
return new SiblingInfo(superMethod, inheritor);
}
}
return null;
}
private static boolean usesDefaultSerialization(PsiClass aClass) {
final Project project = aClass.getProject();
final PsiManager manager = aClass.getManager();
final GlobalSearchScope scope = GlobalSearchScope.allScope(project);
final PsiClass serializable =
JavaPsiFacade.getInstance(manager.getProject()).findClass("java.io.Serializable", scope);
if (!InheritanceUtil.isInheritorOrSelf(aClass, serializable, true)) {
return false;
}
final PsiMethod[] methods = aClass.findMethodsByName("writeObject", false);
for (PsiMethod method : methods) {
final PsiParameterList parameterList = method.getParameterList();
final PsiParameter[] parameters = parameterList.getParameters();
if (parameters.length == 1) {
final PsiType type = parameters[0].getType();
final String text = type.getCanonicalText();
if ("java.io.DataOutputStream".equals(text)) {
return false;
}
}
}
return true;
}
private static boolean hasOnDemandImportStaticConflict(
String fqName, String memberName, PsiElement context, boolean strict) {
final PsiFile file = context.getContainingFile();
if (!(file instanceof PsiJavaFile)) {
return false;
}
final PsiJavaFile javaFile = (PsiJavaFile) file;
final PsiImportList importList = javaFile.getImportList();
if (importList == null) {
return false;
}
final PsiImportStaticStatement[] importStaticStatements =
importList.getImportStaticStatements();
for (PsiImportStaticStatement importStaticStatement : importStaticStatements) {
if (!importStaticStatement.isOnDemand()) {
continue;
}
final PsiClass targetClass = importStaticStatement.resolveTargetClass();
if (targetClass == null) {
continue;
}
final String name = targetClass.getQualifiedName();
if (fqName.equals(name)) {
continue;
}
final PsiField field = targetClass.findFieldByName(memberName, true);
if (field != null && (!strict || memberReferenced(field, javaFile))) {
return true;
}
final PsiMethod[] methods = targetClass.findMethodsByName(memberName, true);
if (methods.length > 0 && (!strict || membersReferenced(methods, javaFile))) {
return true;
}
}
return false;
}
@NotNull
private static Set<String> findSingleImports(
@NotNull final PsiJavaFile file,
@NotNull String[] names,
@NotNull final Set<String> onDemandImports,
@NotNull Set<String> namesToImportStaticly) {
final GlobalSearchScope resolveScope = file.getResolveScope();
Set<String> namesToUseSingle = new THashSet<String>();
final String thisPackageName = file.getPackageName();
final Set<String> implicitlyImportedPackages =
new THashSet<String>(Arrays.asList(file.getImplicitlyImportedPackages()));
final PsiManager manager = file.getManager();
for (String name : names) {
String prefix = getPackageOrClassName(name);
if (prefix.length() == 0) continue;
final boolean isImplicitlyImported = implicitlyImportedPackages.contains(prefix);
if (!onDemandImports.contains(prefix) && !isImplicitlyImported) continue;
String shortName = PsiNameHelper.getShortClassName(name);
String thisPackageClass =
thisPackageName.length() > 0 ? thisPackageName + "." + shortName : shortName;
if (JavaPsiFacade.getInstance(manager.getProject()).findClass(thisPackageClass, resolveScope)
!= null) {
namesToUseSingle.add(name);
continue;
}
if (!isImplicitlyImported) {
String langPackageClass = JAVA_LANG_PACKAGE + "." + shortName; // TODO : JSP!
if (JavaPsiFacade.getInstance(manager.getProject())
.findClass(langPackageClass, resolveScope)
!= null) {
namesToUseSingle.add(name);
continue;
}
}
for (String onDemandName : onDemandImports) {
if (prefix.equals(onDemandName)) continue;
if (namesToImportStaticly.contains(name)) {
PsiClass aClass =
JavaPsiFacade.getInstance(manager.getProject()).findClass(onDemandName, resolveScope);
if (aClass != null) {
PsiField field = aClass.findFieldByName(shortName, true);
if (field != null && field.hasModifierProperty(PsiModifier.STATIC)) {
namesToUseSingle.add(name);
} else {
PsiClass inner = aClass.findInnerClassByName(shortName, true);
if (inner != null && inner.hasModifierProperty(PsiModifier.STATIC)) {
namesToUseSingle.add(name);
} else {
PsiMethod[] methods = aClass.findMethodsByName(shortName, true);
for (PsiMethod method : methods) {
if (method.hasModifierProperty(PsiModifier.STATIC)) {
namesToUseSingle.add(name);
}
}
}
}
}
} else {
PsiClass aClass =
JavaPsiFacade.getInstance(manager.getProject())
.findClass(onDemandName + "." + shortName, resolveScope);
if (aClass != null) {
namesToUseSingle.add(name);
}
}
}
}
return namesToUseSingle;
}
private static void completeAnnotationAttributeName(
CompletionResultSet result, PsiElement insertedElement, CompletionParameters parameters) {
PsiNameValuePair pair = PsiTreeUtil.getParentOfType(insertedElement, PsiNameValuePair.class);
PsiAnnotationParameterList parameterList = (PsiAnnotationParameterList) pair.getParent();
PsiAnnotation anno = (PsiAnnotation) parameterList.getParent();
boolean showClasses = psiElement().afterLeaf("(").accepts(insertedElement);
PsiClass annoClass = null;
final PsiJavaCodeReferenceElement referenceElement = anno.getNameReferenceElement();
if (referenceElement != null) {
final PsiElement element = referenceElement.resolve();
if (element instanceof PsiClass) {
annoClass = (PsiClass) element;
if (annoClass.findMethodsByName("value", false).length == 0) {
showClasses = false;
}
}
}
if (showClasses && insertedElement.getParent() instanceof PsiReferenceExpression) {
final Set<LookupElement> set =
JavaCompletionUtil.processJavaReference(
insertedElement,
(PsiJavaReference) insertedElement.getParent(),
new ElementExtractorFilter(createAnnotationFilter(insertedElement)),
JavaCompletionProcessor.Options.DEFAULT_OPTIONS,
result.getPrefixMatcher(),
parameters);
for (final LookupElement element : set) {
result.addElement(element);
}
addAllClasses(parameters, result, new InheritorsHolder(insertedElement, result));
}
if (annoClass != null) {
final PsiNameValuePair[] existingPairs = parameterList.getAttributes();
methods:
for (PsiMethod method : annoClass.getMethods()) {
if (!(method instanceof PsiAnnotationMethod)) continue;
final String attrName = method.getName();
for (PsiNameValuePair existingAttr : existingPairs) {
if (PsiTreeUtil.isAncestor(existingAttr, insertedElement, false)) break;
if (Comparing.equal(existingAttr.getName(), attrName)
|| PsiAnnotation.DEFAULT_REFERENCED_METHOD_NAME.equals(attrName)
&& existingAttr.getName() == null) continue methods;
}
LookupElementBuilder element =
LookupElementBuilder.createWithIcon(method)
.withInsertHandler(
new InsertHandler<LookupElement>() {
@Override
public void handleInsert(InsertionContext context, LookupElement item) {
final Editor editor = context.getEditor();
TailType.EQ.processTail(editor, editor.getCaretModel().getOffset());
context.setAddCompletionChar(false);
context.commitDocument();
PsiAnnotationParameterList paramList =
PsiTreeUtil.findElementOfClassAtOffset(
context.getFile(),
context.getStartOffset(),
PsiAnnotationParameterList.class,
false);
if (paramList != null
&& paramList.getAttributes().length > 0
&& paramList.getAttributes()[0].getName() == null) {
int valueOffset =
paramList.getAttributes()[0].getTextRange().getStartOffset();
context
.getDocument()
.insertString(
valueOffset, PsiAnnotation.DEFAULT_REFERENCED_METHOD_NAME);
TailType.EQ.processTail(
editor,
valueOffset + PsiAnnotation.DEFAULT_REFERENCED_METHOD_NAME.length());
}
}
});
PsiAnnotationMemberValue defaultValue = ((PsiAnnotationMethod) method).getDefaultValue();
if (defaultValue != null) {
Object constant =
JavaPsiFacade.getInstance(method.getProject())
.getConstantEvaluationHelper()
.computeConstantExpression(defaultValue);
if (constant != null) {
element =
element.withTailText(
" default " + (constant instanceof String ? "\"" + constant + "\"" : constant),
true);
}
}
result.addElement(element);
}
}
}
private static boolean processDeclarationsInClassNotCached(
@NotNull PsiClass aClass,
@NotNull PsiScopeProcessor processor,
@NotNull ResolveState state,
@Nullable Set<PsiClass> visited,
PsiElement last,
@NotNull PsiElement place,
boolean isRaw,
@NotNull LanguageLevel languageLevel) {
if (visited == null) visited = new THashSet<PsiClass>();
if (!visited.add(aClass)) return true;
processor.handleEvent(PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, aClass);
final ElementClassHint classHint = processor.getHint(ElementClassHint.KEY);
final NameHint nameHint = processor.getHint(NameHint.KEY);
if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclarationKind.FIELD)) {
if (nameHint != null) {
final PsiField fieldByName = aClass.findFieldByName(nameHint.getName(state), false);
if (fieldByName != null && !processor.execute(fieldByName, state)) return false;
} else {
final PsiField[] fields = aClass.getFields();
for (final PsiField field : fields) {
if (!processor.execute(field, state)) return false;
}
}
}
PsiElementFactory factory = JavaPsiFacade.getInstance(aClass.getProject()).getElementFactory();
if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclarationKind.METHOD)) {
PsiSubstitutor baseSubstitutor = state.get(PsiSubstitutor.KEY);
final PsiMethod[] methods =
nameHint != null
? aClass.findMethodsByName(nameHint.getName(state), false)
: aClass.getMethods();
for (final PsiMethod method : methods) {
PsiSubstitutor finalSubstitutor = checkRaw(isRaw, factory, method, baseSubstitutor);
ResolveState methodState =
finalSubstitutor == baseSubstitutor
? state
: state.put(PsiSubstitutor.KEY, finalSubstitutor);
if (!processor.execute(method, methodState)) return false;
}
}
if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclarationKind.CLASS)) {
if (last != null && last.getParent() == aClass) {
// Parameters
final PsiTypeParameterList list = aClass.getTypeParameterList();
if (list != null
&& !list.processDeclarations(processor, ResolveState.initial(), last, place))
return false;
}
if (!(last instanceof PsiReferenceList) && !(last instanceof PsiModifierList)) {
// Inners
if (nameHint != null) {
final PsiClass inner = aClass.findInnerClassByName(nameHint.getName(state), false);
if (inner != null) {
if (!processor.execute(inner, state)) return false;
}
} else {
final PsiClass[] inners = aClass.getInnerClasses();
for (final PsiClass inner : inners) {
if (!processor.execute(inner, state)) return false;
}
}
}
}
return last instanceof PsiReferenceList
|| processSuperTypes(
aClass, processor, visited, last, place, state, isRaw, factory, languageLevel);
}