public static PsiType eliminateWildcards(PsiType type, final boolean eliminateInTypeArguments) {
if (eliminateInTypeArguments && type instanceof PsiClassType) {
PsiClassType classType = (PsiClassType) type;
JavaResolveResult resolveResult = classType.resolveGenerics();
PsiClass aClass = (PsiClass) resolveResult.getElement();
if (aClass != null) {
PsiManager manager = aClass.getManager();
PsiTypeParameter[] typeParams = aClass.getTypeParameters();
Map<PsiTypeParameter, PsiType> map = new HashMap<PsiTypeParameter, PsiType>();
for (PsiTypeParameter typeParam : typeParams) {
PsiType substituted = resolveResult.getSubstitutor().substitute(typeParam);
if (substituted instanceof PsiWildcardType) {
substituted = ((PsiWildcardType) substituted).getBound();
if (substituted == null)
substituted = TypeConversionUtil.typeParameterErasure(typeParam);
}
map.put(typeParam, substituted);
}
PsiElementFactory factory =
JavaPsiFacade.getInstance(manager.getProject()).getElementFactory();
PsiSubstitutor substitutor = factory.createSubstitutor(map);
type = factory.createType(aClass, substitutor);
}
} else if (type instanceof PsiArrayType) {
return eliminateWildcards(((PsiArrayType) type).getComponentType(), false).createArrayType();
} else if (type instanceof PsiWildcardType) {
final PsiType bound = ((PsiWildcardType) type).getBound();
return bound != null ? bound : ((PsiWildcardType) type).getExtendsBound(); // object
} else if (type instanceof PsiCapturedWildcardType && !eliminateInTypeArguments) {
return eliminateWildcards(
((PsiCapturedWildcardType) type).getWildcard(), eliminateInTypeArguments);
}
return type;
}
@Nullable
private LocalQuickFix[] createNPEFixes(
PsiExpression qualifier, PsiExpression expression, boolean onTheFly) {
if (qualifier == null || expression == null) return null;
if (qualifier instanceof PsiMethodCallExpression) return null;
if (qualifier instanceof PsiLiteralExpression
&& ((PsiLiteralExpression) qualifier).getValue() == null) return null;
try {
final List<LocalQuickFix> fixes = new SmartList<LocalQuickFix>();
if (PsiUtil.getLanguageLevel(qualifier).isAtLeast(LanguageLevel.JDK_1_4)) {
final Project project = qualifier.getProject();
final PsiElementFactory elementFactory =
JavaPsiFacade.getInstance(project).getElementFactory();
final PsiBinaryExpression binary =
(PsiBinaryExpression) elementFactory.createExpressionFromText("a != null", null);
binary.getLOperand().replace(qualifier);
fixes.add(new AddAssertStatementFix(binary));
}
addSurroundWithIfFix(qualifier, fixes, onTheFly);
if (ReplaceWithTernaryOperatorFix.isAvailable(qualifier, expression)) {
fixes.add(new ReplaceWithTernaryOperatorFix(qualifier));
}
return fixes.toArray(new LocalQuickFix[fixes.size()]);
} catch (IncorrectOperationException e) {
LOG.error(e);
return null;
}
}
private static boolean canBePrivate(
PsiMethod method,
Collection<PsiReference> references,
Collection<? extends PsiElement> deleted,
final PsiElement[] allElementsToDelete) {
final PsiClass containingClass = method.getContainingClass();
if (containingClass == null) {
return false;
}
PsiManager manager = method.getManager();
final JavaPsiFacade facade = JavaPsiFacade.getInstance(manager.getProject());
final PsiElementFactory factory = facade.getElementFactory();
final PsiModifierList privateModifierList;
try {
final PsiMethod newMethod = factory.createMethod("x3", PsiType.VOID);
privateModifierList = newMethod.getModifierList();
privateModifierList.setModifierProperty(PsiModifier.PRIVATE, true);
} catch (IncorrectOperationException e) {
LOG.assertTrue(false);
return false;
}
for (PsiReference reference : references) {
final PsiElement element = reference.getElement();
if (!isInside(element, allElementsToDelete)
&& !isInside(element, deleted)
&& !facade
.getResolveHelper()
.isAccessible(method, privateModifierList, element, null, null)) {
return false;
}
}
return true;
}
private static PsiSubstitutor obtainFinalSubstitutor(
PsiClass superClass,
PsiSubstitutor superSubstitutor,
PsiSubstitutor derivedSubstitutor,
boolean inRawContext) {
if (inRawContext) {
Set<PsiTypeParameter> typeParams = superSubstitutor.getSubstitutionMap().keySet();
PsiElementFactory factory = JavaPsiFacade.getElementFactory(superClass.getProject());
superSubstitutor =
factory.createRawSubstitutor(
derivedSubstitutor, typeParams.toArray(new PsiTypeParameter[typeParams.size()]));
}
Map<PsiTypeParameter, PsiType> map = null;
for (PsiTypeParameter typeParameter : PsiUtil.typeParametersIterable(superClass)) {
PsiType type = superSubstitutor.substitute(typeParameter);
final PsiType t = derivedSubstitutor.substitute(type);
if (map == null) {
map = new THashMap<PsiTypeParameter, PsiType>();
}
map.put(typeParameter, t);
}
return map == null
? PsiSubstitutor.EMPTY
: JavaPsiFacade.getInstance(superClass.getProject())
.getElementFactory()
.createSubstitutor(map);
}
private void fixReferencesToStatic(PsiElement classMember) throws IncorrectOperationException {
final StaticReferencesCollector collector = new StaticReferencesCollector();
classMember.accept(collector);
ArrayList<PsiJavaCodeReferenceElement> refs = collector.getReferences();
ArrayList<PsiElement> members = collector.getReferees();
ArrayList<PsiClass> classes = collector.getRefereeClasses();
PsiElementFactory factory =
JavaPsiFacade.getInstance(classMember.getProject()).getElementFactory();
for (int i = 0; i < refs.size(); i++) {
PsiJavaCodeReferenceElement ref = refs.get(i);
PsiElement namedElement = members.get(i);
PsiClass aClass = classes.get(i);
if (namedElement instanceof PsiNamedElement) {
PsiReferenceExpression newRef =
(PsiReferenceExpression)
factory.createExpressionFromText(
"a." + ((PsiNamedElement) namedElement).getName(), null);
PsiExpression qualifierExpression = newRef.getQualifierExpression();
assert qualifierExpression != null;
qualifierExpression =
(PsiExpression) qualifierExpression.replace(factory.createReferenceExpression(aClass));
qualifierExpression.putCopyableUserData(PRESERVE_QUALIFIER, ref.isQualified());
ref.replace(newRef);
}
}
}
private static void addDefaultConstructor(
JavaChangeInfo changeInfo, PsiClass aClass, final UsageInfo[] usages)
throws IncorrectOperationException {
if (!(aClass instanceof PsiAnonymousClass)) {
PsiElementFactory factory = JavaPsiFacade.getElementFactory(aClass.getProject());
PsiMethod defaultConstructor =
factory.createMethodFromText(aClass.getName() + "(){}", aClass);
defaultConstructor =
(PsiMethod)
CodeStyleManager.getInstance(aClass.getProject()).reformat(defaultConstructor);
defaultConstructor = (PsiMethod) aClass.add(defaultConstructor);
PsiUtil.setModifierProperty(
defaultConstructor, VisibilityUtil.getVisibilityModifier(aClass.getModifierList()), true);
addSuperCall(changeInfo, defaultConstructor, null, usages);
} else {
final PsiElement parent = aClass.getParent();
if (parent instanceof PsiNewExpression) {
final PsiExpressionList argumentList = ((PsiNewExpression) parent).getArgumentList();
final PsiClass baseClass = changeInfo.getMethod().getContainingClass();
final PsiSubstitutor substitutor =
TypeConversionUtil.getSuperClassSubstitutor(baseClass, aClass, PsiSubstitutor.EMPTY);
fixActualArgumentsList(argumentList, changeInfo, true, substitutor);
}
}
}
private static PsiParameter createNewParameter(
JavaChangeInfo changeInfo, JavaParameterInfo newParm, PsiSubstitutor substitutor)
throws IncorrectOperationException {
final PsiParameterList list = changeInfo.getMethod().getParameterList();
final PsiElementFactory factory =
JavaPsiFacade.getInstance(list.getProject()).getElementFactory();
final PsiType type = substitutor.substitute(newParm.createType(list, list.getManager()));
return factory.createParameter(newParm.getName(), type);
}
private static PsiType createType(PsiClass cls, PsiSubstitutor currentSubstitutor, int arrayDim) {
final PsiElementFactory elementFactory =
JavaPsiFacade.getInstance(cls.getProject()).getElementFactory();
PsiType newType = elementFactory.createType(cls, currentSubstitutor);
for (int i = 0; i < arrayDim; i++) {
newType = newType.createArrayType();
}
return newType;
}
public static PsiMethod generateSetterPrototype(
PsiField field, final PsiClass containingClass, boolean returnSelf) {
Project project = field.getProject();
JavaCodeStyleManager codeStyleManager = JavaCodeStyleManager.getInstance(project);
PsiElementFactory factory = JavaPsiFacade.getInstance(field.getProject()).getElementFactory();
String name = field.getName();
boolean isStatic = field.hasModifierProperty(PsiModifier.STATIC);
VariableKind kind = codeStyleManager.getVariableKind(field);
String propertyName = codeStyleManager.variableNameToPropertyName(name, kind);
String setName = suggestSetterName(project, field);
try {
PsiMethod setMethod =
factory.createMethod(
setName, returnSelf ? factory.createType(containingClass) : PsiType.VOID);
String parameterName =
codeStyleManager.propertyNameToVariableName(propertyName, VariableKind.PARAMETER);
PsiParameter param = factory.createParameter(parameterName, field.getType());
annotateWithNullableStuff(field, factory, param);
setMethod.getParameterList().add(param);
PsiUtil.setModifierProperty(setMethod, PsiModifier.PUBLIC, true);
PsiUtil.setModifierProperty(setMethod, PsiModifier.STATIC, isStatic);
@NonNls StringBuffer buffer = new StringBuffer();
buffer.append("{\n");
if (name.equals(parameterName)) {
if (!isStatic) {
buffer.append("this.");
} else {
String className = containingClass.getName();
if (className != null) {
buffer.append(className);
buffer.append(".");
}
}
}
buffer.append(name);
buffer.append("=");
buffer.append(parameterName);
buffer.append(";\n");
if (returnSelf) {
buffer.append("return this;\n");
}
buffer.append("}");
PsiCodeBlock body = factory.createCodeBlockFromText(buffer.toString(), null);
setMethod.getBody().replace(body);
setMethod = (PsiMethod) CodeStyleManager.getInstance(project).reformat(setMethod);
return setMethod;
} catch (IncorrectOperationException e) {
LOG.error(e);
return null;
}
}
private static void processParameterUsage(
PsiReferenceExpression ref, String oldName, String newName)
throws IncorrectOperationException {
PsiElement last = ref.getReferenceNameElement();
if (last instanceof PsiIdentifier && last.getText().equals(oldName)) {
PsiElementFactory factory = JavaPsiFacade.getInstance(ref.getProject()).getElementFactory();
PsiIdentifier newNameIdentifier = factory.createIdentifier(newName);
last.replace(newNameIdentifier);
}
}
private void addParameters(
final PsiElementFactory factory, final PsiMethod methodCopy, final boolean isInterface)
throws IncorrectOperationException {
final Set<Map.Entry<PsiClass, String>> entries = myOldClassParameterNames.entrySet();
for (final Map.Entry<PsiClass, String> entry : entries) {
final PsiClassType type = factory.createType(entry.getKey());
final PsiParameter parameter = factory.createParameter(entry.getValue(), type);
if (isInterface) {
PsiUtil.setModifierProperty(parameter, PsiModifier.FINAL, false);
}
methodCopy.getParameterList().add(parameter);
}
}
public static PsiSubstitutor obtainFinalSubstitutor(
@NotNull PsiClass candidateClass,
@NotNull PsiSubstitutor candidateSubstitutor,
@NotNull PsiClass aClass,
@NotNull PsiSubstitutor substitutor,
@NotNull PsiElementFactory elementFactory,
@NotNull LanguageLevel languageLevel) {
if (PsiUtil.isRawSubstitutor(aClass, substitutor)) {
return elementFactory.createRawSubstitutor(candidateClass);
}
final PsiType containingType =
elementFactory.createType(candidateClass, candidateSubstitutor, languageLevel);
PsiType type = substitutor.substitute(containingType);
if (!(type instanceof PsiClassType)) return candidateSubstitutor;
return ((PsiClassType) type).resolveGenerics().getSubstitutor();
}
private static void fixExceptions(PsiElement ref, PsiClassType[] newExceptions)
throws IncorrectOperationException {
// methods' throws lists are already modified, may use ExceptionUtil.collectUnhandledExceptions
newExceptions = filterCheckedExceptions(newExceptions);
PsiElement context = PsiTreeUtil.getParentOfType(ref, PsiTryStatement.class, PsiMethod.class);
if (context instanceof PsiTryStatement) {
PsiTryStatement tryStatement = (PsiTryStatement) context;
PsiCodeBlock tryBlock = tryStatement.getTryBlock();
// Remove unused catches
Collection<PsiClassType> classes =
ExceptionUtil.collectUnhandledExceptions(tryBlock, tryBlock);
PsiParameter[] catchParameters = tryStatement.getCatchBlockParameters();
for (PsiParameter parameter : catchParameters) {
final PsiType caughtType = parameter.getType();
if (!(caughtType instanceof PsiClassType)) continue;
if (ExceptionUtil.isUncheckedExceptionOrSuperclass((PsiClassType) caughtType)) continue;
if (!isCatchParameterRedundant((PsiClassType) caughtType, classes)) continue;
parameter.getParent().delete(); // delete catch section
}
PsiClassType[] exceptionsToAdd = filterUnhandledExceptions(newExceptions, tryBlock);
addExceptions(exceptionsToAdd, tryStatement);
adjustPossibleEmptyTryStatement(tryStatement);
} else {
newExceptions = filterUnhandledExceptions(newExceptions, ref);
if (newExceptions.length > 0) {
// Add new try statement
PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(ref.getProject());
PsiTryStatement tryStatement =
(PsiTryStatement)
elementFactory.createStatementFromText("try {} catch (Exception e) {}", null);
PsiStatement anchor = PsiTreeUtil.getParentOfType(ref, PsiStatement.class);
LOG.assertTrue(anchor != null);
tryStatement.getTryBlock().add(anchor);
tryStatement = (PsiTryStatement) anchor.getParent().addAfter(tryStatement, anchor);
addExceptions(newExceptions, tryStatement);
anchor.delete();
tryStatement.getCatchSections()[0].delete(); // Delete dummy catch section
}
}
}
private void copyToFinal() throws IncorrectOperationException {
PsiManager psiManager = myClass.getManager();
PsiElementFactory factory =
JavaPsiFacade.getInstance(psiManager.getProject()).getElementFactory();
PsiExpression initializer = factory.createExpressionFromText(myVariable.getName(), myClass);
String newName = suggestNewName(psiManager.getProject(), myVariable);
PsiType type = myVariable.getType();
PsiDeclarationStatement copyDecl =
factory.createVariableDeclarationStatement(newName, type, initializer);
PsiVariable newVariable = (PsiVariable) copyDecl.getDeclaredElements()[0];
PsiUtil.setModifierProperty(newVariable, PsiModifier.FINAL, true);
PsiElement statement = getStatementToInsertBefore();
if (statement == null) return;
statement.getParent().addBefore(copyDecl, statement);
PsiExpression newExpression = factory.createExpressionFromText(newName, myVariable);
replaceReferences(myClass, myVariable, newExpression);
}
@Nullable
public static PsiMethod findPsiMethod(PsiManager manager, String externalName) {
final int spaceIdx = externalName.indexOf(' ');
final String className = externalName.substring(0, spaceIdx);
final PsiClass psiClass = ClassUtil.findPsiClass(manager, className);
if (psiClass == null) return null;
try {
PsiElementFactory factory =
JavaPsiFacade.getInstance(psiClass.getProject()).getElementFactory();
String methodSignature = externalName.substring(spaceIdx + 1);
PsiMethod patternMethod = factory.createMethodFromText(methodSignature, psiClass);
return psiClass.findMethodBySignature(patternMethod, false);
} catch (IncorrectOperationException e) {
// Do nothing. Returning null is acceptable in this case.
return null;
}
}
static PsiElement replaceElementWithExpression(
PsiExpression expression, PsiElementFactory factory, PsiElement element)
throws IncorrectOperationException {
PsiElement elementToReplace = element;
PsiElement expressionToReplaceWith = expression;
if (element.getParent() instanceof PsiExpressionStatement) {
elementToReplace = element.getParent();
expressionToReplaceWith =
factory.createStatementFromText(
(expression == null ? "" : expression.getText()) + ";", null);
} else if (element.getParent() instanceof PsiDeclarationStatement) {
expressionToReplaceWith =
factory.createStatementFromText(
(expression == null ? "" : expression.getText()) + ";", null);
}
return elementToReplace.replace(expressionToReplaceWith);
}
private static void annotate(
final PsiElementFactory factory,
final PsiModifierListOwner listOwner,
final String annotationQName)
throws IncorrectOperationException {
final PsiModifierList modifierList = listOwner.getModifierList();
LOG.assertTrue(modifierList != null);
modifierList.addAfter(factory.createAnnotationFromText("@" + annotationQName, listOwner), null);
}
private void buildDelegate() {
final PsiManager manager = sourceClass.getManager();
final PsiElementFactory factory =
JavaPsiFacade.getInstance(manager.getProject()).getElementFactory();
final CodeStyleManager codeStyleManager = CodeStyleManager.getInstance(manager.getProject());
@NonNls final StringBuilder fieldBuffer = new StringBuilder();
final String delegateVisibility = calculateDelegateVisibility();
if (delegateVisibility.length() > 0) fieldBuffer.append(delegateVisibility).append(' ');
fieldBuffer.append("final ");
final String fullyQualifiedName = getQualifiedName();
fieldBuffer.append(fullyQualifiedName);
if (!typeParams.isEmpty()) {
fieldBuffer.append('<');
for (PsiTypeParameter typeParameter : typeParams) {
fieldBuffer.append(typeParameter.getName());
}
fieldBuffer.append('>');
}
fieldBuffer.append(' ');
fieldBuffer.append(delegateFieldName);
fieldBuffer.append(" = new ").append(fullyQualifiedName);
if (!typeParams.isEmpty()) {
fieldBuffer.append('<');
for (PsiTypeParameter typeParameter : typeParams) {
fieldBuffer.append(typeParameter.getName());
}
fieldBuffer.append('>');
}
fieldBuffer.append('(');
if (requiresBackpointer) {
fieldBuffer.append("this");
}
fieldBuffer.append(");");
try {
final String fieldString = fieldBuffer.toString();
final PsiField field = factory.createFieldFromText(fieldString, sourceClass);
final PsiElement newField = sourceClass.add(field);
codeStyleManager.reformat(
JavaCodeStyleManager.getInstance(myProject).shortenClassReferences(newField));
} catch (IncorrectOperationException e) {
logger.error(e);
}
}
public static void addImportIfNeeded(@NotNull PsiClass aClass, @NotNull PsiElement context) {
final PsiFile file = context.getContainingFile();
if (!(file instanceof PsiJavaFile)) {
return;
}
final PsiJavaFile javaFile = (PsiJavaFile) file;
final PsiClass outerClass = aClass.getContainingClass();
if (outerClass == null) {
if (PsiTreeUtil.isAncestor(javaFile, aClass, true)) {
return;
}
} else if (PsiTreeUtil.isAncestor(outerClass, context, true)) {
final PsiElement brace = outerClass.getLBrace();
if (brace != null && brace.getTextOffset() < context.getTextOffset()) {
return;
}
}
final String qualifiedName = aClass.getQualifiedName();
if (qualifiedName == null) {
return;
}
final PsiImportList importList = javaFile.getImportList();
if (importList == null) {
return;
}
final String containingPackageName = javaFile.getPackageName();
@NonNls final String packageName = ClassUtil.extractPackageName(qualifiedName);
if (containingPackageName.equals(packageName)
|| importList.findSingleClassImportStatement(qualifiedName) != null) {
return;
}
if (importList.findOnDemandImportStatement(packageName) != null
&& !hasDefaultImportConflict(qualifiedName, javaFile)
&& !hasOnDemandImportConflict(qualifiedName, javaFile)) {
return;
}
final Project project = importList.getProject();
final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project);
final PsiElementFactory elementFactory = psiFacade.getElementFactory();
final PsiImportStatement importStatement = elementFactory.createImportStatement(aClass);
importList.add(importStatement);
}
static PsiElement createStatementIfNeeded(
PsiExpression expression, PsiElementFactory factory, PsiElement element)
throws IncorrectOperationException {
// if element used in expression, subexpression will do
if (!(element.getParent() instanceof PsiExpressionStatement)
&& !(element.getParent() instanceof PsiDeclarationStatement)) {
return expression;
}
return factory.createStatementFromText(
(expression == null ? "" : expression.getText()) + ";", null);
}
@Nullable
private static PsiExpression createActualArgument(
JavaChangeInfo changeInfo,
final PsiExpressionList list,
final JavaParameterInfo info,
final boolean toInsertDefaultValue,
final PsiExpression[] args)
throws IncorrectOperationException {
final PsiElementFactory factory =
JavaPsiFacade.getInstance(list.getProject()).getElementFactory();
final int index = info.getOldIndex();
if (index >= 0) {
return args[index];
} else {
if (toInsertDefaultValue) {
return createDefaultValue(changeInfo, factory, info, list);
} else {
return factory.createExpressionFromText(info.getName(), list);
}
}
}
private static PsiSubstitutor checkRaw(
boolean isRaw,
@NotNull PsiElementFactory factory,
@NotNull PsiMethod candidateMethod,
@NotNull PsiSubstitutor substitutor) {
if (isRaw
&& !candidateMethod.hasModifierProperty(
PsiModifier.STATIC)) { // static methods are not erased due to raw overriding
PsiTypeParameter[] methodTypeParameters = candidateMethod.getTypeParameters();
substitutor = factory.createRawSubstitutor(substitutor, methodTypeParameters);
}
return substitutor;
}
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 void addSuperCall(
JavaChangeInfo changeInfo, PsiMethod constructor, PsiMethod callee, final UsageInfo[] usages)
throws IncorrectOperationException {
final PsiElementFactory factory = JavaPsiFacade.getElementFactory(constructor.getProject());
PsiExpressionStatement superCall =
(PsiExpressionStatement) factory.createStatementFromText("super();", constructor);
PsiCodeBlock body = constructor.getBody();
assert body != null;
PsiStatement[] statements = body.getStatements();
if (statements.length > 0) {
superCall = (PsiExpressionStatement) body.addBefore(superCall, statements[0]);
} else {
superCall = (PsiExpressionStatement) body.add(superCall);
}
PsiMethodCallExpression callExpression = (PsiMethodCallExpression) superCall.getExpression();
final PsiClass aClass = constructor.getContainingClass();
final PsiClass baseClass = changeInfo.getMethod().getContainingClass();
final PsiSubstitutor substitutor =
TypeConversionUtil.getSuperClassSubstitutor(baseClass, aClass, PsiSubstitutor.EMPTY);
processMethodUsage(
callExpression.getMethodExpression(), changeInfo, true, false, callee, substitutor, usages);
}
private void addMethodConflicts(MultiMap<PsiElement, String> conflicts) {
String newMethodName = myChangeInfo.getNewName();
if (!(myChangeInfo instanceof JavaChangeInfo)) {
return;
}
try {
PsiMethod prototype;
final PsiMethod method = myChangeInfo.getMethod();
if (!StdLanguages.JAVA.equals(method.getLanguage())) return;
PsiManager manager = method.getManager();
PsiElementFactory factory =
JavaPsiFacade.getInstance(manager.getProject()).getElementFactory();
final CanonicalTypes.Type returnType = myChangeInfo.getNewReturnType();
if (returnType != null) {
prototype = factory.createMethod(newMethodName, returnType.getType(method, manager));
} else {
prototype = factory.createConstructor();
prototype.setName(newMethodName);
}
JavaParameterInfo[] parameters = myChangeInfo.getNewParameters();
for (JavaParameterInfo info : parameters) {
PsiType parameterType = info.createType(method, manager);
if (parameterType == null) {
parameterType =
JavaPsiFacade.getElementFactory(method.getProject())
.createTypeFromText(CommonClassNames.JAVA_LANG_OBJECT, method);
}
PsiParameter param = factory.createParameter(info.getName(), parameterType);
prototype.getParameterList().add(param);
}
ConflictsUtil.checkMethodConflicts(
method.getContainingClass(), method, prototype, conflicts);
} catch (IncorrectOperationException e) {
LOG.error(e);
}
}
private static PsiClassType getEnumSuperType(
@NotNull PsiClass psiClass, @NotNull PsiElementFactory factory) {
PsiClassType superType;
final PsiManager manager = psiClass.getManager();
final PsiClass enumClass =
JavaPsiFacade.getInstance(manager.getProject())
.findClass("java.lang.Enum", psiClass.getResolveScope());
if (enumClass == null) {
try {
superType = (PsiClassType) factory.createTypeFromText("java.lang.Enum", null);
} catch (IncorrectOperationException e) {
superType = null;
}
} else {
final PsiTypeParameter[] typeParameters = enumClass.getTypeParameters();
PsiSubstitutor substitutor = PsiSubstitutor.EMPTY;
if (typeParameters.length == 1) {
substitutor = substitutor.put(typeParameters[0], factory.createType(psiClass));
}
superType = new PsiImmediateClassType(enumClass, substitutor);
}
return superType;
}
public static PsiMethod generateGetterPrototype(PsiField field) {
PsiElementFactory factory = JavaPsiFacade.getInstance(field.getProject()).getElementFactory();
Project project = field.getProject();
String name = field.getName();
String getName = suggestGetterName(project, field);
try {
PsiMethod getMethod = factory.createMethod(getName, field.getType());
PsiUtil.setModifierProperty(getMethod, PsiModifier.PUBLIC, true);
if (field.hasModifierProperty(PsiModifier.STATIC)) {
PsiUtil.setModifierProperty(getMethod, PsiModifier.STATIC, true);
}
annotateWithNullableStuff(field, factory, getMethod);
PsiCodeBlock body = factory.createCodeBlockFromText("{\nreturn " + name + ";\n}", null);
getMethod.getBody().replace(body);
getMethod = (PsiMethod) CodeStyleManager.getInstance(project).reformat(getMethod);
return getMethod;
} catch (IncorrectOperationException e) {
LOG.error(e);
return null;
}
}
private static void modifySuperCall(
final PsiMethod subConstructor, final Set<PsiParameter> parametersToPassToSuper) {
final PsiCodeBlock body = subConstructor.getBody();
if (body != null) {
PsiMethodCallExpression superCall = null;
final PsiStatement[] statements = body.getStatements();
if (statements.length > 0) {
if (statements[0] instanceof PsiExpressionStatement) {
final PsiExpression expression = ((PsiExpressionStatement) statements[0]).getExpression();
if (expression instanceof PsiMethodCallExpression) {
final PsiMethodCallExpression methodCall = (PsiMethodCallExpression) expression;
if ("super".equals(methodCall.getMethodExpression().getText())) {
superCall = methodCall;
}
}
}
}
final PsiElementFactory factory =
JavaPsiFacade.getInstance(subConstructor.getProject()).getElementFactory();
try {
if (superCall == null) {
PsiExpressionStatement statement =
(PsiExpressionStatement) factory.createStatementFromText("super();", null);
statement = (PsiExpressionStatement) body.addAfter(statement, null);
superCall = (PsiMethodCallExpression) statement.getExpression();
}
final PsiExpressionList argList = superCall.getArgumentList();
for (final PsiParameter parameter : parametersToPassToSuper) {
argList.add(factory.createExpressionFromText(parameter.getName(), null));
}
} catch (IncorrectOperationException e) {
LOG.error(e);
}
}
}
private static void addDelegateArguments(
JavaChangeInfo changeInfo, PsiElementFactory factory, final PsiCallExpression callExpression)
throws IncorrectOperationException {
final JavaParameterInfo[] newParms = changeInfo.getNewParameters();
final String[] oldParameterNames = changeInfo.getOldParameterNames();
for (int i = 0; i < newParms.length; i++) {
JavaParameterInfo newParm = newParms[i];
final PsiExpression actualArg;
if (newParm.getOldIndex() >= 0) {
actualArg =
factory.createExpressionFromText(
oldParameterNames[newParm.getOldIndex()], callExpression);
} else {
actualArg = changeInfo.getValue(i, callExpression);
}
JavaCodeStyleManager.getInstance(callExpression.getProject())
.shortenClassReferences(callExpression.getArgumentList().add(actualArg));
}
}
private void makeArray(PsiVariable variable) throws IncorrectOperationException {
PsiType type = variable.getType();
PsiElementFactory factory = JavaPsiFacade.getInstance(myClass.getProject()).getElementFactory();
PsiType newType = type.createArrayType();
PsiDeclarationStatement variableDeclarationStatement;
PsiExpression initializer = variable.getInitializer();
if (initializer == null) {
String expression = "[1]";
while (type instanceof PsiArrayType) {
expression += "[1]";
type = ((PsiArrayType) type).getComponentType();
}
PsiExpression init =
factory.createExpressionFromText("new " + type.getCanonicalText() + expression, variable);
variableDeclarationStatement =
factory.createVariableDeclarationStatement(variable.getName(), newType, init);
} else {
PsiExpression init =
factory.createExpressionFromText("{ " + initializer.getText() + " }", variable);
variableDeclarationStatement =
factory.createVariableDeclarationStatement(variable.getName(), newType, init);
}
PsiVariable newVariable = (PsiVariable) variableDeclarationStatement.getDeclaredElements()[0];
PsiUtil.setModifierProperty(newVariable, PsiModifier.FINAL, true);
PsiElement newExpression =
factory.createExpressionFromText(variable.getName() + "[0]", variable);
PsiElement outerCodeBlock = PsiUtil.getVariableCodeBlock(variable, null);
if (outerCodeBlock == null) return;
List<PsiReferenceExpression> outerReferences = new ArrayList<PsiReferenceExpression>();
collectReferences(outerCodeBlock, variable, outerReferences);
replaceReferences(outerReferences, newExpression);
variable.replace(newVariable);
}
