private void doMoveClass(PsiSubstitutor substitutor, MemberInfo info) {
PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(myProject);
PsiClass aClass = (PsiClass) info.getMember();
if (Boolean.FALSE.equals(info.getOverrides())) {
final PsiReferenceList sourceReferenceList = info.getSourceReferenceList();
LOG.assertTrue(sourceReferenceList != null);
PsiJavaCodeReferenceElement ref =
mySourceClass.equals(sourceReferenceList.getParent())
? RefactoringUtil.removeFromReferenceList(sourceReferenceList, aClass)
: RefactoringUtil.findReferenceToClass(sourceReferenceList, aClass);
if (ref != null && !myTargetSuperClass.isInheritor(aClass, false)) {
RefactoringUtil.replaceMovedMemberTypeParameters(
ref, PsiUtil.typeParametersIterable(mySourceClass), substitutor, elementFactory);
final PsiReferenceList referenceList =
myIsTargetInterface
? myTargetSuperClass.getExtendsList()
: myTargetSuperClass.getImplementsList();
assert referenceList != null;
referenceList.add(ref);
}
} else {
RefactoringUtil.replaceMovedMemberTypeParameters(
aClass, PsiUtil.typeParametersIterable(mySourceClass), substitutor, elementFactory);
fixReferencesToStatic(aClass);
final PsiMember movedElement =
(PsiMember)
myTargetSuperClass.add(
convertClassToLanguage(aClass, myTargetSuperClass.getLanguage()));
myMembersAfterMove.add(movedElement);
aClass.delete();
}
}
@Nullable
private PullUpHelper<MemberInfo> getProcessor(@NotNull MemberInfo info) {
PsiReferenceList refList = info.getSourceReferenceList();
if (refList != null) {
return getProcessor(refList.getLanguage());
}
return getProcessor(info.getMember());
}
@NotNull
public static PsiClassType[] getImplementsListTypes(@NotNull PsiClass psiClass) {
final PsiReferenceList extendsList = psiClass.getImplementsList();
if (extendsList != null) {
return extendsList.getReferencedTypes();
}
return PsiClassType.EMPTY_ARRAY;
}
private static void processCallerMethod(
JavaChangeInfo changeInfo,
PsiMethod caller,
PsiMethod baseMethod,
boolean toInsertParams,
boolean toInsertThrows)
throws IncorrectOperationException {
LOG.assertTrue(toInsertParams || toInsertThrows);
if (toInsertParams) {
List<PsiParameter> newParameters = new ArrayList<PsiParameter>();
ContainerUtil.addAll(newParameters, caller.getParameterList().getParameters());
final JavaParameterInfo[] primaryNewParms = changeInfo.getNewParameters();
PsiSubstitutor substitutor =
baseMethod == null
? PsiSubstitutor.EMPTY
: ChangeSignatureProcessor.calculateSubstitutor(caller, baseMethod);
for (JavaParameterInfo info : primaryNewParms) {
if (info.getOldIndex() < 0)
newParameters.add(createNewParameter(changeInfo, info, substitutor));
}
PsiParameter[] arrayed = newParameters.toArray(new PsiParameter[newParameters.size()]);
boolean[] toRemoveParm = new boolean[arrayed.length];
Arrays.fill(toRemoveParm, false);
resolveParameterVsFieldsConflicts(arrayed, caller, caller.getParameterList(), toRemoveParm);
}
if (toInsertThrows) {
List<PsiJavaCodeReferenceElement> newThrowns = new ArrayList<PsiJavaCodeReferenceElement>();
final PsiReferenceList throwsList = caller.getThrowsList();
ContainerUtil.addAll(newThrowns, throwsList.getReferenceElements());
final ThrownExceptionInfo[] primaryNewExns = changeInfo.getNewExceptions();
for (ThrownExceptionInfo thrownExceptionInfo : primaryNewExns) {
if (thrownExceptionInfo.getOldIndex() < 0) {
final PsiClassType type =
(PsiClassType) thrownExceptionInfo.createType(caller, caller.getManager());
final PsiJavaCodeReferenceElement ref =
JavaPsiFacade.getInstance(caller.getProject())
.getElementFactory()
.createReferenceElementByType(type);
newThrowns.add(ref);
}
}
PsiJavaCodeReferenceElement[] arrayed =
newThrowns.toArray(new PsiJavaCodeReferenceElement[newThrowns.size()]);
boolean[] toRemoveParm = new boolean[arrayed.length];
Arrays.fill(toRemoveParm, false);
ChangeSignatureUtil.synchronizeList(
throwsList, Arrays.asList(arrayed), ThrowsList.INSTANCE, toRemoveParm);
}
}
@NotNull
public static PsiClassType[] getExtendsListTypes(@NotNull PsiClass psiClass) {
if (psiClass.isEnum()) {
PsiClassType enumSuperType =
getEnumSuperType(
psiClass, JavaPsiFacade.getInstance(psiClass.getProject()).getElementFactory());
return enumSuperType == null ? PsiClassType.EMPTY_ARRAY : new PsiClassType[] {enumSuperType};
}
if (psiClass.isAnnotationType()) {
return new PsiClassType[] {
getAnnotationSuperType(
psiClass, JavaPsiFacade.getInstance(psiClass.getProject()).getElementFactory())
};
}
final PsiReferenceList extendsList = psiClass.getExtendsList();
if (extendsList != null) {
return extendsList.getReferencedTypes();
}
return PsiClassType.EMPTY_ARRAY;
}
@Nullable
private static PsiReferenceParameterList extractReferenceParameterList(
final PsiClass superClass, final PsiReferenceList extendsList) {
for (PsiJavaCodeReferenceElement referenceElement : extendsList.getReferenceElements()) {
final PsiElement element = referenceElement.resolve();
if (element instanceof PsiClass
&& InheritanceUtil.isInheritorOrSelf((PsiClass) element, superClass, true)) {
return referenceElement.getParameterList();
}
}
return null;
}
private static void fixPrimaryThrowsLists(PsiMethod method, PsiClassType[] newExceptions)
throws IncorrectOperationException {
PsiElementFactory elementFactory =
JavaPsiFacade.getInstance(method.getProject()).getElementFactory();
PsiJavaCodeReferenceElement[] refs = new PsiJavaCodeReferenceElement[newExceptions.length];
for (int i = 0; i < refs.length; i++) {
refs[i] = elementFactory.createReferenceElementByType(newExceptions[i]);
}
PsiReferenceList throwsList = elementFactory.createReferenceList(refs);
PsiReferenceList methodThrowsList =
(PsiReferenceList) method.getThrowsList().replace(throwsList);
methodThrowsList =
(PsiReferenceList)
JavaCodeStyleManager.getInstance(method.getProject())
.shortenClassReferences(methodThrowsList);
CodeStyleManager.getInstance(method.getManager().getProject())
.reformatRange(
method,
method.getParameterList().getTextRange().getEndOffset(),
methodThrowsList.getTextRange().getEndOffset());
}
private static List<PsiClassType> getSuperTypes(PsiClass clazz) {
if (clazz instanceof GrTypeDefinition) {
final GrExtendsClause elist = ((GrTypeDefinition) clazz).getExtendsClause();
final GrImplementsClause ilist = ((GrTypeDefinition) clazz).getImplementsClause();
if (elist == null && ilist == null) return ContainerUtil.emptyList();
final ArrayList<PsiClassType> types = new ArrayList<PsiClassType>();
if (elist != null) ContainerUtil.addAll(types, elist.getReferencedTypes());
if (ilist != null) ContainerUtil.addAll(types, ilist.getReferencedTypes());
return types;
} else {
final PsiReferenceList elist = clazz.getExtendsList();
final PsiReferenceList ilist = clazz.getImplementsList();
if (elist == null && ilist == null) return ContainerUtil.emptyList();
final ArrayList<PsiClassType> types = new ArrayList<PsiClassType>();
if (elist != null) ContainerUtil.addAll(types, elist.getReferencedTypes());
if (ilist != null) ContainerUtil.addAll(types, ilist.getReferencedTypes());
return types;
}
}
public List<PsiJavaCodeReferenceElement> getChildren(PsiReferenceList throwsList) {
return Arrays.asList(throwsList.getReferenceElements());
}
