summaryrefslogtreecommitdiff
path: root/java/java-impl/src/com/intellij/refactoring/encapsulateFields/EncapsulateFieldsProcessor.java
diff options
context:
space:
mode:
Diffstat (limited to 'java/java-impl/src/com/intellij/refactoring/encapsulateFields/EncapsulateFieldsProcessor.java')
-rw-r--r--java/java-impl/src/com/intellij/refactoring/encapsulateFields/EncapsulateFieldsProcessor.java446
1 files changed, 96 insertions, 350 deletions
diff --git a/java/java-impl/src/com/intellij/refactoring/encapsulateFields/EncapsulateFieldsProcessor.java b/java/java-impl/src/com/intellij/refactoring/encapsulateFields/EncapsulateFieldsProcessor.java
index fc87374b6ad3..986f98b5fc39 100644
--- a/java/java-impl/src/com/intellij/refactoring/encapsulateFields/EncapsulateFieldsProcessor.java
+++ b/java/java-impl/src/com/intellij/refactoring/encapsulateFields/EncapsulateFieldsProcessor.java
@@ -1,6 +1,6 @@
/*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2013 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -20,17 +20,11 @@ import com.intellij.lang.findUsages.DescriptiveNameUtil;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.Ref;
-import com.intellij.openapi.util.text.StringUtil;
import com.intellij.psi.*;
-import com.intellij.psi.codeStyle.CodeStyleManager;
import com.intellij.psi.javadoc.PsiDocComment;
import com.intellij.psi.search.searches.ClassInheritorsSearch;
import com.intellij.psi.search.searches.ReferencesSearch;
-import com.intellij.psi.tree.IElementType;
-import com.intellij.psi.util.InheritanceUtil;
-import com.intellij.psi.util.PsiFormatUtil;
-import com.intellij.psi.util.PsiTreeUtil;
-import com.intellij.psi.util.PsiUtil;
+import com.intellij.psi.util.*;
import com.intellij.refactoring.BaseRefactoringProcessor;
import com.intellij.refactoring.RefactoringBundle;
import com.intellij.refactoring.util.CommonRefactoringUtil;
@@ -41,12 +35,10 @@ import com.intellij.usageView.UsageInfo;
import com.intellij.usageView.UsageViewDescriptor;
import com.intellij.usageView.UsageViewUtil;
import com.intellij.util.IncorrectOperationException;
-import com.intellij.util.VisibilityUtil;
+import com.intellij.util.containers.ContainerUtil;
import com.intellij.util.containers.HashMap;
import com.intellij.util.containers.MultiMap;
-import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
import java.util.*;
@@ -56,7 +48,7 @@ public class EncapsulateFieldsProcessor extends BaseRefactoringProcessor {
private PsiClass myClass;
@NotNull
private final EncapsulateFieldsDescriptor myDescriptor;
- private final PsiField[] myFields;
+ private final FieldDescriptor[] myFieldDescriptors;
private HashMap<String,PsiMethod> myNameToGetter;
private HashMap<String,PsiMethod> myNameToSetter;
@@ -64,14 +56,26 @@ public class EncapsulateFieldsProcessor extends BaseRefactoringProcessor {
public EncapsulateFieldsProcessor(Project project, @NotNull EncapsulateFieldsDescriptor descriptor) {
super(project);
myDescriptor = descriptor;
- myFields = myDescriptor.getSelectedFields();
- myClass = myFields[0].getContainingClass();
+ myFieldDescriptors = descriptor.getSelectedFields();
+ myClass = descriptor.getTargetClass();
+ }
+
+ public static void setNewFieldVisibility(PsiField field, EncapsulateFieldsDescriptor descriptor) {
+ try {
+ if (descriptor.getFieldsVisibility() != null) {
+ field.normalizeDeclaration();
+ PsiUtil.setModifierProperty(field, descriptor.getFieldsVisibility(), true);
+ }
+ }
+ catch (IncorrectOperationException e) {
+ LOG.error(e);
+ }
}
@NotNull
protected UsageViewDescriptor createUsageViewDescriptor(UsageInfo[] usages) {
- PsiField[] fields = new PsiField[myFields.length];
- System.arraycopy(myFields, 0, fields, 0, myFields.length);
+ FieldDescriptor[] fields = new FieldDescriptor[myFieldDescriptors.length];
+ System.arraycopy(myFieldDescriptors, 0, fields, 0, myFieldDescriptors.length);
return new EncapsulateFieldsViewDescriptor(fields);
}
@@ -82,28 +86,27 @@ public class EncapsulateFieldsProcessor extends BaseRefactoringProcessor {
protected boolean preprocessUsages(Ref<UsageInfo[]> refUsages) {
final MultiMap<PsiElement, String> conflicts = new MultiMap<PsiElement, String>();
- final PsiMethod[] getterPrototypes = myDescriptor.getGetterPrototypes();
- final PsiMethod[] setterPrototypes = myDescriptor.getSetterPrototypes();
-
- checkExistingMethods(getterPrototypes, conflicts, true);
- checkExistingMethods(setterPrototypes, conflicts, false);
+ checkExistingMethods(conflicts, true);
+ checkExistingMethods(conflicts, false);
final Collection<PsiClass> classes = ClassInheritorsSearch.search(myClass).findAll();
- for (int i = 0; i < myFields.length; i++) {
- final PsiField field = myFields[i];
+ for (FieldDescriptor fieldDescriptor : myFieldDescriptors) {
final Set<PsiMethod> setters = new HashSet<PsiMethod>();
final Set<PsiMethod> getters = new HashSet<PsiMethod>();
for (PsiClass aClass : classes) {
- final PsiMethod getterOverrider = getterPrototypes != null ? aClass.findMethodBySignature(getterPrototypes[i], false) : null;
+ final PsiMethod getterOverrider =
+ myDescriptor.isToEncapsulateGet() ? aClass.findMethodBySignature(fieldDescriptor.getGetterPrototype(), false) : null;
if (getterOverrider != null) {
getters.add(getterOverrider);
}
- final PsiMethod setterOverrider = setterPrototypes != null ? aClass.findMethodBySignature(setterPrototypes[i], false) : null;
+ final PsiMethod setterOverrider =
+ myDescriptor.isToEncapsulateSet() ? aClass.findMethodBySignature(fieldDescriptor.getSetterPrototype(), false) : null;
if (setterOverrider != null) {
setters.add(setterOverrider);
}
}
if (!getters.isEmpty() || !setters.isEmpty()) {
+ final PsiField field = fieldDescriptor.getField();
for (PsiReference reference : ReferencesSearch.search(field)) {
final PsiElement place = reference.getElement();
LOG.assertTrue(place instanceof PsiReferenceExpression);
@@ -132,9 +135,19 @@ public class EncapsulateFieldsProcessor extends BaseRefactoringProcessor {
return showConflicts(conflicts, refUsages.get());
}
- private void checkExistingMethods(PsiMethod[] prototypes, MultiMap<PsiElement, String> conflicts, boolean isGetter) {
- if(prototypes == null) return;
- for (PsiMethod prototype : prototypes) {
+ private void checkExistingMethods(MultiMap<PsiElement, String> conflicts, boolean isGetter) {
+ if (isGetter) {
+ if (!myDescriptor.isToEncapsulateGet()) return;
+ }
+ else {
+ if (!myDescriptor.isToEncapsulateSet()) return;
+ }
+
+ for (FieldDescriptor descriptor : myFieldDescriptors) {
+ PsiMethod prototype = isGetter
+ ? descriptor.getGetterPrototype()
+ : descriptor.getSetterPrototype();
+
final PsiType prototypeReturnType = prototype.getReturnType();
PsiMethod existing = myClass.findMethodBySignature(prototype, true);
if (existing != null) {
@@ -142,8 +155,8 @@ public class EncapsulateFieldsProcessor extends BaseRefactoringProcessor {
if (!RefactoringUtil.equivalentTypes(prototypeReturnType, returnType, myClass.getManager())) {
final String descr = PsiFormatUtil.formatMethod(existing,
PsiSubstitutor.EMPTY,
- PsiFormatUtil.SHOW_NAME | PsiFormatUtil.SHOW_PARAMETERS | PsiFormatUtil.SHOW_TYPE,
- PsiFormatUtil.SHOW_TYPE
+ PsiFormatUtilBase.SHOW_NAME | PsiFormatUtilBase.SHOW_PARAMETERS | PsiFormatUtilBase.SHOW_TYPE,
+ PsiFormatUtilBase.SHOW_TYPE
);
String message = isGetter ?
RefactoringBundle.message("encapsulate.fields.getter.exists", CommonRefactoringUtil.htmlEmphasize(descr),
@@ -181,144 +194,112 @@ public class EncapsulateFieldsProcessor extends BaseRefactoringProcessor {
}
@NotNull protected UsageInfo[] findUsages() {
- boolean findGet = myDescriptor.isToEncapsulateGet();
- boolean findSet = myDescriptor.isToEncapsulateSet();
- PsiModifierList newModifierList = null;
- final JavaPsiFacade facade = JavaPsiFacade.getInstance(myProject);
- if (!myDescriptor.isToUseAccessorsWhenAccessible()){
- PsiElementFactory factory = facade.getElementFactory();
- try{
- PsiField field = factory.createField("a", PsiType.INT);
- setNewFieldVisibility(field);
- newModifierList = field.getModifierList();
- }
- catch(IncorrectOperationException e){
- LOG.error(e);
- }
- }
- PsiMethod[] getterPrototypes = myDescriptor.getGetterPrototypes();
- PsiMethod[] setterPrototypes = myDescriptor.getSetterPrototypes();
- ArrayList<UsageInfo> array = new ArrayList<UsageInfo>();
- PsiField[] fields = myFields;
- for(int i = 0; i < fields.length; i++){
- PsiField field = fields[i];
- for (final PsiReference reference : ReferencesSearch.search(field)) {
- if (!(reference instanceof PsiReferenceExpression)) continue;
- PsiReferenceExpression ref = (PsiReferenceExpression)reference;
- // [Jeka] to avoid recursion in the field's accessors
- if (findGet && isUsedInExistingAccessor(getterPrototypes[i], ref)) continue;
- if (findSet && isUsedInExistingAccessor(setterPrototypes[i], ref)) continue;
- if (!findGet) {
- if (!PsiUtil.isAccessedForWriting(ref)) continue;
+ ArrayList<EncapsulateFieldUsageInfo> array = ContainerUtil.newArrayList();
+ for (FieldDescriptor fieldDescriptor : myFieldDescriptors) {
+ for (final PsiReference reference : ReferencesSearch.search(fieldDescriptor.getField())) {
+ final PsiElement element = reference.getElement();
+ if (element == null) continue;
+
+ final EncapsulateFieldHelper helper = EncapsulateFieldHelper.getHelper(element.getLanguage());
+ EncapsulateFieldUsageInfo usageInfo = helper.createUsage(myDescriptor, fieldDescriptor, reference);
+ if (usageInfo != null) {
+ array.add(usageInfo);
}
- if (!findSet || field.hasModifierProperty(PsiModifier.FINAL)) {
- if (!PsiUtil.isAccessedForReading(ref)) continue;
- }
- if (!myDescriptor.isToUseAccessorsWhenAccessible()) {
- PsiClass accessObjectClass = null;
- PsiExpression qualifier = ref.getQualifierExpression();
- if (qualifier != null) {
- accessObjectClass = (PsiClass)PsiUtil.getAccessObjectClass(qualifier).getElement();
- }
- if (facade.getResolveHelper()
- .isAccessible(field, newModifierList, ref, accessObjectClass, null)) {
- continue;
- }
- }
- UsageInfo usageInfo = new MyUsageInfo(ref, i);
- array.add(usageInfo);
}
}
- MyUsageInfo[] usageInfos = array.toArray(new MyUsageInfo[array.size()]);
+ EncapsulateFieldUsageInfo[] usageInfos = array.toArray(new EncapsulateFieldUsageInfo[array.size()]);
return UsageViewUtil.removeDuplicatedUsages(usageInfos);
}
protected void refreshElements(PsiElement[] elements) {
- LOG.assertTrue(elements.length == myFields.length);
+ LOG.assertTrue(elements.length == myFieldDescriptors.length);
for (int idx = 0; idx < elements.length; idx++) {
PsiElement element = elements[idx];
LOG.assertTrue(element instanceof PsiField);
- myFields[idx] = (PsiField)element;
+ myFieldDescriptors[idx].refreshField((PsiField)element);
}
- myClass = myFields[0].getContainingClass();
+ myClass = myFieldDescriptors[0].getField().getContainingClass();
}
protected void performRefactoring(UsageInfo[] usages) {
- // change visibility of fields
- if (myDescriptor.getFieldsVisibility() != null){
- // "as is"
- for (PsiField field : myFields) {
- setNewFieldVisibility(field);
- }
+ updateFieldVisibility();
+ generateAccessors();
+ processUsagesPerFile(usages);
+ }
+
+ private void updateFieldVisibility() {
+ if (myDescriptor.getFieldsVisibility() == null) return;
+
+ for (FieldDescriptor descriptor : myFieldDescriptors) {
+ setNewFieldVisibility(descriptor.getField(), myDescriptor);
}
+ }
+ private void generateAccessors() {
// generate accessors
myNameToGetter = new HashMap<String, PsiMethod>();
myNameToSetter = new HashMap<String, PsiMethod>();
- for(int i = 0; i < myFields.length; i++){
+
+ for (FieldDescriptor fieldDescriptor : myFieldDescriptors) {
final DocCommentPolicy<PsiDocComment> commentPolicy = new DocCommentPolicy<PsiDocComment>(myDescriptor.getJavadocPolicy());
- PsiField field = myFields[i];
+
+ PsiField field = fieldDescriptor.getField();
final PsiDocComment docComment = field.getDocComment();
- if (myDescriptor.isToEncapsulateGet()){
- PsiMethod[] prototypes = myDescriptor.getGetterPrototypes();
- assert prototypes != null;
- final PsiMethod getter = addOrChangeAccessor(prototypes[i], myNameToGetter);
+ if (myDescriptor.isToEncapsulateGet()) {
+ final PsiMethod prototype = fieldDescriptor.getGetterPrototype();
+ assert prototype != null;
+ final PsiMethod getter = addOrChangeAccessor(prototype, myNameToGetter);
if (docComment != null) {
final PsiDocComment getterJavadoc = (PsiDocComment)getter.addBefore(docComment, getter.getFirstChild());
commentPolicy.processNewJavaDoc(getterJavadoc);
}
}
- if (myDescriptor.isToEncapsulateSet() && !field.hasModifierProperty(PsiModifier.FINAL)){
- PsiMethod[] prototypes = myDescriptor.getSetterPrototypes();
- assert prototypes != null;
- addOrChangeAccessor(prototypes[i], myNameToSetter);
+ if (myDescriptor.isToEncapsulateSet() && !field.hasModifierProperty(PsiModifier.FINAL)) {
+ PsiMethod prototype = fieldDescriptor.getSetterPrototype();
+ assert prototype != null;
+ addOrChangeAccessor(prototype, myNameToSetter);
}
if (docComment != null) {
commentPolicy.processOldJavaDoc(docComment);
}
}
+ }
- Map<PsiFile, List<MyUsageInfo>> usagesInFiles = new HashMap<PsiFile, List<MyUsageInfo>>();
+ private void processUsagesPerFile(UsageInfo[] usages) {
+ Map<PsiFile, List<EncapsulateFieldUsageInfo>> usagesInFiles = new HashMap<PsiFile, List<EncapsulateFieldUsageInfo>>();
for (UsageInfo usage : usages) {
PsiElement element = usage.getElement();
if (element == null) continue;
final PsiFile file = element.getContainingFile();
- List<MyUsageInfo> usagesInFile = usagesInFiles.get(file);
+ List<EncapsulateFieldUsageInfo> usagesInFile = usagesInFiles.get(file);
if (usagesInFile == null) {
- usagesInFile = new ArrayList<MyUsageInfo>();
+ usagesInFile = new ArrayList<EncapsulateFieldUsageInfo>();
usagesInFiles.put(file, usagesInFile);
}
- usagesInFile.add(((MyUsageInfo)usage));
+ usagesInFile.add(((EncapsulateFieldUsageInfo)usage));
}
- for (List<MyUsageInfo> usageInfos : usagesInFiles.values()) {
+ for (List<EncapsulateFieldUsageInfo> usageInfos : usagesInFiles.values()) {
//this is to avoid elements to become invalid as a result of processUsage
- final MyUsageInfo[] infos = usageInfos.toArray(new MyUsageInfo[usageInfos.size()]);
+ final EncapsulateFieldUsageInfo[] infos = usageInfos.toArray(new EncapsulateFieldUsageInfo[usageInfos.size()]);
CommonRefactoringUtil.sortDepthFirstRightLeftOrder(infos);
- for (MyUsageInfo info : infos) {
- processUsage(info);
+ for (EncapsulateFieldUsageInfo info : infos) {
+ EncapsulateFieldHelper helper = EncapsulateFieldHelper.getHelper(info.getElement().getLanguage());
+ helper.processUsage(info,
+ myDescriptor,
+ myNameToSetter.get(info.getFieldDescriptor().getSetterName()),
+ myNameToGetter.get(info.getFieldDescriptor().getGetterName())
+ );
}
}
}
- private void setNewFieldVisibility(PsiField field) {
- try{
- if (myDescriptor.getFieldsVisibility() != null){
- field.normalizeDeclaration();
- PsiUtil.setModifierProperty(field, myDescriptor.getFieldsVisibility(), true);
- }
- }
- catch(IncorrectOperationException e){
- LOG.error(e);
- }
- }
-
private PsiMethod addOrChangeAccessor(PsiMethod prototype, HashMap<String,PsiMethod> nameToAncestor) {
PsiMethod existing = myClass.findMethodBySignature(prototype, false);
PsiMethod result = existing;
@@ -338,239 +319,4 @@ public class EncapsulateFieldsProcessor extends BaseRefactoringProcessor {
}
return null;
}
-
- private boolean isUsedInExistingAccessor(PsiMethod prototype, PsiElement element) {
- PsiMethod existingAccessor = myClass.findMethodBySignature(prototype, false);
- if (existingAccessor != null) {
- PsiElement parent = element;
- while (parent != null) {
- if (existingAccessor.equals(parent)) return true;
- parent = parent.getParent();
- }
- }
- return false;
- }
-
- private void processUsage(MyUsageInfo usage) {
- PsiField field = myFields[usage.fieldIndex];
- boolean processGet = myDescriptor.isToEncapsulateGet();
- boolean processSet = myDescriptor.isToEncapsulateSet() && !field.hasModifierProperty(PsiModifier.FINAL);
- if (!processGet && !processSet) return;
- PsiElementFactory factory = JavaPsiFacade.getInstance(myProject).getElementFactory();
-
- try{
- final PsiReferenceExpression expr = (PsiReferenceExpression)usage.getElement();
- if (expr == null) return;
- final PsiElement parent = expr.getParent();
- if (parent instanceof PsiAssignmentExpression && expr.equals(((PsiAssignmentExpression)parent).getLExpression())){
- PsiAssignmentExpression assignment = (PsiAssignmentExpression)parent;
- if (assignment.getRExpression() == null) return;
- PsiJavaToken opSign = assignment.getOperationSign();
- IElementType opType = opSign.getTokenType();
- if (opType == JavaTokenType.EQ) {
- {
- if (!processSet) return;
- final int fieldIndex = usage.fieldIndex;
- final PsiExpression setterArgument = assignment.getRExpression();
-
- PsiMethodCallExpression methodCall = createSetterCall(fieldIndex, setterArgument, expr);
-
- if (methodCall != null) {
- assignment.replace(methodCall);
- }
- //TODO: check if value is used!!!
- }
- }
- else if (opType == JavaTokenType.ASTERISKEQ || opType == JavaTokenType.DIVEQ || opType == JavaTokenType.PERCEQ ||
- opType == JavaTokenType.PLUSEQ ||
- opType == JavaTokenType.MINUSEQ ||
- opType == JavaTokenType.LTLTEQ ||
- opType == JavaTokenType.GTGTEQ ||
- opType == JavaTokenType.GTGTGTEQ ||
- opType == JavaTokenType.ANDEQ ||
- opType == JavaTokenType.OREQ ||
- opType == JavaTokenType.XOREQ) {
- {
- // Q: side effects of qualifier??!
-
- String opName = opSign.getText();
- LOG.assertTrue(StringUtil.endsWithChar(opName, '='));
- opName = opName.substring(0, opName.length() - 1);
-
- PsiExpression getExpr = expr;
- if (processGet) {
- final int fieldIndex = usage.fieldIndex;
- final PsiMethodCallExpression getterCall = createGetterCall(fieldIndex, expr);
- if (getterCall != null) {
- getExpr = getterCall;
- }
- }
-
- @NonNls String text = "a" + opName + "b";
- PsiBinaryExpression binExpr = (PsiBinaryExpression)factory.createExpressionFromText(text, expr);
- binExpr = (PsiBinaryExpression)CodeStyleManager.getInstance(myProject).reformat(binExpr);
- binExpr.getLOperand().replace(getExpr);
- binExpr.getROperand().replace(assignment.getRExpression());
-
- PsiExpression setExpr;
- if (processSet) {
- setExpr = createSetterCall(usage.fieldIndex, binExpr, expr);
- }
- else {
- text = "a = b";
- PsiAssignmentExpression assignment1 = (PsiAssignmentExpression)factory.createExpressionFromText(text, null);
- assignment1 = (PsiAssignmentExpression)CodeStyleManager.getInstance(myProject).reformat(assignment1);
- assignment1.getLExpression().replace(expr);
- assignment1.getRExpression().replace(binExpr);
- setExpr = assignment1;
- }
-
- assignment.replace(setExpr);
- //TODO: check if value is used!!!
- }
- }
- }
- else if (RefactoringUtil.isPlusPlusOrMinusMinus(parent)){
- IElementType sign;
- if (parent instanceof PsiPrefixExpression){
- sign = ((PsiPrefixExpression)parent).getOperationTokenType();
- }
- else{
- sign = ((PsiPostfixExpression)parent).getOperationTokenType();
- }
-
- PsiExpression getExpr = expr;
- if (processGet){
- final int fieldIndex = usage.fieldIndex;
- final PsiMethodCallExpression getterCall = createGetterCall(fieldIndex, expr);
- if(getterCall != null) {
- getExpr = getterCall;
- }
- }
-
- @NonNls String text;
- if (sign == JavaTokenType.PLUSPLUS){
- text = "a+1";
- }
- else{
- text = "a-1";
- }
- PsiBinaryExpression binExpr = (PsiBinaryExpression)factory.createExpressionFromText(text, null);
- binExpr = (PsiBinaryExpression)CodeStyleManager.getInstance(myProject).reformat(binExpr);
- binExpr.getLOperand().replace(getExpr);
-
- PsiExpression setExpr;
- if (processSet){
- final int fieldIndex = usage.fieldIndex;
- setExpr = createSetterCall(fieldIndex, binExpr, expr);
- }
- else{
- text = "a = b";
- PsiAssignmentExpression assignment = (PsiAssignmentExpression)factory.createExpressionFromText(text, null);
- assignment = (PsiAssignmentExpression)CodeStyleManager.getInstance(myProject).reformat(assignment);
- assignment.getLExpression().replace(expr);
- assignment.getRExpression().replace(binExpr);
- setExpr = assignment;
- }
- parent.replace(setExpr);
- }
- else{
- if (!processGet) return;
- PsiMethodCallExpression methodCall = createGetterCall(usage.fieldIndex, expr);
-
- if (methodCall != null) {
- expr.replace(methodCall);
- }
- }
- }
- catch(IncorrectOperationException e){
- LOG.error(e);
- }
- }
-
- private PsiMethodCallExpression createSetterCall(final int fieldIndex, final PsiExpression setterArgument, PsiReferenceExpression expr) throws IncorrectOperationException {
- String[] setterNames = myDescriptor.getSetterNames();
- PsiElementFactory factory = JavaPsiFacade.getInstance(expr.getProject()).getElementFactory();
- final String setterName = setterNames[fieldIndex];
- @NonNls String text = setterName + "(a)";
- PsiExpression qualifier = expr.getQualifierExpression();
- if (qualifier != null){
- text = "q." + text;
- }
- PsiMethodCallExpression methodCall = (PsiMethodCallExpression)factory.createExpressionFromText(text, expr);
- methodCall = (PsiMethodCallExpression)CodeStyleManager.getInstance(myProject).reformat(methodCall);
-
- methodCall.getArgumentList().getExpressions()[0].replace(setterArgument);
- if (qualifier != null){
- methodCall.getMethodExpression().getQualifierExpression().replace(qualifier);
- }
- final PsiMethod targetMethod = myNameToSetter.get(setterName);
- methodCall = checkMethodResolvable(methodCall, targetMethod, expr);
- if (methodCall == null) {
- VisibilityUtil.escalateVisibility(myFields[fieldIndex], expr);
- }
- return methodCall;
- }
-
- @Nullable
- private PsiMethodCallExpression createGetterCall(final int fieldIndex, PsiReferenceExpression expr)
- throws IncorrectOperationException {
- String[] getterNames = myDescriptor.getGetterNames();
- PsiElementFactory factory = JavaPsiFacade.getInstance(expr.getProject()).getElementFactory();
- final String getterName = getterNames[fieldIndex];
- @NonNls String text = getterName + "()";
- PsiExpression qualifier = expr.getQualifierExpression();
- if (qualifier != null){
- text = "q." + text;
- }
- PsiMethodCallExpression methodCall = (PsiMethodCallExpression)factory.createExpressionFromText(text, expr);
- methodCall = (PsiMethodCallExpression)CodeStyleManager.getInstance(myProject).reformat(methodCall);
-
- if (qualifier != null){
- methodCall.getMethodExpression().getQualifierExpression().replace(qualifier);
- }
-
- final PsiMethod targetMethod = myNameToGetter.get(getterName);
- methodCall = checkMethodResolvable(methodCall, targetMethod, expr);
- if(methodCall == null) {
- VisibilityUtil.escalateVisibility(myFields[fieldIndex], expr);
- }
- return methodCall;
- }
-
- @Nullable
- private PsiMethodCallExpression checkMethodResolvable(PsiMethodCallExpression methodCall, final PsiMethod targetMethod, PsiReferenceExpression context) throws IncorrectOperationException {
- PsiElementFactory factory = JavaPsiFacade.getInstance(targetMethod.getProject()).getElementFactory();
- final PsiElement resolved = methodCall.getMethodExpression().resolve();
- if (resolved != targetMethod) {
- PsiClass containingClass;
- if (resolved instanceof PsiMethod) {
- containingClass = ((PsiMethod) resolved).getContainingClass();
- } else if (resolved instanceof PsiClass) {
- containingClass = (PsiClass)resolved;
- }
- else {
- return null;
- }
- if(containingClass != null && containingClass.isInheritor(myClass, false)) {
- final PsiExpression newMethodExpression =
- factory.createExpressionFromText("super." + targetMethod.getName(), context);
- methodCall.getMethodExpression().replace(newMethodExpression);
- } else {
- methodCall = null;
- }
- }
- return methodCall;
- }
-
-
-
- private static class MyUsageInfo extends UsageInfo {
- public final int fieldIndex;
-
- public MyUsageInfo(PsiJavaCodeReferenceElement ref, int fieldIndex) {
- super(ref);
- this.fieldIndex = fieldIndex;
- }
- }
}
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-04 22:48:34 +0000