1 files changed, 883 insertions, 0 deletions
diff --git a/java/typeMigration/test/com/intellij/refactoring/TypeMigrationTest.java b/java/typeMigration/test/com/intellij/refactoring/TypeMigrationTest.java
new file mode 100644
index 000000000000..b3c36dca19f2
--- /dev/null
+++ b/java/typeMigration/test/com/intellij/refactoring/TypeMigrationTest.java
@@ -0,0 +1,883 @@
+package com.intellij.refactoring;
+
+import com.intellij.openapi.roots.LanguageLevelProjectExtension;
+import com.intellij.pom.java.LanguageLevel;
+import com.intellij.psi.*;
+import com.intellij.psi.search.GlobalSearchScope;
+import com.intellij.psi.util.PsiTreeUtil;
+import com.intellij.refactoring.typeMigration.TypeMigrationRules;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author db
+ * @since 22.07.2003
+ */
+public class TypeMigrationTest extends TypeMigrationTestBase {
+  private PsiElementFactory myFactory;
+
+  @NotNull
+  @Override
+  public String getTestRoot() {
+    return "/refactoring/typeMigration/";
+  }
+
+  @Override
+  public void setUp() throws Exception {
+    super.setUp();
+    LanguageLevelProjectExtension.getInstance(getProject()).setLanguageLevel(LanguageLevel.HIGHEST);
+    myFactory = myJavaFacade.getElementFactory();
+  }
+
+  public void testT07() {
+    doTestFieldType("f",
+                    PsiType.INT.createArrayType(),
+                    myFactory.createTypeFromText("java.lang.Integer", null).createArrayType());
+  }
+
+  public void testT08() {
+    doTestFieldType("f",
+                    myFactory.createTypeFromText("java.lang.Integer", null).createArrayType(),
+                    myFactory.createTypeFromText("java.lang.String", null).createArrayType());
+  }
+
+  public void testT09() {
+    doTestFieldType("f",
+                    myFactory.createTypeFromText("java.lang.Integer", null).createArrayType(),
+                    myFactory.createTypeFromText("java.lang.String", null).createArrayType());
+  }
+
+  public void testT10() {
+    doTestFieldType("f",
+                    myFactory.createTypeFromText("java.util.List<java.lang.Integer>", null),
+                    myFactory.createTypeFromText("java.util.List<java.lang.String>", null));
+  }
+
+  public void testT11() {
+    doTestFieldType("f",
+                    myFactory.createTypeFromText("java.util.Map<java.lang.Integer, java.lang.Integer>", null),
+                    myFactory.createTypeFromText("java.util.Map<java.lang.String, java.lang.Integer>", null));
+  }
+
+  public void testT12() {
+    doTestFieldType("f",
+                    myFactory.createTypeFromText("java.util.List<java.lang.Integer>", null),
+                    myFactory.createTypeFromText("java.util.List<java.lang.String>", null));
+  }
+
+  public void testT13() {
+    doTestFieldType("f",
+                    myFactory.createTypeFromText("java.util.List<java.lang.String>", null),
+                    myFactory.createTypeFromText("java.util.List<java.lang.Integer>", null));
+  }
+
+  public void testT14() {
+    doTestFieldType("f",
+                    myFactory.createTypeFromText("B", null),
+                    myFactory.createTypeFromText("A", null));
+  }
+
+  //do not touch javadoc refs etc
+  public void testT15() {
+    doTestFieldType("f",
+                    myFactory.createTypeFromText("B", null),
+                    myFactory.createTypeFromText("A", null));
+  }
+
+  //do not touch signature with method type parameters
+  public void testT16() {
+    doTestFieldType("f",
+                    myFactory.createTypeFromText("A", null),
+                    myFactory.createTypeFromText("B", null));
+  }
+
+  //change method signature inspired by call on parameters
+  public void testT17() {
+    doTestFieldType("f",
+                    myFactory.createTypeFromText("A", null),
+                    myFactory.createTypeFromText("B", null));
+  }
+
+  //extending iterable -> used in foreach statement
+  public void testT18() {
+    doTestFieldType("f",
+                    myFactory.createTypeFromText("A", null),
+                    myFactory.createTypeFromText("B", null));
+  }
+
+  public void testT19() {
+    doTestFieldType("f",
+                    myFactory.createTypeFromText("java.util.Map<java.lang.String, java.lang.String>", null),
+                    myFactory.createTypeFromText("java.util.HashMap<java.lang.Integer, java.lang.Integer>", null));
+  }
+
+  public void testT20() {
+    doTestFieldType("f",
+                    myFactory.createTypeFromText("java.util.HashMap<java.lang.Integer, java.lang.Integer>", null),
+                    myFactory.createTypeFromText("java.util.Map<java.lang.String, java.lang.String>", null));
+  }
+
+  public void testT21() {
+    doTestFieldType("f",
+                    myFactory.createTypeFromText("java.util.Map<java.lang.String, java.util.List<java.lang.String>>",
+                                                 null),
+                    myFactory.createTypeFromText("java.util.Map<java.lang.String, java.util.Set<java.lang.String>>",
+                                                 null)
+    );
+  }
+
+  //varargs : removed after migration?!
+  public void testT22() {
+    doTestFieldType("f",
+                    myFactory.createTypeFromText("java.lang.String", null),
+                    myFactory.createTypeFromText("java.lang.Integer", null));
+  }
+
+  //substitution from super class: type params substitution needed
+  public void testT23() {
+    doTestFieldType("f",
+                    myFactory.createTypeFromText("HashMap<java.lang.String, java.util.Set<java.lang.String>>", null),
+                    myFactory.createTypeFromText("HashMap<java.lang.String, java.util.List<java.lang.String>>", null));
+  }
+
+  //check return type unchanged when it is possible
+  public void testT24() {
+    doTestFieldType("f",
+                    myFactory.createTypeFromText("C", null),
+                    myFactory.createTypeFromText("D", null));
+  }
+
+  public void testT25() {
+    doTestFieldType("f",
+                    myFactory.createTypeFromText("C", null),
+                    myFactory.createTypeFromText("D", null));
+  }
+
+  //check param type change
+  public void testT26() {
+    doTestFieldType("f",
+                    myFactory.createTypeFromText("C", null),
+                    myFactory.createTypeFromText("D", null));
+  }
+
+  public void testT27() {
+    doTestFieldType("f",
+                    myFactory.createTypeFromText("C", null),
+                    myFactory.createTypeFromText("D", null));
+  }
+
+  //list --> array
+  public void testT28() {
+    doTestFieldType("f",
+                    myFactory.createTypeFromText("java.util.List<java.lang.String>", null),
+                    myFactory.createTypeFromText("java.lang.String", null).createArrayType());
+  }
+
+  public void testT29() {
+    doTestMethodType("get",
+                     myFactory.createTypeFromText("java.lang.String", null).createArrayType(),
+                     myFactory.createTypeFromText("java.util.List<java.lang.String>", null));
+  }
+
+  public void testT30() {
+    doTestFieldType("f",
+                    myFactory.createTypeFromText("java.util.List<java.lang.String>", null),
+                    myFactory.createTypeFromText("java.lang.String", null).createArrayType());
+  }
+
+
+  public void testT31() {
+    doTestFieldType("f",
+                    myFactory.createTypeFromText("Test", null),
+                    myFactory.createTypeFromText(CommonClassNames.JAVA_LANG_OBJECT, null));
+  }
+
+  //non code usages
+  public void testT32() {
+    doTestFirstParamType("bar",
+                         myFactory.createTypeFromText("long", null),
+                         myFactory.createTypeFromText("int", null));
+  }
+
+  //change type arguments for new expressions: l = new ArrayList<String>() -> l = new ArrayList<Integer>()
+  public void testT33() {
+    doTestFieldType("l",
+                    myFactory.createTypeFromText("java.util.List<java.lang.String>", null),
+                    myFactory.createTypeFromText("java.util.List<java.lang.Integer>", null));
+  }
+
+  //new expression new ArrayList<String>() should be left without modifications
+  public void testT34() {
+    doTestFieldType("l",
+                    myFactory.createTypeFromText("java.util.List<java.lang.String>", null),
+                    myFactory.createTypeFromText("java.util.AbstractList<java.lang.String>", null));
+  }
+
+  public void testT35() {
+    doTestFieldType("myParent",
+                    myFactory.createTypeFromText("Test", null),
+                    myFactory.createTypeFromText("TestImpl", null));
+  }
+
+  //co-variant/contra-variant positions for primitive types 36-39
+  public void testT36() {
+    doTestFirstParamType("foo", PsiType.INT, PsiType.BYTE);
+  }
+
+  public void testT37() {
+    doTestFirstParamType("foo", PsiType.SHORT, PsiType.INT);
+  }
+
+  public void testT38() {
+    doTestFirstParamType("foo", PsiType.SHORT, PsiType.LONG);
+  }
+
+  public void testT39() {
+    doTestFirstParamType("foo", PsiType.SHORT, PsiType.BYTE);
+  }
+
+  //Set s = new HashSet() -> HashSet s = new HashSet();
+  public void testT40() {
+    doTestFieldType("l",
+                    myFactory.createTypeFromText(CommonClassNames.JAVA_UTIL_LIST, null),
+                    myFactory.createTypeFromText("java.util.ArrayList", null));
+  }
+
+  //Set s = new HashSet<String>() -> HashSet s = new HashSet<String>();
+  public void testT41() {
+    doTestFieldType("l",
+                    myFactory.createTypeFromText(CommonClassNames.JAVA_UTIL_LIST, null),
+                    myFactory.createTypeFromText("java.util.ArrayList", null));
+  }
+
+  //Set s = new HashSet() -> HashSet<String> s = new HashSet();
+  public void testT42() {
+    doTestFieldType("l",
+                    myFactory.createTypeFromText(CommonClassNames.JAVA_UTIL_LIST, null),
+                    myFactory.createTypeFromText("java.util.ArrayList<java.lang.String>", null));
+  }
+
+  //long l; Object o = l -> long l; Long o = l;
+  public void testT43() {
+    doTestFieldType("o",
+                    myFactory.createTypeFromText(CommonClassNames.JAVA_LANG_OBJECT, null),
+                    myFactory.createTypeFromText("java.lang.Long", null));
+  }
+
+  //long l; int  i; l = i; -> long l; byte i; l = i;
+  public void testT44() {
+    doTestFieldType("i", PsiType.INT, PsiType.BYTE);
+  }
+
+  //long l; int i; l = i; -> byte l; -> byte i; l = i;
+  public void testT45() {
+    doTestFieldType("l", PsiType.LONG, PsiType.BYTE);
+  }
+
+  //byte i; long j = i; -> byte i; int j = i;
+  public void testT46() {
+    doTestFieldType("j", PsiType.LONG, PsiType.INT);
+  }
+
+  //o = null -? int o = null
+  public void testT47() {
+    doTestFieldType("o", myFactory.createTypeFromText(CommonClassNames.JAVA_LANG_OBJECT, null), PsiType.INT);
+  }
+
+  //co-variant/contra-variant assignments: leave types if possible change generics signature only  48-49
+  // foo(AbstractSet<String> s){Set<String> ss = s} -> foo(AbstractSet<Integer> s){Set<Integer> ss = s}
+  public void testT48() {
+    doTestFirstParamType("foo",
+                         myFactory.createTypeFromText("java.util.AbstractSet<A>", null),
+                         myFactory.createTypeFromText("java.util.AbstractSet<B>", null));
+  }
+
+  // Set<String> f; foo(AbstractSet<String> s){f = s} -> Set<Integer>f; foo(AbstractSet<Integer> s){f = s}
+  public void testT49() {
+    doTestFieldType("f",
+                    myFactory.createTypeFromText("java.util.Set<A>", null),
+                    myFactory.createTypeFromText("java.util.Set<B>", null));
+  }
+
+  //captured wildcard: Set<? extends JComponent> s; Set<? extends JComponent> c1 = s; ->
+  //  Set<? extends JButton> s; Set<? extends JButton> c1 = s;
+  public void testT50() {
+    doTestFieldType("c1",
+                    myFactory.createTypeFromText("java.util.Set<? extends JComponent>", null),
+                    myFactory.createTypeFromText("java.util.Set<? extends JButton>", null));
+  }
+
+  //array initialization: 51-52
+  public void testT51() {
+    doTestFieldType("f",
+                    myFactory.createTypeFromText("java.lang.String", null).createArrayType(),
+                    myFactory.createTypeFromText(CommonClassNames.JAVA_LANG_OBJECT, null).createArrayType());
+  }
+
+  public void testT52() {
+    doTestFieldType("f",
+                    myFactory.createTypeFromText(CommonClassNames.JAVA_UTIL_SET, null).createArrayType(),
+                    myFactory.createTypeFromText(CommonClassNames.JAVA_LANG_OBJECT, null).createArrayType());
+  }
+
+  //generic type promotion to array initializer
+  public void testT53() {
+    doTestFieldType("f",
+                    PsiType.DOUBLE.createArrayType(),
+                    myFactory.createTypeFromText("java.util.Set<java.lang.String>", null).createArrayType());
+  }
+
+  //wildcard type promotion to expressions 54-55
+  public void testT54() {
+    doTestFieldType("f",
+                    myFactory.createTypeFromText("java.util.Set<java.lang.Object>", null),
+                    myFactory.createTypeFromText("java.util.Set<? extends java.lang.Integer>", null));
+  }
+
+  public void testT55() {
+    doTestFieldType("f",
+                    myFactory.createTypeFromText("java.util.Set<java.lang.Object>", null),
+                    myFactory.createTypeFromText("java.util.Set<?>", null));
+  }
+
+  //array index should be integer 56-57
+  public void testT56() {
+    doTestFirstParamType("foo", PsiType.INT, PsiType.DOUBLE);
+  }
+
+  public void testT57() {
+    doTestFirstParamType("foo", PsiType.INT, PsiType.BYTE);
+  }
+
+  //Arrays can be assignable to Object/Serializable/Cloneable 58-59; ~ 60 varargs
+  public void testT58() {
+    doTestFieldType("f",
+                    myFactory.createTypeFromText("java.lang.String", null).createArrayType(),
+                    myFactory.createTypeFromText(CommonClassNames.JAVA_LANG_OBJECT, null));
+  }
+
+  public void testT59() {
+    doTestFieldType("f",
+                    myFactory.createTypeFromText("java.lang.String", null).createArrayType(),
+                    myFactory.createTypeFromText("java.lang.Cloneable", null));
+  }
+
+  public void testT60() {
+    doTestFieldType("p",
+                    PsiType.INT.createArrayType(),
+                    myFactory.createTypeFromText(CommonClassNames.JAVA_LANG_OBJECT, null));
+  }
+
+  //change parameter type -> vararg; assignment changed to array
+  public void testT61() {
+    doTestFirstParamType("foo", PsiType.INT, new PsiEllipsisType(PsiType.INT));
+  }
+
+  //change field type -> change vararg parameter type due to assignment: 62-63
+  public void testT62() {
+    doTestFieldType("p", PsiType.INT.createArrayType(), myFactory.createTypeFromText(
+      CommonClassNames.JAVA_LANG_OBJECT, null));
+  }
+
+  public void testT63() {
+    doTestFieldType("p", PsiType.INT.createArrayType(), PsiType.DOUBLE.createArrayType());
+  }
+
+  //remove vararg type: 64-66
+  public void testT64() {
+    doTestFirstParamType("foo", new PsiEllipsisType(PsiType.INT), PsiType.INT);
+  }
+
+  public void testT65() {
+    doTestFirstParamType("foo",
+                         new PsiEllipsisType(PsiType.INT),
+                         myFactory.createTypeFromText("java.lang.String", null));
+  }
+
+  public void testT115() {
+    doTestFirstParamType("foo",
+                         new PsiEllipsisType(myFactory.createTypeFromText(CommonClassNames.JAVA_LANG_OBJECT, null)),
+                         new PsiEllipsisType(myFactory.createTypeFromText("java.lang.String", null)));
+  }
+
+  public void testT66() {
+    doTestFirstParamType("foo", new PsiEllipsisType(PsiType.INT), PsiType.INT);
+  }
+
+  public void testT67() {
+    doTestFirstParamType("methMemAcc",
+                         myFactory.createTypeFromText(CommonClassNames.JAVA_LANG_OBJECT, null),
+                         myFactory.createTypeFromText("java.lang.String", null));
+  }
+
+  public void testT68() {
+    doTestFirstParamType("foo", PsiType.INT, PsiType.DOUBLE);
+  }
+
+  public void testT69() {
+    doTestFirstParamType("foo", PsiType.INT, PsiType.BYTE);
+  }
+
+  public void testT70() {
+    doTestFieldType("a", PsiType.INT.createArrayType().createArrayType(), PsiType.FLOAT.createArrayType().createArrayType());
+  }
+
+  public void testT71() {
+    doTestFieldType("f",
+                    myFactory.createTypeFromText(CommonClassNames.JAVA_LANG_CLASS, null),
+                    myFactory.createTypeFromText("java.lang.Class<? extends java.lang.Number>", null));
+  }
+
+  public void testT72() {
+    doTestFieldType("f",
+                    myFactory.createTypeFromText(CommonClassNames.JAVA_LANG_CLASS, null),
+                    myFactory.createTypeFromText("java.lang.Class<java.lang.Integer>", null));
+  }
+
+  public void testT73() {
+    doTestFieldType("f",
+                    myFactory.createTypeFromText("java.util.Set<javax.swing.JComponent>", null).createArrayType().createArrayType(),
+                    myFactory.createTypeFromText("java.util.Set<java.awt.Component>", null).createArrayType().createArrayType());
+  }
+
+  //prefix/postfix expression; binary expressions 74-76
+  public void testT74() {
+    doTestFirstParamType("meth", PsiType.INT, PsiType.FLOAT);
+  }
+
+  public void testT75() {
+    doTestFirstParamType("meth", PsiType.INT, myFactory.createTypeFromText("java.lang.String", null));
+  }
+
+  public void testT76() {
+    doTestFirstParamType("meth", PsiType.BYTE, PsiType.FLOAT);
+  }
+
+  //+= , etc 77-78
+  public void testT77() {
+    doTestFirstParamType("meth", PsiType.INT, myFactory.createTypeFromText(CommonClassNames.JAVA_LANG_OBJECT, null));
+  }
+
+  public void testT78() {
+    doTestFirstParamType("meth", PsiType.INT, myFactory.createTypeFromText("java.lang.String", null));
+  }
+
+  //casts 79-80,83
+  public void testT79() {
+    doTestFirstParamType("meth", PsiType.INT, PsiType.BYTE);
+  }
+
+  public void testT80() {
+    doTestFirstParamType("meth", PsiType.INT, PsiType.DOUBLE);
+  }
+
+  public void testT83() {
+    doTestFirstParamType("meth", PsiType.INT, myFactory.createTypeFromText(CommonClassNames.JAVA_LANG_OBJECT, null));
+  }
+
+  //instanceofs 81-82
+  public void testT81() {
+    doTestFirstParamType("foo",
+                         myFactory.createTypeFromText(CommonClassNames.JAVA_LANG_OBJECT, null),
+                         myFactory.createTypeFromText("A", null));
+  }
+
+  public void testT82() {
+    doTestFirstParamType("foo",
+                         myFactory.createTypeFromText(CommonClassNames.JAVA_LANG_OBJECT, null),
+                         myFactory.createTypeFromText("C", null));
+  }
+
+  public void testT84() {
+    doTestFirstParamType("meth",
+                         myFactory.createTypeFromText(CommonClassNames.JAVA_UTIL_SET, null),
+                         myFactory.createTypeFromText("java.util.Set<? extends java.util.Set>", null));
+  }
+
+  public void testT85() {
+    doTestFieldType("str",
+                    myFactory.createTypeFromText("java.lang.String", null),
+                    myFactory.createTypeFromText("java.lang.Integer", null));
+  }
+
+  //array <-> list 86-89;94;95
+  public void testT86() {
+    doTestMethodType("getArray",
+                     myFactory.createTypeFromText("java.lang.String", null).createArrayType(),
+                     myFactory.createTypeFromText("java.util.List<java.lang.String>", null));
+  }
+
+   public void testT87() {
+    doTestMethodType("getArray",
+                     myFactory.createTypeFromText("java.util.List<java.lang.String>", null),
+                     myFactory.createTypeFromText("java.lang.String", null).createArrayType());
+  }
+
+  public void testT88() {
+    doTestMethodType("getArray",
+                     myFactory.createTypeFromText("java.lang.String", null).createArrayType(),
+                     myFactory.createTypeFromText("java.util.List<java.lang.String>", null));
+  }
+
+  public void testT89() {
+    doTestMethodType("getArray",
+                     myFactory.createTypeFromText("java.util.List<java.lang.String>", null),
+                     myFactory.createTypeFromText("java.lang.String", null).createArrayType());
+  }
+
+  public void testT94() {
+    doTestMethodType("getArray",
+                     myFactory.createTypeFromText("java.util.List<java.lang.String>", null),
+                     myFactory.createTypeFromText("java.lang.String", null).createArrayType());
+  }
+
+  public void testT95() {
+    doTestMethodType("getArray",
+                     myFactory.createTypeFromText("java.lang.String", null).createArrayType(),
+                     myFactory.createTypeFromText("java.util.List<java.lang.String>", null));
+  }
+
+
+  public void testT90() {
+    doTestFieldType("l",
+                    myFactory.createTypeFromText("java.util.List<B>", null),
+                    myFactory.createTypeFromText("java.util.List<A>", null));
+  }
+
+  //element type -> element type array
+  public void testT91() {
+    doTestMethodType("foo",
+                     myFactory.createTypeFromText("java.lang.String", null),
+                     myFactory.createTypeFromText("java.lang.String", null).createArrayType());
+  }
+
+  //List<S>=new ArrayList<S>{}; -> List<I>=new ArrayList<I>{}; anonymous
+  public void testT92() {
+    doTestFieldType("f",
+                    myFactory.createTypeFromText("java.util.List<java.lang.String>", null),
+                    myFactory.createTypeFromText("java.util.List<java.lang.Integer>", null));
+  }
+
+  //generics signature do not support primitives: Map<Boolean, String> - Map<boolean, String>
+  public void testT93() {
+    doTestFirstParamType("foo", myFactory.createTypeFromText("java.lang.Boolean", null), PsiType.BOOLEAN);
+  }
+
+  //field initializers procession
+  public void testT96() {
+    doTestFieldType("f1",
+                    myFactory.createTypeFromText("java.lang.Integer", null),
+                    myFactory.createTypeFromText("java.lang.String", null));
+  }
+
+  public void testT97() {
+    doTestFieldType("f1", myFactory.createTypeFromText("java.lang.Integer", null).createArrayType(), PsiType.INT);
+  }
+
+  //list <-> array conversion in assignment statements
+  public void testT98() {
+    doTestMethodType("getArray",
+                     myFactory.createTypeFromText("java.lang.String", null).createArrayType(),
+                     myFactory.createTypeFromText("java.util.List<java.lang.String>", null));
+  }
+
+  //escape pattern from []
+  public void testT99() {
+    doTestFieldType("f",
+                    myFactory.createTypeFromText("java.util.Set<java.util.List<char[]>>", null),
+                    myFactory.createTypeFromText("java.util.Set<java.util.List<int[]>>", null));
+  }
+
+  //non formatted type
+  public void testT100() {
+    doTestFieldType("f",
+                    myFactory.createTypeFromText("java.util.Map<java.lang.String,java.lang.String>", null),
+                    myFactory.createTypeFromText("java.util.Map<java.lang.String,java.lang.Integer>", null));
+  }
+
+  //param List -> Array[]
+  public void testT101() {
+    doTestFirstParamType("meth",
+                         myFactory.createTypeFromText("java.util.List<java.util.ArrayList<java.lang.Integer>>", null),
+                         myFactory.createTypeFromText("java.util.ArrayList<java.lang.Integer>[]", null));
+  }
+
+  //param Set.add() -> Array[] with conflict
+  public void testT102() {
+    doTestFirstParamType("method",
+                         myFactory.createTypeFromText("java.util.Set<? extends java.lang.Object>", null),
+                         myFactory.createTypeFromText("java.lang.Object[]", null));
+  }
+
+  //set(1, "") should be assignment-checked over String
+  public void testT103() {
+    doTestFirstParamType("method",
+                         myFactory.createTypeFromText("java.util.ArrayList<java.lang.String>", null),
+                         myFactory.createTypeFromText("java.lang.Integer", null).createArrayType());
+  }
+
+   //raw list type now should not be changed
+  public void testT104() {
+    doTestFirstParamType("method",
+                         myFactory.createTypeFromText("java.util.ArrayList", null),
+                         myFactory.createTypeFromText("java.lang.String", null).createArrayType());
+  }
+
+  //implicit type parameter change 105-107
+  public void testT105() {
+    doTestFieldType("t",
+                    myFactory.createTypeFromText("T", null),
+                    myFactory.createTypeFromText("java.lang.String", null));
+  }
+
+
+  public void testT106() {
+    doTestFieldType("t",
+                    myFactory.createTypeFromText("T", null),
+                    myFactory.createTypeFromText("java.lang.String", null));
+  }
+
+  public void testT107() {
+    doTestFieldType("t",
+                    myFactory.createTypeFromText("T", null),
+                    myFactory.createTypeFromText("java.lang.Integer", null));
+  }
+
+  //foreach && wildcards: 108-110
+  public void testT108() {
+    doTestFirstParamType("method",
+                         myFactory.createTypeFromText("java.util.List<java.lang.Integer>", null),
+                         myFactory.createTypeFromText("java.util.List<? extends java.lang.Number>", null));
+  }
+
+  public void testT109() {
+    doTestFirstParamType("method",
+                         myFactory.createTypeFromText("java.util.List<java.lang.Integer>", null),
+                         myFactory.createTypeFromText("java.util.List<? super java.lang.Number>", null));
+  }
+
+  public void testT110() {
+    doTestFirstParamType("method",
+                         myFactory.createTypeFromText("java.util.List<java.lang.Integer>", null),
+                         myFactory.createTypeFromText("java.util.List<? extends java.lang.String>", null));
+  }
+
+  //wrap with array creation only literals and refs outside of binary/unary expressions
+  public void testT111() {
+    doTestFirstParamType("method",
+                         myFactory.createTypeFromText("java.lang.Integer", null),
+                         myFactory.createTypeFromText("java.lang.Integer", null).createArrayType());
+  }
+
+  public void testT112() {
+    doTestMethodType("method",
+                     myFactory.createTypeFromText("java.lang.Integer", null),
+                     myFactory.createTypeFromText("java.lang.Integer", null).createArrayType());
+  }
+
+  //varargs
+  public void testT113() {
+    doTestFirstParamType("method",
+                         new PsiEllipsisType(myFactory.createTypeFromText("java.lang.Integer", null)),
+                         new PsiEllipsisType(myFactory.createTypeFromText("java.lang.Number", null)));
+  }
+
+  public void testT114() {
+      doTestFirstParamType("method",
+                           new PsiEllipsisType(myFactory.createTypeFromText("java.lang.Integer", null)),
+                           new PsiEllipsisType(myFactory.createTypeFromText("java.lang.String", null)));
+    }
+
+  //varargs && ArrayList
+  public void testT118() {
+    doTestFirstParamType("method",
+                         myFactory.createTypeFromText("java.lang.Integer", null),
+                         new PsiEllipsisType(myFactory.createTypeFromText("java.lang.Integer", null)));
+  }
+
+  //varargs && arrays
+  public void testT119() {
+    doTestFirstParamType("method",
+                         myFactory.createTypeFromText("java.lang.Integer", null),
+                         new PsiEllipsisType(myFactory.createTypeFromText("java.lang.Integer", null)));
+  }
+
+  public void testT120() {
+    doTestFirstParamType("method",
+                         myFactory.createTypeFromText("java.lang.Integer", null),
+                         new PsiEllipsisType(myFactory.createTypeFromText("java.lang.String", null)));
+  }
+
+  //change parameter type in foreach statement: 116 - array, 117 - list
+  public void testT116() {
+    doTestFieldType("str",
+                    myFactory.createTypeFromText("java.lang.Number", null),
+                    myFactory.createTypeFromText("java.lang.String", null));
+  }
+
+  public void testT117() {
+    doTestFieldType("str",
+                    myFactory.createTypeFromText("java.lang.Number", null),
+                    myFactory.createTypeFromText("java.lang.String", null));
+  }
+
+
+  public void testT121() {
+    doTestFirstParamType("method",
+                         myFactory.createTypeFromText("java.util.ArrayList<java.lang.Number>", null),
+                         myFactory.createTypeFromText("java.util.ArrayList<java.lang.Float>", null));
+  }
+
+  public void testT122() {
+    doTestFirstParamType("method",
+                         myFactory.createTypeFromText("java.util.List<java.util.ArrayList<java.lang.Integer>>", null),
+                         myFactory.createTypeFromText("java.util.List<java.lang.Integer>", null).createArrayType());
+  }
+
+  public void testT123() {
+    doTestFieldType("n",
+                    myFactory.createTypeFromText("java.lang.Number", null),
+                    myFactory.createTypeFromText("java.lang.Integer", null));
+  }
+
+  //124,125 - do not change formal method return type
+  public void testT124() {
+    doTestFirstParamType("meth",
+                         myFactory.createTypeFromText("T", null),
+                         myFactory.createTypeFromText("java.lang.Integer", null));
+  }
+
+  public void testT125() {
+    doTestFirstParamType("meth",
+                         myFactory.createTypeFromText("T", null),
+                         myFactory.createTypeFromText("java.lang.Integer", null));
+  }
+
+  public void testT126() {
+    doTestMethodType("meth",
+                     myFactory.createTypeFromText("java.lang.String", null),
+                     myFactory.createTypeFromText("T", null));
+  }
+
+  // Checking preserving method parameters alignment
+  public void testT127() {
+    getCurrentCodeStyleSettings().ALIGN_MULTILINE_PARAMETERS = true;
+    getCurrentCodeStyleSettings().ALIGN_MULTILINE_PARAMETERS_IN_CALLS = true;
+    doTestMethodType("test234",
+                     myFactory.createTypeFromText("int", null),
+                     myFactory.createTypeFromText("long", null));
+  }
+
+  // test type migration from disjunction type
+  public void testT128() {
+    doTestCatchParameter(myFactory.createTypeFromText("Test.E1 | Test.E2", null),
+                         myFactory.createTypeFromText("Test.E", null));
+  }
+
+  // test type migration to disjunction type
+  public void testT129() {
+    doTestCatchParameter(myFactory.createTypeFromText("Test.E", null),
+                         myFactory.createTypeFromText("Test.E1 | Test.E2", null));
+  }
+
+  // test type migration from disjunction type with interfaces
+  public void testT130() {
+    doTestCatchParameter(myFactory.createTypeFromText("Test.E1 | Test.E2", null),
+                         myFactory.createTypeFromText("Test.E", null));
+  }
+
+  // test type migration between disjunction types
+  public void testT131() {
+    doTestCatchParameter(myFactory.createTypeFromText("Test.E1 | Test.E2", null),
+                         myFactory.createTypeFromText("Test.E2 | Test.E1", null));
+  }
+
+  private void doTestCatchParameter(final PsiType rootType, final PsiType migrationType) {
+    start(new RulesProvider() {
+      @Override
+      public TypeMigrationRules provide() {
+        final TypeMigrationRules rules = new TypeMigrationRules(rootType);
+        rules.setMigrationRootType(migrationType);
+        return rules;
+      }
+
+      @Override
+      public PsiElement victims(final PsiClass aClass) {
+        final PsiCatchSection catchSection = PsiTreeUtil.findChildOfType(aClass, PsiCatchSection.class);
+        assert catchSection != null : aClass.getText();
+        final PsiParameter parameter = catchSection.getParameter();
+        assert parameter != null : catchSection.getText();
+        return parameter;
+      }
+    });
+  }
+
+  // IDEA-72420
+  public void testT132() {
+    doTestFirstParamType("h", "Test",
+                         myFactory.createTypeFromText("J", null),
+                         myFactory.createTypeFromText("I", null));
+  }
+
+  public void testT133() {
+    doTestFirstParamType("h", "Test",
+                         myFactory.createTypeFromText("J", null),
+                         myFactory.createTypeFromText("I", null));
+  }
+
+  public void testT134() {
+    doTestFirstParamType("buzz", "Test",
+                         PsiType.INT,
+                         myFactory.createTypeFromText("java.lang.String", null));
+  }
+
+  public void testT135() {
+    doTestFieldType("foo", "Test", PsiType.LONG, PsiType.INT);
+  }
+
+  public void testT136() {
+    final GlobalSearchScope scope = GlobalSearchScope.allScope(myProject);
+    doTestFirstParamType("foo", "Test",
+                         myFactory.createTypeByFQClassName(CommonClassNames.JAVA_LANG_INTEGER, scope),
+                         PsiType.getJavaLangString(myPsiManager, scope));
+  }
+
+  public void testT137() {
+    doTestFirstParamType("foo", "Test", PsiType.INT, myFactory.createTypeFromText("java.lang.String", null));
+  }
+
+  public void testT138() {
+    doTestFirstParamType("foo", "Test",
+                         myFactory.createTypeFromText("java.util.Set<java.lang.String>", null),
+                         myFactory.createTypeFromText("java.util.Collection<java.lang.String>", null));
+  }
+
+  public void testT139() {
+    doTestForeachParameter(myFactory.createTypeFromText("java.lang.String", null),
+                           myFactory.createTypeFromText("java.lang.Integer", null));
+  }
+
+  private void doTestForeachParameter(final PsiType rootType, final PsiType migrationType) {
+    start(new RulesProvider() {
+      @Override
+      public TypeMigrationRules provide() {
+        final TypeMigrationRules rules = new TypeMigrationRules(rootType);
+        rules.setMigrationRootType(migrationType);
+        return rules;
+      }
+
+      @Override
+      public PsiElement victims(final PsiClass aClass) {
+        final PsiForeachStatement foreachStatement = PsiTreeUtil.findChildOfType(aClass, PsiForeachStatement.class);
+        assert foreachStatement != null : aClass.getText();
+        return foreachStatement.getIterationParameter();
+      }
+    });
+  }
+
+
+  public void testTypeAnno() {
+    doTestFieldType("list", "Test",
+                    myFactory.createTypeFromText("java.util.ArrayList<java.lang.@TA Integer>", null),
+                    myFactory.createTypeFromText("java.util.Collection<java.lang.@TA Integer>", null));
+  }
+}