1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
|
package com.intellij.refactoring.introduceParameter;
import com.intellij.codeInsight.intention.impl.TypeExpression;
import com.intellij.codeInsight.lookup.LookupElement;
import com.intellij.codeInsight.template.Expression;
import com.intellij.codeInsight.template.ExpressionContext;
import com.intellij.codeInsight.template.Result;
import com.intellij.codeInsight.template.TextResult;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.editor.Editor;
import com.intellij.openapi.editor.RangeMarker;
import com.intellij.openapi.fileTypes.StdFileTypes;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.Comparing;
import com.intellij.openapi.util.Computable;
import com.intellij.pom.java.LanguageLevel;
import com.intellij.psi.*;
import com.intellij.psi.codeStyle.JavaCodeStyleManager;
import com.intellij.psi.codeStyle.VariableKind;
import com.intellij.psi.impl.source.tree.injected.InjectedLanguageUtil;
import com.intellij.psi.util.PsiTreeUtil;
import com.intellij.refactoring.introduce.inplace.AbstractInplaceIntroducer;
import com.intellij.refactoring.ui.TypeSelectorManagerImpl;
import com.intellij.util.ArrayUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
/**
* User: anna
*/
public abstract class AbstractJavaInplaceIntroducer extends AbstractInplaceIntroducer<PsiVariable, PsiExpression> {
protected TypeSelectorManagerImpl myTypeSelectorManager;
public AbstractJavaInplaceIntroducer(final Project project,
Editor editor,
PsiExpression expr,
PsiVariable localVariable,
PsiExpression[] occurrences,
TypeSelectorManagerImpl typeSelectorManager, String title) {
super(project, InjectedLanguageUtil.getTopLevelEditor(editor), expr, localVariable, occurrences, title, StdFileTypes.JAVA);
myTypeSelectorManager = typeSelectorManager;
}
protected abstract PsiVariable createFieldToStartTemplateOn(String[] names, PsiType psiType);
protected abstract String[] suggestNames(PsiType defaultType, String propName);
protected abstract VariableKind getVariableKind();
@Override
protected String[] suggestNames(boolean replaceAll, PsiVariable variable) {
myTypeSelectorManager.setAllOccurrences(replaceAll);
final PsiType defaultType = myTypeSelectorManager.getTypeSelector().getSelectedType();
final String propertyName = variable != null
? JavaCodeStyleManager.getInstance(myProject).variableNameToPropertyName(variable.getName(), VariableKind.LOCAL_VARIABLE)
: null;
final String[] names = suggestNames(defaultType, propertyName);
if (propertyName != null && names.length > 1) {
final JavaCodeStyleManager javaCodeStyleManager = JavaCodeStyleManager.getInstance(myProject);
final String paramName = javaCodeStyleManager.propertyNameToVariableName(propertyName, getVariableKind());
final int idx = ArrayUtil.find(names, paramName);
if (idx > -1) {
ArrayUtil.swap(names, 0, idx);
}
}
return names;
}
@Override
protected PsiVariable createFieldToStartTemplateOn(boolean replaceAll, String[] names) {
myTypeSelectorManager.setAllOccurrences(replaceAll);
return createFieldToStartTemplateOn(names, getType());
}
@Override
protected void correctExpression() {
final PsiElement parent = getExpr().getParent();
if (parent instanceof PsiExpressionStatement && parent.getLastChild() instanceof PsiErrorElement) {
myExpr = ((PsiExpressionStatement)ApplicationManager.getApplication().runWriteAction(new Computable<PsiElement>() {
@Override
public PsiElement compute() {
return parent.replace(JavaPsiFacade.getElementFactory(myProject).createStatementFromText(parent.getText() + ";", parent));
}
})).getExpression();
myEditor.getCaretModel().moveToOffset(myExpr.getTextRange().getStartOffset());
}
}
@Override
public PsiExpression restoreExpression(PsiFile containingFile, PsiVariable psiVariable, RangeMarker marker, String exprText) {
return restoreExpression(containingFile, psiVariable, JavaPsiFacade.getElementFactory(myProject), marker, exprText);
}
@Override
protected void restoreState(PsiVariable psiField) {
final SmartTypePointer typePointer = SmartTypePointerManager.getInstance(myProject).createSmartTypePointer(getType());
super.restoreState(psiField);
for (PsiExpression occurrence : myOccurrences) {
if (!occurrence.isValid()) return;
}
try {
myTypeSelectorManager = myExpr != null
? new TypeSelectorManagerImpl(myProject, typePointer.getType(), myExpr, myOccurrences)
: new TypeSelectorManagerImpl(myProject, typePointer.getType(), myOccurrences);
}
catch (Exception e) {
LOG.error(e);
}
}
@Override
protected void saveSettings(@NotNull PsiVariable psiVariable) {
TypeSelectorManagerImpl.typeSelected(psiVariable.getType(), getType());//myDefaultType.getType());
myTypeSelectorManager = null;
}
public PsiType getType() {
return myTypeSelectorManager.getDefaultType();
}
public static String[] appendUnresolvedExprName(String[] names, final PsiExpression expr) {
if (expr instanceof PsiReferenceExpression && ((PsiReferenceExpression)expr).resolve() == null) {
final String name = expr.getText();
if (JavaPsiFacade.getInstance(expr.getProject()).getNameHelper().isIdentifier(name, LanguageLevel.HIGHEST)) {
names = ArrayUtil.mergeArrays(new String[]{name}, names);
}
}
return names;
}
@Nullable
public static PsiExpression restoreExpression(PsiFile containingFile,
PsiVariable psiVariable,
PsiElementFactory elementFactory,
RangeMarker marker, String exprText) {
if (exprText == null) return null;
if (psiVariable == null || !psiVariable.isValid()) return null;
final PsiElement refVariableElement = containingFile.findElementAt(marker.getStartOffset());
final PsiElement refVariableElementParent = refVariableElement != null ? refVariableElement.getParent() : null;
PsiExpression expression = refVariableElement instanceof PsiKeyword && refVariableElementParent instanceof PsiNewExpression
? (PsiNewExpression)refVariableElementParent
: refVariableElementParent instanceof PsiParenthesizedExpression
? ((PsiParenthesizedExpression)refVariableElementParent).getExpression()
: PsiTreeUtil.getParentOfType(refVariableElement, PsiReferenceExpression.class);
if (expression instanceof PsiReferenceExpression && !(expression.getParent() instanceof PsiMethodCallExpression)) {
final String referenceName = ((PsiReferenceExpression)expression).getReferenceName();
if (((PsiReferenceExpression)expression).resolve() == psiVariable ||
Comparing.strEqual(psiVariable.getName(), referenceName) ||
Comparing.strEqual(exprText, referenceName)) {
return (PsiExpression)expression.replace(elementFactory.createExpressionFromText(exprText, psiVariable));
}
}
if (expression == null) {
expression = PsiTreeUtil.getParentOfType(refVariableElement, PsiExpression.class);
}
while (expression instanceof PsiReferenceExpression || expression instanceof PsiMethodCallExpression) {
final PsiElement parent = expression.getParent();
if (parent instanceof PsiMethodCallExpression) {
if (parent.getText().equals(exprText)) return (PsiExpression)parent;
}
if (parent instanceof PsiExpression) {
expression = (PsiExpression)parent;
if (expression.getText().equals(exprText)) {
return expression;
}
} else if (expression instanceof PsiReferenceExpression) {
return null;
} else {
break;
}
}
if (expression != null && expression.isValid() && expression.getText().equals(exprText)) {
return expression;
}
if (refVariableElementParent instanceof PsiExpression && refVariableElementParent.getText().equals(exprText)) {
return (PsiExpression)refVariableElementParent;
}
return null;
}
public static Expression createExpression(final TypeExpression expression, final String defaultType) {
return new Expression() {
@Override
public Result calculateResult(ExpressionContext context) {
return new TextResult(defaultType);
}
@Override
public Result calculateQuickResult(ExpressionContext context) {
return new TextResult(defaultType);
}
@Override
public LookupElement[] calculateLookupItems(ExpressionContext context) {
return expression.calculateLookupItems(context);
}
@Override
public String getAdvertisingText() {
return null;
}
};
}
}
|
