@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;
}
public static boolean areParametersErasureEqual(
@NotNull PsiMethod method1, @NotNull PsiMethod method2) {
if (method1.getParameterList().getParametersCount()
!= method2.getParameterList().getParametersCount()) return false;
return areSignaturesErasureEqual(
method1.getSignature(PsiSubstitutor.EMPTY), method2.getSignature(PsiSubstitutor.EMPTY));
}
private static PsiSubstitutor calculateSubstitutor(
PsiMethod derivedMethod, PsiMethod baseMethod) {
PsiSubstitutor substitutor;
if (derivedMethod.getManager().areElementsEquivalent(derivedMethod, baseMethod)) {
substitutor = PsiSubstitutor.EMPTY;
} else {
final PsiClass baseClass = baseMethod.getContainingClass();
final PsiClass derivedClass = derivedMethod.getContainingClass();
if (baseClass != null
&& derivedClass != null
&& InheritanceUtil.isInheritorOrSelf(derivedClass, baseClass, true)) {
final PsiSubstitutor superClassSubstitutor =
TypeConversionUtil.getSuperClassSubstitutor(
baseClass, derivedClass, PsiSubstitutor.EMPTY);
final MethodSignature superMethodSignature = baseMethod.getSignature(superClassSubstitutor);
final MethodSignature methodSignature = derivedMethod.getSignature(PsiSubstitutor.EMPTY);
final PsiSubstitutor superMethodSubstitutor =
MethodSignatureUtil.getSuperMethodSignatureSubstitutor(
methodSignature, superMethodSignature);
substitutor =
superMethodSubstitutor != null ? superMethodSubstitutor : superClassSubstitutor;
} else {
substitutor = PsiSubstitutor.EMPTY;
}
}
return substitutor;
}
public static boolean isSuperMethod(
@NotNull PsiMethod superMethodCandidate, @NotNull PsiMethod derivedMethod) {
PsiClass superClassCandidate = superMethodCandidate.getContainingClass();
PsiClass derivedClass = derivedMethod.getContainingClass();
if (derivedClass == null || superClassCandidate == null) return false;
if (!derivedClass.isInheritor(superClassCandidate, true)) return false;
final PsiSubstitutor superSubstitutor =
TypeConversionUtil.getSuperClassSubstitutor(
superClassCandidate, derivedClass, PsiSubstitutor.EMPTY);
final MethodSignature superSignature = superMethodCandidate.getSignature(superSubstitutor);
final MethodSignature derivedSignature = derivedMethod.getSignature(PsiSubstitutor.EMPTY);
return isSubsignature(superSignature, derivedSignature);
}
private boolean isOverridden(
PsiClass inheritor, PsiMethod method, PsiMethod superMethod, PsiClass superInterface) {
// calculate substitutor of containingClass --> inheritor
PsiSubstitutor substitutor =
TypeConversionUtil.getSuperClassSubstitutor(
myContainingClass, inheritor, PsiSubstitutor.EMPTY);
// calculate substitutor of inheritor --> superInterface
substitutor =
TypeConversionUtil.getSuperClassSubstitutor(superInterface, inheritor, substitutor);
return MethodSignatureUtil.isSubsignature(
superMethod.getSignature(substitutor), method.getSignature(PsiSubstitutor.EMPTY));
}
@Nullable
private static PsiMethod doFindMethodInSuperClassBySignatureInDerived(
@NotNull PsiClass superClass,
@NotNull PsiSubstitutor superSubstitutor,
@NotNull MethodSignature signature,
final boolean checkDeep) {
final String name = signature.getName();
final PsiMethod[] methods = superClass.findMethodsByName(name, false);
for (final PsiMethod method : methods) {
if (isSubsignature(method.getSignature(superSubstitutor), signature)) {
return method;
}
}
if (checkDeep) {
final PsiClass clazz = superClass.getSuperClass();
if (clazz != null && clazz != superClass) {
PsiSubstitutor substitutor1 =
TypeConversionUtil.getSuperClassSubstitutor(clazz, superClass, superSubstitutor);
return doFindMethodInSuperClassBySignatureInDerived(clazz, substitutor1, signature, true);
}
}
return null;
}
@Nullable
private static MethodSignature getSignatureForInheritor(
@NotNull PsiMethod methodFromSuperClass, @NotNull GrTypeDefinition inheritor) {
final PsiClass clazz = methodFromSuperClass.getContainingClass();
if (clazz == null) return null;
PsiSubstitutor superSubstitutor =
TypeConversionUtil.getClassSubstitutor(clazz, inheritor, PsiSubstitutor.EMPTY);
if (superSubstitutor == null) return null;
return methodFromSuperClass.getSignature(superSubstitutor);
}
@Nullable
public static PsiMethod findMethodBySuperMethod(
@NotNull PsiClass aClass, @NotNull PsiMethod method, final boolean checkBases) {
List<Pair<PsiMethod, PsiSubstitutor>> pairs =
aClass.findMethodsAndTheirSubstitutorsByName(method.getName(), checkBases);
for (Pair<PsiMethod, PsiSubstitutor> pair : pairs) {
PsiMethod candidate = pair.first;
PsiSubstitutor substitutor = pair.second;
MethodSignature candidateSignature = candidate.getSignature(substitutor);
final PsiClass methodClass = method.getContainingClass();
final PsiClass candidateClass = candidate.getContainingClass();
if (methodClass == null || candidateClass == null) continue;
PsiSubstitutor superSubstitutor =
TypeConversionUtil.getClassSubstitutor(methodClass, candidateClass, substitutor);
if (superSubstitutor == null) continue;
MethodSignature superSignature = method.getSignature(superSubstitutor);
if (isSubsignature(superSignature, candidateSignature)) return candidate;
}
return null;
}
static boolean isInheritorOrSelf(PsiMethod inheritorCandidate, PsiMethod base) {
PsiClass aClass = inheritorCandidate.getContainingClass();
PsiClass bClass = base.getContainingClass();
if (aClass == null || bClass == null) return false;
PsiSubstitutor substitutor =
TypeConversionUtil.getClassSubstitutor(bClass, aClass, PsiSubstitutor.EMPTY);
return substitutor != null
&& MethodSignatureUtil.findMethodBySignature(
bClass, inheritorCandidate.getSignature(substitutor), false)
== base;
}
@Nullable
public static PsiMethod findMethodBySignature(
GrTypeDefinition grType, PsiMethod patternMethod, boolean checkBases) {
final MethodSignature patternSignature = patternMethod.getSignature(PsiSubstitutor.EMPTY);
for (PsiMethod method : findMethodsByName(grType, patternMethod.getName(), checkBases, false)) {
MethodSignature signature = getSignatureForInheritor(method, grType);
if (patternSignature.equals(signature)) return method;
}
return null;
}
@Nullable
public static PsiMethod findMethodBySignature(
@NotNull PsiClass aClass, @NotNull MethodSignature methodSignature, boolean checkBases) {
String name = methodSignature.isConstructor() ? aClass.getName() : methodSignature.getName();
List<Pair<PsiMethod, PsiSubstitutor>> pairs =
aClass.findMethodsAndTheirSubstitutorsByName(name, checkBases);
for (Pair<PsiMethod, PsiSubstitutor> pair : pairs) {
PsiMethod method = pair.first;
PsiSubstitutor substitutor = pair.second;
MethodSignature foundMethodSignature = method.getSignature(substitutor);
if (methodSignature.equals(foundMethodSignature)) return method;
}
return null;
}
// uses hierarchy signature tree if available, traverses class structure by itself otherwise
public static boolean processDirectSuperMethodsSmart(
@NotNull PsiMethod method, @NotNull Processor<PsiMethod> superMethodProcessor) {
// boolean old = PsiSuperMethodUtil.isSuperMethod(method, superMethod);
PsiClass aClass = method.getContainingClass();
if (aClass == null) return false;
if (!canHaveSuperMethod(method, true, false)) return false;
Map<MethodSignature, HierarchicalMethodSignature> cachedMap =
SIGNATURES_KEY.getCachedValueOrNull(aClass);
if (cachedMap != null) {
HierarchicalMethodSignature signature =
cachedMap.get(method.getSignature(PsiSubstitutor.EMPTY));
if (signature != null) {
List<HierarchicalMethodSignature> superSignatures = signature.getSuperSignatures();
for (HierarchicalMethodSignature superSignature : superSignatures) {
if (!superMethodProcessor.process(superSignature.getMethod())) return false;
}
return true;
}
}
PsiClassType[] directSupers = aClass.getSuperTypes();
for (PsiClassType directSuper : directSupers) {
PsiClassType.ClassResolveResult resolveResult = directSuper.resolveGenerics();
if (resolveResult.getSubstitutor() != PsiSubstitutor.EMPTY) {
// generics
break;
}
PsiClass directSuperClass = resolveResult.getElement();
if (directSuperClass == null) continue;
PsiMethod[] candidates = directSuperClass.findMethodsBySignature(method, false);
for (PsiMethod candidate : candidates) {
if (PsiUtil.canBeOverriden(candidate)) {
if (!superMethodProcessor.process(candidate)) return false;
}
}
return true;
}
List<HierarchicalMethodSignature> superSignatures =
method.getHierarchicalMethodSignature().getSuperSignatures();
for (HierarchicalMethodSignature superSignature : superSignatures) {
if (!superMethodProcessor.process(superSignature.getMethod())) return false;
}
return true;
}
private static PsiMethod[] findMethodsBySignature(
GrTypeDefinition grType,
PsiMethod patternMethod,
boolean checkBases,
boolean includeSynthetic) {
ArrayList<PsiMethod> result = new ArrayList<PsiMethod>();
final MethodSignature patternSignature = patternMethod.getSignature(PsiSubstitutor.EMPTY);
for (PsiMethod method :
findMethodsByName(grType, patternMethod.getName(), checkBases, includeSynthetic)) {
MethodSignature signature = getSignatureForInheritor(method, grType);
if (patternSignature.equals(signature)) {
result.add(method);
}
}
return result.toArray(new PsiMethod[result.size()]);
}
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));
}
}
}
public static boolean isMainOrPremainMethod(@NotNull PsiMethod method) {
if (!PsiType.VOID.equals(method.getReturnType())) return false;
String name = method.getName();
if (!("main".equals(name) || "premain".equals(name))) return false;
PsiElementFactory factory = JavaPsiFacade.getInstance(method.getProject()).getElementFactory();
MethodSignature signature = method.getSignature(PsiSubstitutor.EMPTY);
try {
MethodSignature main = createSignatureFromText(factory, "void main(String[] args);");
if (MethodSignatureUtil.areSignaturesEqual(signature, main)) return true;
MethodSignature premain =
createSignatureFromText(
factory, "void premain(String args, java.lang.instrument.Instrumentation i);");
if (MethodSignatureUtil.areSignaturesEqual(signature, premain)) return true;
} catch (IncorrectOperationException e) {
LOG.error(e);
}
return false;
}
private static void addMethodsUsages(
final PsiClass aClass,
final Processor<UsageInfo> results,
final JavaClassFindUsagesOptions options) {
if (options.isIncludeInherited) {
final PsiManager manager = aClass.getManager();
PsiMethod[] methods = aClass.getAllMethods();
MethodsLoop:
for (int i = 0; i < methods.length; i++) {
final PsiMethod method = methods[i];
// filter overriden methods
MethodSignature methodSignature = method.getSignature(PsiSubstitutor.EMPTY);
for (int j = 0; j < i; j++) {
if (methodSignature.equals(methods[j].getSignature(PsiSubstitutor.EMPTY)))
continue MethodsLoop;
}
final PsiClass methodClass = method.getContainingClass();
if (methodClass != null && manager.areElementsEquivalent(methodClass, aClass)) {
addElementUsages(methods[i], results, options);
} else {
MethodReferencesSearch.search(
new MethodReferencesSearch.SearchParameters(
method, options.searchScope, true, options.fastTrack))
.forEach(
new PsiReferenceProcessorAdapter(
new PsiReferenceProcessor() {
@Override
public boolean execute(PsiReference reference) {
addResultFromReference(
reference, methodClass, manager, aClass, results, options);
return true;
}
}));
}
}
} else {
for (PsiMethod method : aClass.getMethods()) {
addElementUsages(method, results, options);
}
}
}
/**
* Adds 'method' to 'signatures' if it doesn't yet contain any method with the same signature or
* replaces abstract methods
*/
private static void addMethodChecked(
Map<MethodSignature, PsiMethod> signatures,
PsiMethod method,
PsiSubstitutor substitutor,
@Nullable Set<PsiMethod> resultSet) {
if (method.isConstructor()) return;
if (method.hasModifierProperty(PsiModifier.STATIC)) return;
final MethodSignature signature = method.getSignature(substitutor);
final PsiMethod old = signatures.get(signature);
if (old != null) {
// if (method.hasModifierProperty(PsiModifier.ABSTRACT)) return;
if (!old.hasModifierProperty(PsiModifier.ABSTRACT)) return;
if (resultSet != null) resultSet.remove(old);
}
signatures.put(signature, method);
if (resultSet != null) resultSet.add(method);
}
private static void addGetterSetterElements(
CompletionResultSet result, PsiClass parent, Set<MethodSignature> addedSignatures) {
int count = 0;
for (PsiField field : parent.getFields()) {
if (field instanceof PsiEnumConstant) continue;
List<PsiMethod> prototypes = ContainerUtil.newSmartList();
Collections.addAll(
prototypes, GetterSetterPrototypeProvider.generateGetterSetters(field, true));
Collections.addAll(
prototypes, GetterSetterPrototypeProvider.generateGetterSetters(field, false));
for (final PsiMethod prototype : prototypes) {
if (parent.findMethodBySignature(prototype, false) == null
&& addedSignatures.add(prototype.getSignature(PsiSubstitutor.EMPTY))) {
Icon icon = prototype.getIcon(Iconable.ICON_FLAG_VISIBILITY);
result.addElement(
createGenerateMethodElement(
prototype,
PsiSubstitutor.EMPTY,
icon,
"",
new InsertHandler<LookupElement>() {
@Override
public void handleInsert(InsertionContext context, LookupElement item) {
removeLookupString(context);
insertGenerationInfos(
context,
Collections.singletonList(new PsiGenerationInfo<PsiMethod>(prototype)));
}
}));
if (count++ > 100) return;
}
}
}
}
protected void checkSameSignatures(@NotNull List<CandidateInfo> conflicts) {
// candidates should go in order of class hierarchy traversal
// in order for this to work
Map<MethodSignature, CandidateInfo> signatures =
new THashMap<MethodSignature, CandidateInfo>(conflicts.size());
Set<PsiMethod> superMethods = new HashSet<PsiMethod>();
for (CandidateInfo conflict : conflicts) {
final PsiMethod method = ((MethodCandidateInfo) conflict).getElement();
for (HierarchicalMethodSignature methodSignature :
method.getHierarchicalMethodSignature().getSuperSignatures()) {
final PsiMethod superMethod = methodSignature.getMethod();
final PsiClass aClass = superMethod.getContainingClass();
if (aClass != null
&& !CommonClassNames.JAVA_LANG_OBJECT.equals(aClass.getQualifiedName())) {
superMethods.add(superMethod);
}
}
}
nextConflict:
for (int i = 0; i < conflicts.size(); i++) {
ProgressManager.checkCanceled();
CandidateInfo info = conflicts.get(i);
PsiMethod method = (PsiMethod) info.getElement();
if (!method.hasModifierProperty(PsiModifier.STATIC) && superMethods.contains(method)) {
conflicts.remove(i);
i--;
continue;
}
PsiClass class1 = method.getContainingClass();
PsiSubstitutor infoSubstitutor = ((MethodCandidateInfo) info).getSubstitutor(false);
MethodSignature signature = method.getSignature(infoSubstitutor);
CandidateInfo existing = signatures.get(signature);
if (existing == null) {
signatures.put(signature, info);
continue;
}
PsiMethod existingMethod = (PsiMethod) existing.getElement();
PsiClass existingClass = existingMethod.getContainingClass();
if (class1 != null
&& existingClass != null) { // prefer interface methods to methods from Object
if (class1.isInterface()
&& CommonClassNames.JAVA_LANG_OBJECT.equals(existingClass.getQualifiedName())) {
signatures.put(signature, info);
continue;
} else if (existingClass.isInterface()
&& CommonClassNames.JAVA_LANG_OBJECT.equals(class1.getQualifiedName())) {
conflicts.remove(info);
i--;
continue;
}
}
if (method == existingMethod) {
PsiElement scope1 = info.getCurrentFileResolveScope();
PsiElement scope2 = existing.getCurrentFileResolveScope();
if (scope1 instanceof PsiClass
&& scope2 instanceof PsiClass
&& PsiTreeUtil.isAncestor(scope1, scope2, true)
&& !existing
.isAccessible()) { // prefer methods from outer class to inaccessible base class
// methods
signatures.put(signature, info);
continue;
}
}
// filter out methods with incorrect inferred bounds (for unrelated methods only)
boolean existingTypeParamAgree = areTypeParametersAgree(existing);
boolean infoTypeParamAgree = areTypeParametersAgree(info);
if (existingTypeParamAgree
&& !infoTypeParamAgree
&& !PsiSuperMethodImplUtil.isSuperMethodSmart(method, existingMethod)) {
conflicts.remove(i);
i--;
continue;
}
if (!existingTypeParamAgree
&& infoTypeParamAgree
&& !PsiSuperMethodImplUtil.isSuperMethodSmart(existingMethod, method)) {
signatures.put(signature, info);
int index = conflicts.indexOf(existing);
conflicts.remove(index);
i--;
continue;
}
if (InheritanceUtil.isInheritorOrSelf(class1, existingClass, true)
|| InheritanceUtil.isInheritorOrSelf(existingClass, class1, true)) {
PsiParameter[] parameters = method.getParameterList().getParameters();
final PsiParameter[] existingParameters = existingMethod.getParameterList().getParameters();
for (int i1 = 0, parametersLength = parameters.length; i1 < parametersLength; i1++) {
if (parameters[i1].getType() instanceof PsiArrayType
&& !(existingParameters[i1].getType()
instanceof PsiArrayType)) { // prefer more specific type
signatures.put(signature, info);
continue nextConflict;
}
}
PsiType returnType1 = method.getReturnType();
PsiType returnType2 = existingMethod.getReturnType();
if (returnType1 != null && returnType2 != null) {
returnType1 = infoSubstitutor.substitute(returnType1);
returnType2 =
((MethodCandidateInfo) existing).getSubstitutor(false).substitute(returnType2);
if (!returnType1.equals(returnType2) && returnType1.isAssignableFrom(returnType2)) {
conflicts.remove(i);
i--;
continue;
}
}
// prefer derived class
signatures.put(signature, info);
} else {
final PsiMethodCallExpression methodCallExpression =
PsiTreeUtil.getParentOfType(myArgumentsList, PsiMethodCallExpression.class);
if (methodCallExpression != null) {
final PsiReferenceExpression expression = methodCallExpression.getMethodExpression();
final PsiExpression qualifierExpression = expression.getQualifierExpression();
PsiClass currentClass;
if (qualifierExpression != null) {
currentClass = PsiUtil.resolveClassInClassTypeOnly(qualifierExpression.getType());
} else {
currentClass = PsiTreeUtil.getParentOfType(expression, PsiClass.class);
}
if (currentClass != null && existingClass != null && class1 != null) {
final PsiSubstitutor eSubstitutor =
TypeConversionUtil.getMaybeSuperClassSubstitutor(
existingClass, currentClass, PsiSubstitutor.EMPTY, null);
final PsiSubstitutor cSubstitutor =
TypeConversionUtil.getMaybeSuperClassSubstitutor(
class1, currentClass, PsiSubstitutor.EMPTY, null);
if (eSubstitutor != null
&& cSubstitutor != null
&& MethodSignatureUtil.areSignaturesEqual(
existingMethod.getSignature(eSubstitutor), method.getSignature(cSubstitutor))) {
final PsiType returnType = eSubstitutor.substitute(existingMethod.getReturnType());
final PsiType returnType1 = cSubstitutor.substitute(method.getReturnType());
if (returnType != null && returnType1 != null && !returnType1.equals(returnType)) {
if (TypeConversionUtil.isAssignable(returnType, returnType1, false)) {
if (class1.isInterface() && !existingClass.isInterface()) continue;
conflicts.remove(existing);
} else {
if (!TypeConversionUtil.isAssignable(returnType1, returnType, false)) continue;
conflicts.remove(i);
}
i--;
break;
}
}
}
}
}
}
}
@Nullable
public static String getSuspiciousMethodCallMessage(
@NotNull PsiMethodCallExpression methodCall,
PsiType argType,
boolean reportConvertibleMethodCalls,
@NotNull List<PsiMethod> patternMethods,
@NotNull IntArrayList indices) {
final PsiReferenceExpression methodExpression = methodCall.getMethodExpression();
final PsiExpression qualifier = methodExpression.getQualifierExpression();
if (qualifier == null
|| qualifier instanceof PsiThisExpression
|| qualifier instanceof PsiSuperExpression) return null;
if (argType instanceof PsiPrimitiveType) {
argType = ((PsiPrimitiveType) argType).getBoxedType(methodCall);
}
if (!(argType instanceof PsiClassType)) return null;
final JavaResolveResult resolveResult = methodExpression.advancedResolve(false);
PsiMethod calleeMethod = (PsiMethod) resolveResult.getElement();
if (calleeMethod == null) return null;
PsiMethod contextMethod = PsiTreeUtil.getParentOfType(methodCall, PsiMethod.class);
//noinspection SynchronizationOnLocalVariableOrMethodParameter
synchronized (patternMethods) {
if (patternMethods.isEmpty()) {
setupPatternMethods(
methodCall.getManager(), methodCall.getResolveScope(), patternMethods, indices);
}
}
for (int i = 0; i < patternMethods.size(); i++) {
PsiMethod patternMethod = patternMethods.get(i);
if (!patternMethod.getName().equals(methodExpression.getReferenceName())) continue;
int index = indices.get(i);
// we are in collections method implementation
if (contextMethod != null && isInheritorOrSelf(contextMethod, patternMethod)) return null;
final PsiClass calleeClass = calleeMethod.getContainingClass();
PsiSubstitutor substitutor = resolveResult.getSubstitutor();
final PsiClass patternClass = patternMethod.getContainingClass();
assert patternClass != null;
assert calleeClass != null;
substitutor = TypeConversionUtil.getClassSubstitutor(patternClass, calleeClass, substitutor);
if (substitutor == null) continue;
if (!patternMethod
.getSignature(substitutor)
.equals(calleeMethod.getSignature(PsiSubstitutor.EMPTY))) continue;
PsiTypeParameter[] typeParameters = patternClass.getTypeParameters();
if (typeParameters.length <= index) return null;
final PsiTypeParameter typeParameter = typeParameters[index];
PsiType typeParamMapping = substitutor.substitute(typeParameter);
if (typeParamMapping == null) return null;
PsiParameter[] parameters = patternMethod.getParameterList().getParameters();
if (parameters.length == 1 && "removeAll".equals(patternMethod.getName())) {
PsiType paramType = parameters[0].getType();
if (InheritanceUtil.isInheritor(paramType, CommonClassNames.JAVA_UTIL_COLLECTION)) {
PsiType qualifierType = qualifier.getType();
if (qualifierType != null) {
final PsiType itemType =
JavaGenericsUtil.getCollectionItemType(argType, calleeMethod.getResolveScope());
final PsiType qualifierItemType =
JavaGenericsUtil.getCollectionItemType(
qualifierType, calleeMethod.getResolveScope());
if (qualifierItemType != null
&& itemType != null
&& !qualifierItemType.isAssignableFrom(itemType)) {
return InspectionsBundle.message(
"inspection.suspicious.collections.method.calls.problem.descriptor",
PsiFormatUtil.formatType(qualifierType, 0, PsiSubstitutor.EMPTY),
PsiFormatUtil.formatType(itemType, 0, PsiSubstitutor.EMPTY));
}
}
return null;
}
}
String message = null;
if (typeParamMapping instanceof PsiCapturedWildcardType) {
typeParamMapping = ((PsiCapturedWildcardType) typeParamMapping).getWildcard();
}
if (!typeParamMapping.isAssignableFrom(argType)) {
if (typeParamMapping.isConvertibleFrom(argType)) {
if (reportConvertibleMethodCalls) {
message =
InspectionsBundle.message(
"inspection.suspicious.collections.method.calls.problem.descriptor1",
PsiFormatUtil.formatMethod(
calleeMethod,
substitutor,
PsiFormatUtilBase.SHOW_NAME | PsiFormatUtilBase.SHOW_CONTAINING_CLASS,
PsiFormatUtilBase.SHOW_TYPE));
}
} else {
PsiType qualifierType = qualifier.getType();
if (qualifierType != null) {
message =
InspectionsBundle.message(
"inspection.suspicious.collections.method.calls.problem.descriptor",
PsiFormatUtil.formatType(qualifierType, 0, PsiSubstitutor.EMPTY),
PsiFormatUtil.formatType(argType, 0, PsiSubstitutor.EMPTY));
}
}
}
return message;
}
return null;
}
private void doMoveMethod(PsiSubstitutor substitutor, GrMemberInfo info) {
GroovyPsiElementFactory elementFactory = GroovyPsiElementFactory.getInstance(myProject);
GrMethod method = (GrMethod) info.getMember();
PsiMethod sibling = method;
PsiMethod anchor = null;
while (sibling != null) {
sibling = PsiTreeUtil.getNextSiblingOfType(sibling, PsiMethod.class);
if (sibling != null) {
anchor =
MethodSignatureUtil.findMethodInSuperClassBySignatureInDerived(
method.getContainingClass(),
myTargetSuperClass,
sibling.getSignature(PsiSubstitutor.EMPTY),
false);
if (anchor != null) {
break;
}
}
}
GrMethod methodCopy = (GrMethod) method.copy();
if (method.findSuperMethods(myTargetSuperClass).length == 0) {
deleteOverrideAnnotationIfFound(methodCopy);
}
final boolean isOriginalMethodAbstract =
method.hasModifierProperty(PsiModifier.ABSTRACT)
|| method.hasModifierProperty(PsiModifier.DEFAULT);
if (myTargetSuperClass.isInterface() || info.isToAbstract()) {
GroovyChangeContextUtil.clearContextInfo(method);
RefactoringUtil.makeMethodAbstract(myTargetSuperClass, methodCopy);
if (myTargetSuperClass.isInterface()) {
PsiUtil.setModifierProperty(methodCopy, PsiModifier.ABSTRACT, false);
}
replaceMovedMemberTypeParameters(
methodCopy, PsiUtil.typeParametersIterable(mySourceClass), substitutor, elementFactory);
final GrMethod movedElement =
anchor != null
? (GrMethod) myTargetSuperClass.addBefore(methodCopy, anchor)
: (GrMethod) myTargetSuperClass.add(methodCopy);
CodeStyleSettings styleSettings = CodeStyleSettingsManager.getSettings(method.getProject());
if (styleSettings.INSERT_OVERRIDE_ANNOTATION) {
if (PsiUtil.isLanguageLevel5OrHigher(mySourceClass) && !myTargetSuperClass.isInterface()
|| PsiUtil.isLanguageLevel6OrHigher(mySourceClass)) {
new AddAnnotationFix(CommonClassNames.JAVA_LANG_OVERRIDE, method)
.invoke(method.getProject(), null, mySourceClass.getContainingFile());
}
}
GrDocComment oldDoc = method.getDocComment();
if (oldDoc != null) {
GrDocCommentUtil.setDocComment(movedElement, oldDoc);
}
myDocCommentPolicy.processCopiedJavaDoc(
methodCopy.getDocComment(), oldDoc, isOriginalMethodAbstract);
myMembersAfterMove.add(movedElement);
if (isOriginalMethodAbstract) {
deleteMemberWithDocComment(method);
}
} else {
if (isOriginalMethodAbstract) {
PsiUtil.setModifierProperty(myTargetSuperClass, PsiModifier.ABSTRACT, true);
}
// fixReferencesToStatic(methodCopy, movedMembers);
replaceMovedMemberTypeParameters(
methodCopy, PsiUtil.typeParametersIterable(mySourceClass), substitutor, elementFactory);
final PsiMethod superClassMethod =
myTargetSuperClass.findMethodBySignature(methodCopy, false);
final GrMethod movedElement;
if (superClassMethod != null && superClassMethod.hasModifierProperty(PsiModifier.ABSTRACT)) {
movedElement = (GrMethod) superClassMethod.replace(methodCopy);
} else {
movedElement =
anchor != null
? (GrMethod) myTargetSuperClass.addBefore(methodCopy, anchor)
: (GrMethod) myTargetSuperClass.add(methodCopy);
myMembersAfterMove.add(movedElement);
}
GrDocCommentUtil.setDocComment(movedElement, method.getDocComment());
deleteMemberWithDocComment(method);
}
}
@NotNull
private static LookupElement castQualifier(
@NotNull LookupElement item,
@Nullable final PsiTypeLookupItem castTypeItem,
@Nullable PsiType plainQualifier,
JavaCompletionProcessor processor) {
if (castTypeItem == null) {
return item;
}
if (plainQualifier != null) {
Object o = item.getObject();
if (o instanceof PsiMethod) {
PsiType castType = castTypeItem.getType();
if (plainQualifier instanceof PsiClassType && castType instanceof PsiClassType) {
PsiMethod method = (PsiMethod) o;
PsiClassType.ClassResolveResult plainResult =
((PsiClassType) plainQualifier).resolveGenerics();
PsiClass plainClass = plainResult.getElement();
if (plainClass != null && plainClass.findMethodBySignature(method, true) != null) {
PsiClass castClass = ((PsiClassType) castType).resolveGenerics().getElement();
if (castClass == null || !castClass.isInheritor(plainClass, true)) {
return item;
}
PsiSubstitutor plainSub = plainResult.getSubstitutor();
PsiSubstitutor castSub =
TypeConversionUtil.getSuperClassSubstitutor(plainClass, (PsiClassType) castType);
PsiType returnType = method.getReturnType();
if (method.getSignature(plainSub).equals(method.getSignature(castSub))) {
PsiType typeAfterCast = toRaw(castSub.substitute(returnType));
PsiType typeDeclared = toRaw(plainSub.substitute(returnType));
if (typeAfterCast != null
&& typeDeclared != null
&& typeAfterCast.isAssignableFrom(typeDeclared)
&& processor.isAccessible(plainClass.findMethodBySignature(method, true))) {
return item;
}
}
}
}
} else if (containsMember(plainQualifier, o)) {
return item;
}
}
return LookupElementDecorator.withInsertHandler(
item,
new InsertHandlerDecorator<LookupElement>() {
@Override
public void handleInsert(
InsertionContext context, LookupElementDecorator<LookupElement> item) {
final Document document = context.getEditor().getDocument();
context.commitDocument();
final PsiFile file = context.getFile();
final PsiJavaCodeReferenceElement ref =
PsiTreeUtil.findElementOfClassAtOffset(
file, context.getStartOffset(), PsiJavaCodeReferenceElement.class, false);
if (ref != null) {
final PsiElement qualifier = ref.getQualifier();
if (qualifier != null) {
final CommonCodeStyleSettings settings = context.getCodeStyleSettings();
final String parenSpace = settings.SPACE_WITHIN_PARENTHESES ? " " : "";
document.insertString(qualifier.getTextRange().getEndOffset(), parenSpace + ")");
final String spaceWithin = settings.SPACE_WITHIN_CAST_PARENTHESES ? " " : "";
final String prefix = "(" + parenSpace + "(" + spaceWithin;
final String spaceAfter = settings.SPACE_AFTER_TYPE_CAST ? " " : "";
final int exprStart = qualifier.getTextRange().getStartOffset();
document.insertString(exprStart, prefix + spaceWithin + ")" + spaceAfter);
CompletionUtil.emulateInsertion(context, exprStart + prefix.length(), castTypeItem);
PsiDocumentManager.getInstance(file.getProject())
.doPostponedOperationsAndUnblockDocument(document);
context.getEditor().getCaretModel().moveToOffset(context.getTailOffset());
}
}
item.getDelegate().handleInsert(context);
}
});
}
// uses hierarchy signature tree if available, traverses class structure by itself otherwise
public static boolean isSuperMethodSmart(
@NotNull PsiMethod method, @NotNull PsiMethod superMethod) {
// boolean old = PsiSuperMethodUtil.isSuperMethod(method, superMethod);
if (method == superMethod) return false;
PsiClass aClass = method.getContainingClass();
PsiClass superClass = superMethod.getContainingClass();
if (aClass == null || superClass == null || superClass == aClass) return false;
if (!canHaveSuperMethod(method, true, false)) return false;
PsiMethod[] superMethods = null;
Map<MethodSignature, HierarchicalMethodSignature> cachedMap =
SIGNATURES_KEY.getCachedValueOrNull(aClass);
if (cachedMap != null) {
HierarchicalMethodSignature signature =
cachedMap.get(method.getSignature(PsiSubstitutor.EMPTY));
if (signature != null) {
superMethods =
MethodSignatureUtil.convertMethodSignaturesToMethods(signature.getSuperSignatures());
}
}
if (superMethods == null) {
PsiClassType[] directSupers = aClass.getSuperTypes();
List<PsiMethod> found = null;
boolean canceled = false;
for (PsiClassType directSuper : directSupers) {
PsiClassType.ClassResolveResult resolveResult = directSuper.resolveGenerics();
if (resolveResult.getSubstitutor() != PsiSubstitutor.EMPTY) {
// generics
canceled = true;
break;
}
PsiClass directSuperClass = resolveResult.getElement();
if (directSuperClass == null) continue;
PsiMethod[] candidates = directSuperClass.findMethodsBySignature(method, false);
if (candidates.length != 0) {
if (found == null) found = new ArrayList<PsiMethod>();
for (PsiMethod candidate : candidates) {
if (PsiUtil.canBeOverriden(candidate)) found.add(candidate);
}
}
}
superMethods =
canceled
? null
: found == null ? PsiMethod.EMPTY_ARRAY : found.toArray(new PsiMethod[found.size()]);
}
if (superMethods == null) {
superMethods =
MethodSignatureUtil.convertMethodSignaturesToMethods(
method.getHierarchicalMethodSignature().getSuperSignatures());
}
for (PsiMethod superCandidate : superMethods) {
if (superMethod.equals(superCandidate) || isSuperMethodSmart(superCandidate, superMethod))
return true;
}
return false;
}
private Specifics isMoreSpecific(
@NotNull MethodCandidateInfo info1,
@NotNull MethodCandidateInfo info2,
@MethodCandidateInfo.ApplicabilityLevelConstant int applicabilityLevel,
@NotNull LanguageLevel languageLevel) {
PsiMethod method1 = info1.getElement();
PsiMethod method2 = info2.getElement();
final PsiClass class1 = method1.getContainingClass();
final PsiClass class2 = method2.getContainingClass();
final PsiParameter[] params1 = method1.getParameterList().getParameters();
final PsiParameter[] params2 = method2.getParameterList().getParameters();
final PsiTypeParameter[] typeParameters1 = method1.getTypeParameters();
final PsiTypeParameter[] typeParameters2 = method2.getTypeParameters();
final PsiSubstitutor classSubstitutor1 =
info1.getSubstitutor(false); // substitutions for method type parameters will be ignored
final PsiSubstitutor classSubstitutor2 = info2.getSubstitutor(false);
final int max = Math.max(params1.length, params2.length);
PsiType[] types1 = PsiType.createArray(max);
PsiType[] types2 = PsiType.createArray(max);
final boolean varargsPosition =
applicabilityLevel == MethodCandidateInfo.ApplicabilityLevel.VARARGS;
for (int i = 0; i < max; i++) {
ProgressManager.checkCanceled();
PsiType type1 =
params1.length > 0 ? params1[Math.min(i, params1.length - 1)].getType() : null;
PsiType type2 =
params2.length > 0 ? params2[Math.min(i, params2.length - 1)].getType() : null;
if (varargsPosition) {
if (type1 instanceof PsiEllipsisType
&& type2 instanceof PsiEllipsisType
&& params1.length == params2.length
&& class1 != null
&& (!JavaVersionService.getInstance().isAtLeast(class1, JavaSdkVersion.JDK_1_7)
|| ((PsiArrayType) type1)
.getComponentType()
.equalsToText(CommonClassNames.JAVA_LANG_OBJECT)
|| ((PsiArrayType) type2)
.getComponentType()
.equalsToText(CommonClassNames.JAVA_LANG_OBJECT))) {
type1 = ((PsiEllipsisType) type1).toArrayType();
type2 = ((PsiEllipsisType) type2).toArrayType();
} else {
type1 =
type1 instanceof PsiEllipsisType ? ((PsiArrayType) type1).getComponentType() : type1;
type2 =
type2 instanceof PsiEllipsisType ? ((PsiArrayType) type2).getComponentType() : type2;
}
}
types1[i] = type1;
types2[i] = type2;
}
boolean sameBoxing = true;
int[] boxingHappened = new int[2];
for (int i = 0; i < types1.length; i++) {
ProgressManager.checkCanceled();
PsiType type1 = classSubstitutor1.substitute(types1[i]);
PsiType type2 = classSubstitutor2.substitute(types2[i]);
PsiType argType = i < getActualParameterTypes().length ? getActualParameterTypes()[i] : null;
boolean boxingInFirst = false;
if (isBoxingHappened(argType, type1, languageLevel)) {
boxingHappened[0] += 1;
boxingInFirst = true;
}
boolean boxingInSecond = false;
if (isBoxingHappened(argType, type2, languageLevel)) {
boxingHappened[1] += 1;
boxingInSecond = true;
}
sameBoxing &= boxingInFirst == boxingInSecond;
}
if (boxingHappened[0] == 0 && boxingHappened[1] > 0) return Specifics.FIRST;
if (boxingHappened[0] > 0 && boxingHappened[1] == 0) return Specifics.SECOND;
if (sameBoxing) {
final PsiSubstitutor siteSubstitutor1 = info1.getSiteSubstitutor();
final PsiSubstitutor siteSubstitutor2 = info2.getSiteSubstitutor();
final PsiType[] types2AtSite = typesAtSite(types2, siteSubstitutor2);
final PsiType[] types1AtSite = typesAtSite(types1, siteSubstitutor1);
final PsiSubstitutor methodSubstitutor1 =
calculateMethodSubstitutor(
typeParameters1, method1, siteSubstitutor1, types1, types2AtSite, languageLevel);
boolean applicable12 =
isApplicableTo(
types2AtSite, method1, languageLevel, varargsPosition, methodSubstitutor1, method2);
final PsiSubstitutor methodSubstitutor2 =
calculateMethodSubstitutor(
typeParameters2, method2, siteSubstitutor2, types2, types1AtSite, languageLevel);
boolean applicable21 =
isApplicableTo(
types1AtSite, method2, languageLevel, varargsPosition, methodSubstitutor2, method1);
if (!myLanguageLevel.isAtLeast(LanguageLevel.JDK_1_8)) {
final boolean typeArgsApplicable12 =
GenericsUtil.isTypeArgumentsApplicable(
typeParameters1, methodSubstitutor1, myArgumentsList, !applicable21);
final boolean typeArgsApplicable21 =
GenericsUtil.isTypeArgumentsApplicable(
typeParameters2, methodSubstitutor2, myArgumentsList, !applicable12);
if (!typeArgsApplicable12) {
applicable12 = false;
}
if (!typeArgsApplicable21) {
applicable21 = false;
}
}
if (applicable12 || applicable21) {
if (applicable12 && !applicable21) return Specifics.SECOND;
if (applicable21 && !applicable12) return Specifics.FIRST;
final boolean abstract1 = method1.hasModifierProperty(PsiModifier.ABSTRACT);
final boolean abstract2 = method2.hasModifierProperty(PsiModifier.ABSTRACT);
if (abstract1 && !abstract2) {
return Specifics.SECOND;
}
if (abstract2 && !abstract1) {
return Specifics.FIRST;
}
}
if (languageLevel.isAtLeast(LanguageLevel.JDK_1_8)
&& myArgumentsList instanceof PsiExpressionList
&& (typeParameters1.length == 0 || typeParameters2.length == 0)) {
boolean toCompareFunctional = false;
if (types1.length > 0 && types2.length > 0) {
for (int i = 0; i < getActualParametersLength(); i++) {
final PsiType type1 = types1[Math.min(i, types1.length - 1)];
final PsiType type2 = types2[Math.min(i, types2.length - 1)];
// from 15.12.2.5 Choosing the Most Specific Method
// In addition, a functional interface type S is more specific than a functional
// interface type T for an expression exp
// if T is not a subtype of S and one of the following conditions apply.
if (LambdaUtil.isFunctionalType(type1)
&& !TypeConversionUtil.erasure(type1).isAssignableFrom(type2)
&& LambdaUtil.isFunctionalType(type2)
&& !TypeConversionUtil.erasure(type2).isAssignableFrom(type1)) {
types1AtSite[Math.min(i, types1.length - 1)] = PsiType.NULL;
types2AtSite[Math.min(i, types2.length - 1)] = PsiType.NULL;
toCompareFunctional = true;
}
}
}
if (toCompareFunctional) {
final boolean applicable12ignoreFunctionalType =
isApplicableTo(
types2AtSite,
method1,
languageLevel,
varargsPosition,
calculateMethodSubstitutor(
typeParameters1,
method1,
siteSubstitutor1,
types1,
types2AtSite,
languageLevel),
null);
final boolean applicable21ignoreFunctionalType =
isApplicableTo(
types1AtSite,
method2,
languageLevel,
varargsPosition,
calculateMethodSubstitutor(
typeParameters2,
method2,
siteSubstitutor2,
types2,
types1AtSite,
languageLevel),
null);
if (applicable12ignoreFunctionalType || applicable21ignoreFunctionalType) {
Specifics specifics = null;
for (int i = 0; i < getActualParametersLength(); i++) {
if (types1AtSite[Math.min(i, types1.length - 1)] == PsiType.NULL
&& types2AtSite[Math.min(i, types2.length - 1)] == PsiType.NULL) {
Specifics specific =
isFunctionalTypeMoreSpecific(
info1, info2, ((PsiExpressionList) myArgumentsList).getExpressions()[i], i);
if (specific == Specifics.NEITHER) {
specifics = Specifics.NEITHER;
break;
}
if (specifics == null) {
specifics = specific;
} else if (specifics != specific) {
specifics = Specifics.NEITHER;
break;
}
}
}
if (!applicable12ignoreFunctionalType && applicable21ignoreFunctionalType) {
return specifics == Specifics.FIRST ? Specifics.FIRST : Specifics.NEITHER;
}
if (!applicable21ignoreFunctionalType && applicable12ignoreFunctionalType) {
return specifics == Specifics.SECOND ? Specifics.SECOND : Specifics.NEITHER;
}
return specifics;
}
}
}
} else if (varargsPosition) {
final PsiType lastParamType1 = classSubstitutor1.substitute(types1[types1.length - 1]);
final PsiType lastParamType2 = classSubstitutor2.substitute(types2[types1.length - 1]);
final boolean assignable1 = TypeConversionUtil.isAssignable(lastParamType2, lastParamType1);
final boolean assignable2 = TypeConversionUtil.isAssignable(lastParamType1, lastParamType2);
if (assignable1 && !assignable2) {
return Specifics.FIRST;
}
if (assignable2 && !assignable1) {
return Specifics.SECOND;
}
}
if (class1 != class2) {
if (class2.isInheritor(class1, true) || class1.isInterface() && !class2.isInterface()) {
if (MethodSignatureUtil.isSubsignature(
method1.getSignature(info1.getSubstitutor(false)),
method2.getSignature(info2.getSubstitutor(false)))) {
return Specifics.SECOND;
} else if (method1.hasModifierProperty(PsiModifier.STATIC)
&& method2.hasModifierProperty(PsiModifier.STATIC)
&& boxingHappened[0] == 0) {
return Specifics.SECOND;
}
} else if (MethodSignatureUtil.areErasedParametersEqual(
method1.getSignature(PsiSubstitutor.EMPTY),
method2.getSignature(PsiSubstitutor.EMPTY))
&& MethodSignatureUtil.isSubsignature(
method2.getSignature(info2.getSubstitutor(false)),
method1.getSignature(info1.getSubstitutor(false)))) {
return Specifics.FIRST;
} else if (class1.isInheritor(class2, true) || class2.isInterface()) {
if (method1.hasModifierProperty(PsiModifier.STATIC)
&& method2.hasModifierProperty(PsiModifier.STATIC)
&& boxingHappened[0] == 0) {
return Specifics.FIRST;
}
}
}
final boolean raw1 = PsiUtil.isRawSubstitutor(method1, classSubstitutor1);
final boolean raw2 = PsiUtil.isRawSubstitutor(method2, classSubstitutor2);
if (raw1 ^ raw2) {
return raw1 ? Specifics.SECOND : Specifics.FIRST;
}
final boolean varargs1 = info1.isVarargs();
final boolean varargs2 = info2.isVarargs();
if (varargs1 ^ varargs2) {
return varargs1 ? Specifics.SECOND : Specifics.FIRST;
}
return Specifics.NEITHER;
}
public static boolean areSignaturesEqual(@NotNull PsiMethod method1, @NotNull PsiMethod method2) {
return method1
.getSignature(PsiSubstitutor.EMPTY)
.equals(method2.getSignature(PsiSubstitutor.EMPTY));
}
private void doMoveMethod(PsiSubstitutor substitutor, MemberInfo info) {
PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(myProject);
PsiMethod method = (PsiMethod) info.getMember();
PsiMethod sibling = method;
PsiMethod anchor = null;
while (sibling != null) {
sibling = PsiTreeUtil.getNextSiblingOfType(sibling, PsiMethod.class);
if (sibling != null) {
anchor =
MethodSignatureUtil.findMethodInSuperClassBySignatureInDerived(
method.getContainingClass(),
myTargetSuperClass,
sibling.getSignature(PsiSubstitutor.EMPTY),
false);
if (anchor != null) {
break;
}
}
}
PsiMethod methodCopy = (PsiMethod) method.copy();
Language language = myTargetSuperClass.getLanguage();
final PsiMethod superClassMethod = myTargetSuperClass.findMethodBySignature(methodCopy, false);
if (superClassMethod != null && superClassMethod.findDeepestSuperMethods().length == 0
|| method.findSuperMethods(myTargetSuperClass).length == 0) {
deleteOverrideAnnotationIfFound(methodCopy);
}
boolean isOriginalMethodAbstract =
method.hasModifierProperty(PsiModifier.ABSTRACT)
|| method.hasModifierProperty(PsiModifier.DEFAULT);
boolean isOriginalMethodPrototype =
method instanceof HaxeFunctionPrototypeDeclarationWithAttributes;
if (myIsTargetInterface || info.isToAbstract()) {
ChangeContextUtil.clearContextInfo(method);
if (!info.isToAbstract()
&& !method.hasModifierProperty(PsiModifier.ABSTRACT)
&& PsiUtil.isLanguageLevel8OrHigher(myTargetSuperClass)) {
// pull as default
RefactoringUtil.makeMethodDefault(methodCopy);
isOriginalMethodAbstract = true;
} else {
RefactoringUtil.makeMethodAbstract(myTargetSuperClass, methodCopy);
}
RefactoringUtil.replaceMovedMemberTypeParameters(
methodCopy, PsiUtil.typeParametersIterable(mySourceClass), substitutor, elementFactory);
myJavaDocPolicy.processCopiedJavaDoc(
methodCopy.getDocComment(), method.getDocComment(), isOriginalMethodAbstract);
final PsiMember movedElement;
if (superClassMethod != null && superClassMethod.hasModifierProperty(PsiModifier.ABSTRACT)) {
movedElement =
(PsiMember) superClassMethod.replace(convertMethodToLanguage(methodCopy, language));
} else {
methodCopy =
HaxeElementGenerator.createFunctionPrototypeDeclarationWithAttributes(
myProject, methodCopy.getText().trim() + ";");
movedElement =
anchor != null
? (PsiMember) myTargetSuperClass.addBefore(methodCopy, anchor)
: (PsiMember)
myTargetSuperClass.addBefore(methodCopy, myTargetSuperClass.getRBrace());
reformat(movedElement);
}
CodeStyleSettings styleSettings = CodeStyleSettingsManager.getSettings(method.getProject());
if (styleSettings.INSERT_OVERRIDE_ANNOTATION) {
if (PsiUtil.isLanguageLevel5OrHigher(mySourceClass) && !myIsTargetInterface
|| PsiUtil.isLanguageLevel6OrHigher(mySourceClass)) {
new AddAnnotationFix(Override.class.getName(), method)
.invoke(method.getProject(), null, mySourceClass.getContainingFile());
}
}
if (!PsiUtil.isLanguageLevel6OrHigher(mySourceClass) && myIsTargetInterface) {
if (isOriginalMethodAbstract) {
for (PsiMethod oMethod : OverridingMethodsSearch.search(method)) {
deleteOverrideAnnotationIfFound(oMethod);
}
}
deleteOverrideAnnotationIfFound(method);
}
myMembersAfterMove.add(movedElement);
// if (isOriginalMethodAbstract) {
method.delete();
// }
} else {
if (isOriginalMethodAbstract) {
PsiUtil.setModifierProperty(myTargetSuperClass, PsiModifier.ABSTRACT, true);
}
RefactoringUtil.replaceMovedMemberTypeParameters(
methodCopy, PsiUtil.typeParametersIterable(mySourceClass), substitutor, elementFactory);
fixReferencesToStatic(methodCopy);
if (superClassMethod != null && superClassMethod.hasModifierProperty(PsiModifier.ABSTRACT)) {
superClassMethod.replace(convertMethodToLanguage(methodCopy, language));
} else {
final PsiMember movedElement =
anchor != null
? (PsiMember)
myTargetSuperClass.addBefore(
convertMethodToLanguage(methodCopy, language), anchor)
: (PsiMember)
myTargetSuperClass.addBefore(
convertMethodToLanguage(methodCopy, language),
myTargetSuperClass.getRBrace());
reformat(movedElement);
myMembersAfterMove.add(movedElement);
}
method.delete();
}
}
@Nullable
public static PsiMethod findMethodBySignature(
@NotNull PsiClass aClass, @NotNull PsiMethod pattenMethod, boolean checkBases) {
return findMethodBySignature(
aClass, pattenMethod.getSignature(PsiSubstitutor.EMPTY), checkBases);
}
