From b7f01dd32a53029979c5e58f9267be83effd3159 Mon Sep 17 00:00:00 2001 From: Dmitry Batkovich Date: Fri, 16 Jun 2017 14:47:53 +0300 Subject: [PATCH] Revert type migration: use deeply immediate migration type copy instead of original one --- .../typeMigration/TypeMigrationLabeler.java | 6 ++-- .../SmartTypePointerManagerImpl.java | 28 +++++++++---------- .../impl/source/PsiClassReferenceType.java | 7 +++++ 3 files changed, 22 insertions(+), 19 deletions(-) diff --git a/java/java-impl/src/com/intellij/refactoring/typeMigration/TypeMigrationLabeler.java b/java/java-impl/src/com/intellij/refactoring/typeMigration/TypeMigrationLabeler.java index b9fd3159c4c4..3cfb1c5412b7 100644 --- a/java/java-impl/src/com/intellij/refactoring/typeMigration/TypeMigrationLabeler.java +++ b/java/java-impl/src/com/intellij/refactoring/typeMigration/TypeMigrationLabeler.java @@ -1073,11 +1073,9 @@ public class TypeMigrationLabeler { myMigrationRoots = new LinkedList<>(); myTypeEvaluator = new TypeEvaluator(myMigrationRoots, this, myProject); - SmartTypePointerManager smartTypePointerManager = SmartTypePointerManager.getInstance(myProject); + for (PsiElement victim : victims) { - // use deeply immediate types - PsiType migrationType = smartTypePointerManager.createSmartTypePointer(myMigrationRootTypeFunction.fun(victim)).getType(); - addMigrationRoot(victim, migrationType, null, false, true, true); + addMigrationRoot(victim, myMigrationRootTypeFunction.fun(victim), null, false, true, true); } if (autoMigrate) { diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/smartPointers/SmartTypePointerManagerImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/smartPointers/SmartTypePointerManagerImpl.java index 0b28631e5494..0f3edffc74af 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/smartPointers/SmartTypePointerManagerImpl.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/smartPointers/SmartTypePointerManagerImpl.java @@ -18,6 +18,7 @@ package com.intellij.psi.impl.smartPointers; import com.intellij.openapi.project.Project; import com.intellij.psi.*; import com.intellij.psi.impl.PsiSubstitutorImpl; +import com.intellij.psi.impl.source.PsiClassReferenceType; import com.intellij.psi.impl.source.PsiImmediateClassType; import com.intellij.psi.util.PsiUtil; import com.intellij.util.NullableFunction; @@ -113,9 +114,9 @@ public class SmartTypePointerManagerImpl extends SmartTypePointerManager { private static class ClassTypePointer extends TypePointerBase { private final SmartPsiElementPointer myClass; - private final Map, SmartTypePointer> myMap; + private final Map myMap; - public ClassTypePointer(@NotNull PsiClassType type, @NotNull SmartPsiElementPointer aClass, @NotNull Map, SmartTypePointer> map) { + public ClassTypePointer(@NotNull PsiClassType type, @NotNull SmartPsiElementPointer aClass, @NotNull Map map) { super(type); myClass = aClass; myMap = map; @@ -126,10 +127,10 @@ public class SmartTypePointerManagerImpl extends SmartTypePointerManager { final PsiElement classElement = myClass.getElement(); if (!(classElement instanceof PsiClass)) return null; Map resurrected = new HashMap<>(); - final Set, SmartTypePointer>> set = myMap.entrySet(); - for (Map.Entry, SmartTypePointer> entry : set) { + final Set> set = myMap.entrySet(); + for (Map.Entry entry : set) { PsiElement element = entry.getKey().getElement(); - if (element != null) { + if (element instanceof PsiTypeParameter) { SmartTypePointer typePointer = entry.getValue(); resurrected.put((PsiTypeParameter)element, typePointer == null ? null : typePointer.getType()); } @@ -186,22 +187,19 @@ public class SmartTypePointerManagerImpl extends SmartTypePointerManager { if (aClass == null) { return createClassReferenceTypePointer(classType); } + if (classType instanceof PsiClassReferenceType) { + classType = ((PsiClassReferenceType)classType).createImmediateCopy(); + } final PsiSubstitutor substitutor = resolveResult.getSubstitutor(); - final HashMap, SmartTypePointer> pointerMap = new HashMap<>(); - final Map map = new HashMap<>(); + final HashMap map = new HashMap<>(); for (PsiTypeParameter typeParameter : PsiUtil.typeParametersIterable(aClass)) { final PsiType substitutionResult = substitutor.substitute(typeParameter); if (substitutionResult != null) { - final SmartPsiElementPointer pointer = myPsiPointerManager.createSmartPsiElementPointer(typeParameter); - SmartTypePointer typePointer = substitutionResult.accept(this); - pointerMap.put(pointer, typePointer); - map.put(typeParameter, typePointer.getType()); + final SmartPsiElementPointer pointer = myPsiPointerManager.createSmartPsiElementPointer(typeParameter); + map.put(pointer, substitutionResult.accept(this)); } } - - return new ClassTypePointer(new PsiImmediateClassType(aClass, PsiSubstitutorImpl.createSubstitutor(map)), - myPsiPointerManager.createSmartPsiElementPointer(aClass), - pointerMap); + return new ClassTypePointer(classType, myPsiPointerManager.createSmartPsiElementPointer(aClass), map); } @Override diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiClassReferenceType.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiClassReferenceType.java index 30fe77f59f5e..8a460a3eac80 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiClassReferenceType.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiClassReferenceType.java @@ -217,6 +217,13 @@ public class PsiClassReferenceType extends PsiClassType.Stub { return getReference().getTypeParameters(); } + @NotNull + public PsiClassType createImmediateCopy() { + ClassResolveResult resolveResult = resolveGenerics(); + PsiClass element = resolveResult.getElement(); + return element == null ? this : new PsiImmediateClassType(element, resolveResult.getSubstitutor()); + } + @NotNull @Override public String getPresentableText(boolean annotated) {