MDS/openide
1
0
Fork 0
mirror of https://gitflic.ru/project/openide/openide.git synced 2026-04-19 04:51:24 +07:00
Code Issues Packages Projects Releases Wiki Activity

[java] Refactoring after review IJ-CR-97162

Browse Source 
GitOrigin-RevId: df817240a27c9d19cda1bc2909b4efc9c490eb99
This commit is contained in:
Andrey Cherkasov
2023-07-03 17:00:39 +04:00
committed by intellij-monorepo-bot
parent 1530062b6c
commit c991d4ca83
1 changed files with 35 additions and 56 deletions
Download Patch File Download Diff File Expand all files Collapse all files

91
java/java-impl-refactorings/src/com/intellij/refactoring/changeSignature/JavaChangeSignatureUsageProcessor.java
View File

@@ -870,7 +870,7 @@ public class JavaChangeSignatureUsageProcessor implements ChangeSignatureUsagePr
}
}
abstract static class Processor<Parent extends PsiElement, Child extends ChildI> {
abstract static class Processor<Parent extends PsiElement, Child extends ChildWrapper> {
protected final @NotNull PsiElementFactory myFactory;
protected final @NotNull Parent myParent;
protected final @NotNull JavaChangeInfo myChangeInfo;
@@ -946,14 +946,14 @@ public class JavaChangeSignatureUsageProcessor implements ChangeSignatureUsagePr
}
}
final static class RecordHeaderProcessor extends Processor<PsiRecordHeader, Variable> {
final static class RecordHeaderProcessor extends Processor<PsiRecordHeader, VariableWrapper> {
RecordHeaderProcessor(@NotNull JavaChangeInfo changeInfo, @NotNull PsiElementFactory factory, @NotNull PsiRecordHeader header) {
super(changeInfo, factory, header);
}
@Override
void processNew(JavaParameterInfo info, List<Variable> result) {
void processNew(JavaParameterInfo info, List<VariableWrapper> result) {
PsiType newType = info.createType(myParent);
if (newType != null) {
String componentText = newType.getCanonicalText() + " " + info.getName();
@@ -961,23 +961,23 @@ public class JavaChangeSignatureUsageProcessor implements ChangeSignatureUsagePr
if (dummyComponents.length != 1) {
throw new IncorrectOperationException(componentText + " is not a valid component");
}
result.add(new Variable(dummyComponents[0]));
result.add(new VariableWrapper(dummyComponents[0]));
}
}
@Override
Variable getChild(int index) {
return new Variable(myParent.getRecordComponents()[index]);
VariableWrapper getChild(int index) {
return new VariableWrapper(myParent.getRecordComponents()[index]);
}
@Override
protected void process(@NotNull List<Variable> newElements) {
final List<PsiRecordComponent> newComponents = ContainerUtil.map(newElements, element -> (PsiRecordComponent)element.getElement());
protected void process(@NotNull List<VariableWrapper> newElements) {
final List<PsiRecordComponent> newComponents = ContainerUtil.map(newElements, element -> (PsiRecordComponent)element.variable());
ChangeSignatureUtil.synchronizeList(myParent, newComponents, RecordHeader.INSTANCE, myChangeInfo.toRemoveParm());
}
}
final static class MethodParamsProcessor extends Processor<PsiParameterList, Variable> {
final static class MethodParamsProcessor extends Processor<PsiParameterList, VariableWrapper> {
private final @Nullable PsiElement myMethodBody;
private final @NotNull PsiSubstitutor mySubstitutor;
private final @Nullable PsiMethod myBaseMethod;
@@ -995,20 +995,20 @@ public class JavaChangeSignatureUsageProcessor implements ChangeSignatureUsagePr
}
@Override
void processNew(JavaParameterInfo info, List<Variable> result) {
void processNew(JavaParameterInfo info, List<VariableWrapper> result) {
PsiElement parent = myParent.getParent();
if (parent instanceof PsiLambdaExpression && !((PsiLambdaExpression)parent).hasFormalParameterTypes()) {
PsiExpression dummyLambdaParam = myFactory.createExpressionFromText(info.getName() + "-> {}", myParent);
result.add(new Variable(((PsiLambdaExpression)dummyLambdaParam).getParameterList().getParameters()[0]));
result.add(new VariableWrapper(((PsiLambdaExpression)dummyLambdaParam).getParameterList().getParameters()[0]));
}
else {
result.add(new Variable(createNewParameter(myChangeInfo, info, mySubstitutor)));
result.add(new VariableWrapper(createNewParameter(myChangeInfo, info, mySubstitutor)));
}
}
@Override
Variable getChild(int index) {
return new Variable(Objects.requireNonNull(myParent.getParameter(index)));
VariableWrapper getChild(int index) {
return new VariableWrapper(Objects.requireNonNull(myParent.getParameter(index)));
}
@Override
@@ -1027,15 +1027,15 @@ public class JavaChangeSignatureUsageProcessor implements ChangeSignatureUsagePr
}
@Override
protected void process(@NotNull List<Variable> newElements) {
final List<PsiParameter> newParameters = ContainerUtil.map(newElements, element -> (PsiParameter)element.getElement());
final List<String> newParameterNames = ContainerUtil.map(newElements, Variable::getName);
protected void process(@NotNull List<VariableWrapper> newElements) {
final List<PsiParameter> newParameters = ContainerUtil.map(newElements, element -> (PsiParameter)element.variable());
final List<String> newParameterNames = ContainerUtil.map(newElements, VariableWrapper::getName);
final boolean[] toRemove = myChangeInfo.toRemoveParm();
resolveVariableVsFieldsConflicts(newParameters, newParameterNames, myParent, toRemove, myMethodBody, ParameterList.INSTANCE);
}
}
final static class DeconstructionProcessor extends Processor<PsiDeconstructionList, Pattern> {
final static class DeconstructionProcessor extends Processor<PsiDeconstructionList, PatternWrapper> {
DeconstructionProcessor(@NotNull JavaChangeInfo changeInfo,
@NotNull PsiElementFactory factory,
@NotNull PsiDeconstructionList list) {
@@ -1043,7 +1043,7 @@ public class JavaChangeSignatureUsageProcessor implements ChangeSignatureUsagePr
}
@Override
void processNew(JavaParameterInfo info, List<Pattern> result) {
void processNew(JavaParameterInfo info, List<PatternWrapper> result) {
PsiType newType = info.createType(myParent);
if (newType != null) {
String patternText = newType.getCanonicalText() + " " + info.getName();
@@ -1052,19 +1052,19 @@ public class JavaChangeSignatureUsageProcessor implements ChangeSignatureUsagePr
throw new IncorrectOperationException(patternText + " is not a valid pattern");
}
PsiPattern pattern = instanceOfExpression.getPattern();
result.add(new Pattern(Objects.requireNonNull(pattern)));
result.add(new PatternWrapper(Objects.requireNonNull(pattern)));
}
}
@Override
Pattern getChild(int index) {
return new Pattern(myParent.getDeconstructionComponents()[index]);
PatternWrapper getChild(int index) {
return new PatternWrapper(myParent.getDeconstructionComponents()[index]);
}
@Override
protected void process(@NotNull List<Pattern> elements) {
final List<PsiPattern> newPatterns = ContainerUtil.map(elements, element -> (PsiPattern)element.getElement());
final List<String> newElementNames = ContainerUtil.map(elements, Pattern::getName);
protected void process(@NotNull List<PatternWrapper> elements) {
final List<PsiPattern> newPatterns = ContainerUtil.map(elements, element -> element.pattern());
final List<String> newElementNames = ContainerUtil.map(elements, PatternWrapper::getName);
resolveVariableVsFieldsConflicts(newPatterns,
newElementNames,
myParent,
@@ -1577,75 +1577,54 @@ public class JavaChangeSignatureUsageProcessor implements ChangeSignatureUsagePr
}
}
interface ChildI {
sealed interface ChildWrapper permits VariableWrapper, PatternWrapper {
@Nullable String getName();
@Nullable PsiElement getNameIdentifier();
@Nullable PsiTypeElement getTypeElement();
@NotNull PsiElement getElement();
default void normalizeDeclaration() {}
}
final static class Variable implements ChildI {
private final @NotNull PsiVariable myElement;
Variable(@NotNull PsiVariable element) {
myElement = element;
}
record VariableWrapper(@NotNull PsiVariable variable) implements ChildWrapper {
@Override
public String getName() {
return myElement.getName();
return variable.getName();
}
@Override
public @Nullable PsiElement getNameIdentifier() {
return myElement.getNameIdentifier();
return variable.getNameIdentifier();
}
@Override
public PsiTypeElement getTypeElement() {
return myElement.getTypeElement();
}
@Override
public @NotNull PsiElement getElement() {
return myElement;
return variable.getTypeElement();
}
@Override
public void normalizeDeclaration() {
myElement.normalizeDeclaration();
variable.normalizeDeclaration();
}
}
final static class Pattern implements ChildI {
private final @NotNull PsiPattern myElement;
Pattern(@NotNull PsiPattern element) {
myElement = element;
}
record PatternWrapper(@NotNull PsiPattern pattern) implements ChildWrapper {
@Override
@Nullable
public String getName() {
final PsiPatternVariable variable = JavaPsiPatternUtil.getPatternVariable(myElement);
final PsiPatternVariable variable = JavaPsiPatternUtil.getPatternVariable(pattern);
return variable != null ? variable.getName() : null;
}
@Override
public @Nullable PsiElement getNameIdentifier() {
final PsiPatternVariable variable = JavaPsiPatternUtil.getPatternVariable(myElement);
final PsiPatternVariable variable = JavaPsiPatternUtil.getPatternVariable(pattern);
return variable != null ? variable.getNameIdentifier() : null;
}
@Override
public @Nullable PsiTypeElement getTypeElement() {
return JavaPsiPatternUtil.getPatternTypeElement(myElement);
}
@Override
public @NotNull PsiElement getElement() {
return myElement;
return JavaPsiPatternUtil.getPatternTypeElement(pattern);
}
}
}