@NotNull
private static PsiClass[] resolveClassReferenceList(
@NotNull PsiClassType[] listOfTypes,
@NotNull PsiManager manager,
@NotNull GlobalSearchScope resolveScope,
boolean includeObject) {
PsiClass objectClass =
JavaPsiFacade.getInstance(manager.getProject())
.findClass(CommonClassNames.JAVA_LANG_OBJECT, resolveScope);
if (objectClass == null) includeObject = false;
if (listOfTypes.length == 0) {
if (includeObject) return new PsiClass[] {objectClass};
return PsiClass.EMPTY_ARRAY;
}
int referenceCount = listOfTypes.length;
if (includeObject) referenceCount++;
PsiClass[] resolved = new PsiClass[referenceCount];
int resolvedCount = 0;
if (includeObject) resolved[resolvedCount++] = objectClass;
for (PsiClassType reference : listOfTypes) {
PsiClass refResolved = reference.resolve();
if (refResolved != null) resolved[resolvedCount++] = refResolved;
}
if (resolvedCount < referenceCount) {
PsiClass[] shorter = new PsiClass[resolvedCount];
System.arraycopy(resolved, 0, shorter, 0, resolvedCount);
resolved = shorter;
}
return resolved;
}
@NotNull
private static PsiClass[] getSupersInner(@NotNull PsiClass psiClass) {
PsiClassType[] extendsListTypes = psiClass.getExtendsListTypes();
PsiClassType[] implementsListTypes = psiClass.getImplementsListTypes();
if (psiClass.isInterface()) {
return resolveClassReferenceList(
extendsListTypes, psiClass.getManager(), psiClass.getResolveScope(), true);
}
if (psiClass instanceof PsiAnonymousClass) {
PsiAnonymousClass psiAnonymousClass = (PsiAnonymousClass) psiClass;
PsiClassType baseClassReference = psiAnonymousClass.getBaseClassType();
PsiClass baseClass = baseClassReference.resolve();
if (baseClass != null) {
if (baseClass.isInterface()) {
PsiClass objectClass =
JavaPsiFacade.getInstance(psiClass.getProject())
.findClass(CommonClassNames.JAVA_LANG_OBJECT, psiClass.getResolveScope());
return objectClass != null
? new PsiClass[] {objectClass, baseClass}
: new PsiClass[] {baseClass};
}
return new PsiClass[] {baseClass};
}
PsiClass objectClass =
JavaPsiFacade.getInstance(psiClass.getProject())
.findClass(CommonClassNames.JAVA_LANG_OBJECT, psiClass.getResolveScope());
return objectClass != null ? new PsiClass[] {objectClass} : PsiClass.EMPTY_ARRAY;
}
if (psiClass instanceof PsiTypeParameter) {
if (extendsListTypes.length == 0) {
final PsiClass objectClass =
JavaPsiFacade.getInstance(psiClass.getProject())
.findClass(CommonClassNames.JAVA_LANG_OBJECT, psiClass.getResolveScope());
return objectClass != null ? new PsiClass[] {objectClass} : PsiClass.EMPTY_ARRAY;
}
return resolveClassReferenceList(
extendsListTypes, psiClass.getManager(), psiClass.getResolveScope(), false);
}
PsiClass[] interfaces =
resolveClassReferenceList(
implementsListTypes, psiClass.getManager(), psiClass.getResolveScope(), false);
PsiClass superClass = getSuperClass(psiClass);
if (superClass == null) return interfaces;
PsiClass[] types = new PsiClass[interfaces.length + 1];
types[0] = superClass;
System.arraycopy(interfaces, 0, types, 1, interfaces.length);
return types;
}
@NotNull
public static PsiClassType[] getSuperTypes(@NotNull PsiClass psiClass) {
if (psiClass instanceof PsiAnonymousClass) {
PsiClassType baseClassType = ((PsiAnonymousClass) psiClass).getBaseClassType();
PsiClass baseClass = baseClassType.resolve();
if (baseClass == null || !baseClass.isInterface()) {
return new PsiClassType[] {baseClassType};
} else {
PsiClassType objectType =
PsiType.getJavaLangObject(psiClass.getManager(), psiClass.getResolveScope());
return new PsiClassType[] {objectType, baseClassType};
}
}
PsiClassType[] extendsTypes = psiClass.getExtendsListTypes();
PsiClassType[] implementsTypes = psiClass.getImplementsListTypes();
boolean hasExtends = extendsTypes.length != 0;
int extendsListLength = extendsTypes.length + (hasExtends ? 0 : 1);
PsiClassType[] result = new PsiClassType[extendsListLength + implementsTypes.length];
System.arraycopy(extendsTypes, 0, result, 0, extendsTypes.length);
if (!hasExtends) {
if (CommonClassNames.JAVA_LANG_OBJECT.equals(psiClass.getQualifiedName())) {
return PsiClassType.EMPTY_ARRAY;
}
PsiManager manager = psiClass.getManager();
PsiClassType objectType = PsiType.getJavaLangObject(manager, psiClass.getResolveScope());
result[0] = objectType;
}
System.arraycopy(implementsTypes, 0, result, extendsListLength, implementsTypes.length);
for (int i = 0; i < result.length; i++) {
PsiClassType type = result[i];
result[i] = (PsiClassType) PsiUtil.captureToplevelWildcards(type, psiClass);
}
return result;
}
public static PsiAnnotation[] getTestNGAnnotations(PsiElement element) {
PsiElement[] annotations =
PsiTreeUtil.collectElements(
element,
new PsiElementFilter() {
public boolean isAccepted(PsiElement element) {
if (!(element instanceof PsiAnnotation)) return false;
String name = ((PsiAnnotation) element).getQualifiedName();
if (null == name) return false;
if (name.startsWith("org.testng.annotations")) {
return true;
}
return false;
}
});
PsiAnnotation[] array = new PsiAnnotation[annotations.length];
System.arraycopy(annotations, 0, array, 0, annotations.length);
return array;
}
@NotNull
protected UsageViewDescriptor createUsageViewDescriptor(UsageInfo[] usages) {
FieldDescriptor[] fields = new FieldDescriptor[myFieldDescriptors.length];
System.arraycopy(myFieldDescriptors, 0, fields, 0, myFieldDescriptors.length);
return new EncapsulateFieldsViewDescriptor(fields);
}
// This methods works equally well for primary usages as well as for propagated callers' usages
private static void fixActualArgumentsList(
PsiExpressionList list,
JavaChangeInfo changeInfo,
boolean toInsertDefaultValue,
PsiSubstitutor substitutor)
throws IncorrectOperationException {
final PsiElementFactory factory =
JavaPsiFacade.getInstance(list.getProject()).getElementFactory();
if (changeInfo.isParameterSetOrOrderChanged()) {
if (changeInfo instanceof JavaChangeInfoImpl
&& ((JavaChangeInfoImpl) changeInfo).isPropagationEnabled) {
final ParameterInfoImpl[] createdParmsInfo =
((JavaChangeInfoImpl) changeInfo).getCreatedParmsInfoWithoutVarargs();
for (ParameterInfoImpl info : createdParmsInfo) {
PsiExpression newArg;
if (toInsertDefaultValue) {
newArg = createDefaultValue(changeInfo, factory, info, list);
} else {
newArg = factory.createExpressionFromText(info.getName(), list);
}
JavaCodeStyleManager.getInstance(list.getProject())
.shortenClassReferences(list.add(newArg));
}
} else {
final PsiExpression[] args = list.getExpressions();
final int nonVarargCount = getNonVarargCount(changeInfo, args);
final int varargCount = args.length - nonVarargCount;
if (varargCount < 0) return;
PsiExpression[] newVarargInitializers = null;
final int newArgsLength;
final int newNonVarargCount;
final JavaParameterInfo[] newParms = changeInfo.getNewParameters();
if (changeInfo.isArrayToVarargs()) {
newNonVarargCount = newParms.length - 1;
final JavaParameterInfo lastNewParm = newParms[newParms.length - 1];
final PsiExpression arrayToConvert = args[lastNewParm.getOldIndex()];
if (arrayToConvert instanceof PsiNewExpression) {
final PsiNewExpression expression = (PsiNewExpression) arrayToConvert;
final PsiArrayInitializerExpression arrayInitializer = expression.getArrayInitializer();
if (arrayInitializer != null) {
newVarargInitializers = arrayInitializer.getInitializers();
}
}
newArgsLength =
newVarargInitializers == null
? newParms.length
: newNonVarargCount + newVarargInitializers.length;
} else if (changeInfo.isRetainsVarargs()) {
newNonVarargCount = newParms.length - 1;
newArgsLength = newNonVarargCount + varargCount;
} else if (changeInfo.isObtainsVarags()) {
newNonVarargCount = newParms.length - 1;
newArgsLength = newNonVarargCount;
} else {
newNonVarargCount = newParms.length;
newArgsLength = newParms.length;
}
String[] oldVarargs = null;
if (changeInfo.wasVararg() && !changeInfo.isRetainsVarargs()) {
oldVarargs = new String[varargCount];
for (int i = nonVarargCount; i < args.length; i++) {
oldVarargs[i - nonVarargCount] = args[i].getText();
}
}
final PsiExpression[] newArgs = new PsiExpression[newArgsLength];
for (int i = 0; i < newNonVarargCount; i++) {
if (newParms[i].getOldIndex() == nonVarargCount && oldVarargs != null) {
PsiType type = newParms[i].createType(changeInfo.getMethod(), list.getManager());
if (type instanceof PsiArrayType) {
type = substitutor.substitute(type);
type = TypeConversionUtil.erasure(type);
String typeText = type.getCanonicalText();
if (type instanceof PsiEllipsisType) {
typeText = typeText.replace("...", "[]");
}
String text = "new " + typeText + "{" + StringUtil.join(oldVarargs, ",") + "}";
newArgs[i] = factory.createExpressionFromText(text, changeInfo.getMethod());
continue;
}
}
newArgs[i] =
createActualArgument(changeInfo, list, newParms[i], toInsertDefaultValue, args);
}
if (changeInfo.isArrayToVarargs()) {
if (newVarargInitializers == null) {
newArgs[newNonVarargCount] =
createActualArgument(
changeInfo, list, newParms[newNonVarargCount], toInsertDefaultValue, args);
} else {
System.arraycopy(
newVarargInitializers, 0, newArgs, newNonVarargCount, newVarargInitializers.length);
}
} else {
final int newVarargCount = newArgsLength - newNonVarargCount;
LOG.assertTrue(newVarargCount == 0 || newVarargCount == varargCount);
for (int i = newNonVarargCount; i < newArgsLength; i++) {
final int oldIndex = newParms[newNonVarargCount].getOldIndex();
if (oldIndex >= 0 && oldIndex != nonVarargCount) {
newArgs[i] =
createActualArgument(
changeInfo, list, newParms[newNonVarargCount], toInsertDefaultValue, args);
} else {
System.arraycopy(args, nonVarargCount, newArgs, newNonVarargCount, newVarargCount);
break;
}
}
}
ChangeSignatureUtil.synchronizeList(
list, Arrays.asList(newArgs), ExpressionList.INSTANCE, changeInfo.toRemoveParm());
}
}
}