private static void findTypeParameterExternalUsages(
final PsiTypeParameter typeParameter, final Collection<UsageInfo> usages) {
PsiTypeParameterListOwner owner = typeParameter.getOwner();
if (owner != null) {
final PsiTypeParameterList parameterList = owner.getTypeParameterList();
if (parameterList != null) {
final int paramsCount = parameterList.getTypeParameters().length;
final int index = parameterList.getTypeParameterIndex(typeParameter);
ReferencesSearch.search(owner)
.forEach(
reference -> {
if (reference instanceof PsiJavaCodeReferenceElement) {
final PsiReferenceParameterList parameterList1 =
((PsiJavaCodeReferenceElement) reference).getParameterList();
if (parameterList1 != null) {
PsiTypeElement[] typeArgs = parameterList1.getTypeParameterElements();
if (typeArgs.length > index) {
if (typeArgs.length == 1
&& paramsCount > 1
&& typeArgs[0].getType() instanceof PsiDiamondType) return true;
usages.add(
new SafeDeleteReferenceJavaDeleteUsageInfo(
typeArgs[index], typeParameter, true));
}
}
}
return true;
});
}
}
}
protected KotlinLightTypeParameter(
@NotNull PsiTypeParameterListOwner owner, int index, @NotNull String name) {
super(owner.getManager(), KotlinLanguage.INSTANCE);
this.owner = owner;
this.index = index;
this.name = name;
}
@NotNull
public static PsiTypeParameter[] getTypeParameters(@NotNull PsiTypeParameterListOwner owner) {
final PsiTypeParameterList typeParameterList = owner.getTypeParameterList();
if (typeParameterList != null) {
return typeParameterList.getTypeParameters();
}
return PsiTypeParameter.EMPTY_ARRAY;
}
private static PsiSubstitutor getRawingSubstitutor(PsiElement context, PsiClass targetClass) {
if (context == null || targetClass == null) return PsiSubstitutor.EMPTY;
PsiTypeParameterListOwner currContext =
PsiTreeUtil.getParentOfType(context, PsiTypeParameterListOwner.class);
PsiManager manager = context.getManager();
PsiSubstitutor substitutor = PsiSubstitutor.EMPTY;
while (currContext != null && !manager.areElementsEquivalent(currContext, targetClass)) {
PsiTypeParameter[] typeParameters = currContext.getTypeParameters();
substitutor =
JavaPsiFacade.getInstance(context.getProject())
.getElementFactory()
.createRawSubstitutor(substitutor, typeParameters);
currContext = currContext.getContainingClass();
}
return substitutor;
}
private void addTypeParams(PsiTypeParameterListOwner from, SNode to) {
ListSequence.fromList(SLinkOperations.getTargets(to, "typeVariableDeclaration", true))
.addSequence(
Sequence.fromIterable(Sequence.fromArray(from.getTypeParameters()))
.select(
new ISelector<PsiTypeParameter, SNode>() {
public SNode select(PsiTypeParameter it) {
return convertTypeParameter(it);
}
}));
}
public static boolean hasTypeParameters(@NotNull PsiTypeParameterListOwner owner) {
final PsiTypeParameterList typeParameterList = owner.getTypeParameterList();
return typeParameterList != null && typeParameterList.getTypeParameters().length != 0;
}
@Nullable
@Override
public Collection<? extends PsiElement> getElementsToSearch(
@NotNull PsiElement element,
@Nullable Module module,
@NotNull Collection<PsiElement> allElementsToDelete) {
Project project = element.getProject();
if (element instanceof PsiPackage && module != null) {
final PsiDirectory[] directories =
((PsiPackage) element).getDirectories(module.getModuleScope());
if (directories.length == 0) return null;
return Arrays.asList(directories);
} else if (element instanceof PsiMethod) {
final PsiMethod[] methods =
SuperMethodWarningUtil.checkSuperMethods(
(PsiMethod) element,
RefactoringBundle.message("to.delete.with.usage.search"),
allElementsToDelete);
if (methods.length == 0) return null;
final ArrayList<PsiMethod> psiMethods = new ArrayList<>(Arrays.asList(methods));
psiMethods.add((PsiMethod) element);
return psiMethods;
} else if (element instanceof PsiParameter
&& ((PsiParameter) element).getDeclarationScope() instanceof PsiMethod) {
PsiMethod method = (PsiMethod) ((PsiParameter) element).getDeclarationScope();
final Set<PsiParameter> parametersToDelete = new HashSet<>();
parametersToDelete.add((PsiParameter) element);
final int parameterIndex =
method.getParameterList().getParameterIndex((PsiParameter) element);
final List<PsiMethod> superMethods =
new ArrayList<>(Arrays.asList(method.findDeepestSuperMethods()));
if (superMethods.isEmpty()) {
superMethods.add(method);
}
for (PsiMethod superMethod : superMethods) {
parametersToDelete.add(superMethod.getParameterList().getParameters()[parameterIndex]);
OverridingMethodsSearch.search(superMethod)
.forEach(
overrider -> {
parametersToDelete.add(
overrider.getParameterList().getParameters()[parameterIndex]);
return true;
});
}
if (parametersToDelete.size() > 1 && !ApplicationManager.getApplication().isUnitTestMode()) {
String message =
RefactoringBundle.message(
"0.is.a.part.of.method.hierarchy.do.you.want.to.delete.multiple.parameters",
UsageViewUtil.getLongName(method));
int result =
Messages.showYesNoCancelDialog(
project, message, SafeDeleteHandler.REFACTORING_NAME, Messages.getQuestionIcon());
if (result == Messages.CANCEL) return null;
if (result == Messages.NO) return Collections.singletonList(element);
}
return parametersToDelete;
} else if (element instanceof PsiTypeParameter) {
final PsiTypeParameterListOwner owner = ((PsiTypeParameter) element).getOwner();
if (owner instanceof PsiMethod && !owner.hasModifierProperty(PsiModifier.STATIC)) {
final PsiTypeParameterList typeParameterList = owner.getTypeParameterList();
if (typeParameterList != null) {
final int index = typeParameterList.getTypeParameterIndex((PsiTypeParameter) element);
if (index >= 0) {
final ArrayList<PsiTypeParameter> overriders = new ArrayList<>();
overriders.add((PsiTypeParameter) element);
OverridingMethodsSearch.search((PsiMethod) owner)
.forEach(
overrider -> {
final PsiTypeParameter[] typeParameters = overrider.getTypeParameters();
if (index < typeParameters.length) {
overriders.add(typeParameters[index]);
}
return true;
});
if (overriders.size() > 1) {
String message =
RefactoringBundle.message(
"0.is.a.part.of.method.hierarchy.do.you.want.to.delete.multiple.type.parameters",
UsageViewUtil.getLongName(owner));
int result =
ApplicationManager.getApplication().isUnitTestMode()
? Messages.YES
: Messages.showYesNoCancelDialog(
project,
message,
SafeDeleteHandler.REFACTORING_NAME,
Messages.getQuestionIcon());
if (result == Messages.CANCEL) return null;
if (result == Messages.YES) return overriders;
}
}
}
}
}
return Collections.singletonList(element);
}