diff options
Diffstat (limited to 'java/typeMigration/testData/refactoring/typeMigrationByAtomic')
45 files changed, 688 insertions, 0 deletions
diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directAssignments/after/Test.items b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directAssignments/after/Test.items new file mode 100644 index 000000000000..9d1b1894378f --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directAssignments/after/Test.items @@ -0,0 +1,25 @@ +Types: +PsiAssignmentExpression:i += 2 : java.util.concurrent.atomic.AtomicInteger +PsiAssignmentExpression:i -= 5 : java.util.concurrent.atomic.AtomicInteger +PsiBinaryExpression:i + 9 : int +PsiBinaryExpression:i - 9 : int +PsiBinaryExpression:i == 0 : boolean +PsiField:i : java.util.concurrent.atomic.AtomicInteger +PsiReferenceExpression:i : java.util.concurrent.atomic.AtomicInteger +PsiReferenceExpression:i : java.util.concurrent.atomic.AtomicInteger +PsiReferenceExpression:i : java.util.concurrent.atomic.AtomicInteger +PsiReferenceExpression:i : java.util.concurrent.atomic.AtomicInteger +PsiReferenceExpression:i : java.util.concurrent.atomic.AtomicInteger +PsiReferenceExpression:i : java.util.concurrent.atomic.AtomicInteger + +Conversions: +0 -> new java.util.concurrent.atomic.AtomicInteger($val$) $val$ +9 -> $qualifier$.set($val$) $qualifier$ = $val$ i = 9 +i + 9 -> $qualifier$.get() + $val$ $qualifier$+$val$ +i += 2 -> $qualifier$.getAndAdd(($val$)) $qualifier$ += $val$ +i - 9 -> $qualifier$.get() - $val$ $qualifier$-$val$ +i -= 5 -> $qualifier$.getAndAdd(-($val$)) $qualifier$ -= $val$ +i == 0 -> $qualifier$.get() == $val$ $qualifier$==$val$ + +New expression type changes: +Fails: diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directAssignments/after/Test.java b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directAssignments/after/Test.java new file mode 100644 index 000000000000..5c16607a8b70 --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directAssignments/after/Test.java @@ -0,0 +1,16 @@ +import java.util.concurrent.atomic.AtomicInteger; + +class Test { + AtomicInteger i = new AtomicInteger(0); + + void foo() { + i.getAndAdd((2)); + i.getAndAdd(-(5)); + if (i.get() == 0) { + i.set(9); + } + + System.out.println(i.get() + 9); + System.out.println(i.get() - 9); + } +}
\ No newline at end of file diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directAssignments/before/Test.java b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directAssignments/before/Test.java new file mode 100644 index 000000000000..b96f02057dfd --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directAssignments/before/Test.java @@ -0,0 +1,14 @@ +class Test { + int i = 0; + + void foo() { + i += 2; + i -= 5; + if (i == 0) { + i = 9; + } + + System.out.println(i + 9); + System.out.println(i - 9); + } +}
\ No newline at end of file diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directByte/after/Test.items b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directByte/after/Test.items new file mode 100644 index 000000000000..e0e121ecf00d --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directByte/after/Test.items @@ -0,0 +1,19 @@ +Types: +PsiAssignmentExpression:b += 0 : java.util.concurrent.atomic.AtomicReference<java.lang.Byte> +PsiBinaryExpression:b == 0 : boolean +PsiField:b : java.util.concurrent.atomic.AtomicReference<java.lang.Byte> +PsiPostfixExpression:b++ : java.util.concurrent.atomic.AtomicReference<java.lang.Byte> +PsiReferenceExpression:b : java.util.concurrent.atomic.AtomicReference<java.lang.Byte> +PsiReferenceExpression:b : java.util.concurrent.atomic.AtomicReference<java.lang.Byte> +PsiReferenceExpression:b : java.util.concurrent.atomic.AtomicReference<java.lang.Byte> +PsiReferenceExpression:b : java.util.concurrent.atomic.AtomicReference<java.lang.Byte> + +Conversions: +0 -> new java.util.concurrent.atomic.AtomicReference<java.lang.Byte>((byte)$val$) $val$ +b += 0 -> $qualifier$.set(new Byte((byte)($qualifier$.get() + $val$))) $qualifier$+=$val$ +b -> $qualifier$.get() $qualifier$ b +b == 0 -> $qualifier$.get() == $val$ $qualifier$==$val$ +b++ -> $qualifier$.getAndSet(new Byte((byte)($qualifier$.get() + 1))) $qualifier$++ + +New expression type changes: +Fails: diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directByte/after/Test.java b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directByte/after/Test.java new file mode 100644 index 000000000000..a1dbfc714326 --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directByte/after/Test.java @@ -0,0 +1,14 @@ +import java.util.concurrent.atomic.AtomicReference; + +class Test { + AtomicReference<Byte> b = new AtomicReference<Byte>((byte) 0); + + void bar() { + if (b.get() == 0) { + b.getAndSet(new Byte((byte) (b.get() + 1))); + b.set(new Byte((byte) (b.get() + 0))); + //System.out.println(b + 10); + System.out.println(b.get()); + } + } +}
\ No newline at end of file diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directByte/before/Test.java b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directByte/before/Test.java new file mode 100644 index 000000000000..fa494c28a3c4 --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directByte/before/Test.java @@ -0,0 +1,12 @@ +class Test { + byte b = 0; + + void bar() { + if (b == 0) { + b++; + b += 0; + //System.out.println(b + 10); + System.out.println(b); + } + } +}
\ No newline at end of file diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directConditions/after/Test.items b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directConditions/after/Test.items new file mode 100644 index 000000000000..95f366691485 --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directConditions/after/Test.items @@ -0,0 +1,11 @@ +Types: +PsiField:b : java.util.concurrent.atomic.AtomicBoolean +PsiReferenceExpression:b : java.util.concurrent.atomic.AtomicBoolean +PsiReferenceExpression:b : java.util.concurrent.atomic.AtomicBoolean + +Conversions: +b -> $qualifier$.get() $qualifier$ b +true -> $qualifier$.set($val$) $qualifier$ = $val$ b = true + +New expression type changes: +Fails: diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directConditions/after/Test.java b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directConditions/after/Test.java new file mode 100644 index 000000000000..02fc40276a86 --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directConditions/after/Test.java @@ -0,0 +1,11 @@ +import java.util.concurrent.atomic.AtomicBoolean; + +class Test { + AtomicBoolean b; + + void foo() { + if (b.get()) { + b.set(true); + } + } +}
\ No newline at end of file diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directConditions/before/Test.java b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directConditions/before/Test.java new file mode 100644 index 000000000000..ef5413600c40 --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directConditions/before/Test.java @@ -0,0 +1,9 @@ +class Test { + boolean b; + + void foo() { + if (b) { + b = true; + } + } +}
\ No newline at end of file diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directForeach/after/Test.items b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directForeach/after/Test.items new file mode 100644 index 000000000000..add3ea1f98e3 --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directForeach/after/Test.items @@ -0,0 +1,9 @@ +Types: +PsiField:lst : java.util.concurrent.atomic.AtomicReference<java.util.List<java.lang.String>> +PsiReferenceExpression:lst : java.util.concurrent.atomic.AtomicReference<java.util.List<java.lang.String>> + +Conversions: +lst -> $qualifier$.get() $qualifier$ lst + +New expression type changes: +Fails: diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directForeach/after/Test.java b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directForeach/after/Test.java new file mode 100644 index 000000000000..4db9a5619849 --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directForeach/after/Test.java @@ -0,0 +1,12 @@ +import java.util.*; +import java.util.concurrent.atomic.AtomicReference; + +class Test { + AtomicReference<List<String>> lst; + + void foo() { + for (String s : lst.get()) { + System.out.println(s); + } + } +}
\ No newline at end of file diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directForeach/before/Test.java b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directForeach/before/Test.java new file mode 100644 index 000000000000..1d40f4082444 --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directForeach/before/Test.java @@ -0,0 +1,11 @@ +import java.util.*; + +class Test { + List<String> lst; + + void foo() { + for (String s : lst) { + System.out.println(s); + } + } +}
\ No newline at end of file diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directIncrementDecrement/after/Test.items b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directIncrementDecrement/after/Test.items new file mode 100644 index 000000000000..852aa470a285 --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directIncrementDecrement/after/Test.items @@ -0,0 +1,25 @@ +Types: +PsiField:i : java.util.concurrent.atomic.AtomicInteger +PsiPostfixExpression:i++ : java.util.concurrent.atomic.AtomicInteger +PsiPostfixExpression:i++ : java.util.concurrent.atomic.AtomicInteger +PsiPostfixExpression:i-- : java.util.concurrent.atomic.AtomicInteger +PsiPrefixExpression:++i : java.util.concurrent.atomic.AtomicInteger +PsiPrefixExpression:--i : java.util.concurrent.atomic.AtomicInteger +PsiPrefixExpression:--i : java.util.concurrent.atomic.AtomicInteger +PsiReferenceExpression:i : java.util.concurrent.atomic.AtomicInteger +PsiReferenceExpression:i : java.util.concurrent.atomic.AtomicInteger +PsiReferenceExpression:i : java.util.concurrent.atomic.AtomicInteger +PsiReferenceExpression:i : java.util.concurrent.atomic.AtomicInteger +PsiReferenceExpression:i : java.util.concurrent.atomic.AtomicInteger +PsiReferenceExpression:i : java.util.concurrent.atomic.AtomicInteger + +Conversions: +++i -> $qualifier$.incrementAndGet() ++$qualifier$ +--i -> $qualifier$.decrementAndGet() --$qualifier$ +--i -> $qualifier$.decrementAndGet() --$qualifier$ +i++ -> $qualifier$.getAndIncrement() $qualifier$++ +i++ -> $qualifier$.getAndIncrement() $qualifier$++ +i-- -> $qualifier$.getAndDecrement() $qualifier$-- + +New expression type changes: +Fails: diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directIncrementDecrement/after/Test.java b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directIncrementDecrement/after/Test.java new file mode 100644 index 000000000000..bdcf7171016b --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directIncrementDecrement/after/Test.java @@ -0,0 +1,14 @@ +import java.util.concurrent.atomic.AtomicInteger; + +class Test { + AtomicInteger i; + + void foo() { + i.getAndIncrement(); + i.incrementAndGet(); + i.getAndDecrement(); + i.decrementAndGet(); + System.out.println(i.getAndIncrement()); + System.out.println(i.decrementAndGet()); + } +}
\ No newline at end of file diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directIncrementDecrement/before/Test.java b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directIncrementDecrement/before/Test.java new file mode 100644 index 000000000000..be6aa55d5f29 --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directIncrementDecrement/before/Test.java @@ -0,0 +1,12 @@ +class Test { + int i; + + void foo() { + i++; + ++i; + i--; + --i; + System.out.println(i++); + System.out.println(--i); + } +}
\ No newline at end of file diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directIntArray/after/Test.items b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directIntArray/after/Test.items new file mode 100644 index 000000000000..69a66c34a6cb --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directIntArray/after/Test.items @@ -0,0 +1,34 @@ +Types: +PsiArrayAccessExpression:a[0] : int +PsiArrayAccessExpression:a[0] : int +PsiArrayAccessExpression:a[0] : int +PsiArrayAccessExpression:a[0] : int +PsiArrayAccessExpression:a[0] : int +PsiArrayAccessExpression:a[0] : int +PsiArrayAccessExpression:a[0] : int +PsiArrayAccessExpression:a[0] : int +PsiField:a : java.util.concurrent.atomic.AtomicIntegerArray +PsiReferenceExpression:a : java.util.concurrent.atomic.AtomicIntegerArray +PsiReferenceExpression:a : java.util.concurrent.atomic.AtomicIntegerArray +PsiReferenceExpression:a : java.util.concurrent.atomic.AtomicIntegerArray +PsiReferenceExpression:a : java.util.concurrent.atomic.AtomicIntegerArray +PsiReferenceExpression:a : java.util.concurrent.atomic.AtomicIntegerArray +PsiReferenceExpression:a : java.util.concurrent.atomic.AtomicIntegerArray +PsiReferenceExpression:a : java.util.concurrent.atomic.AtomicIntegerArray +PsiReferenceExpression:a : java.util.concurrent.atomic.AtomicIntegerArray +PsiReferenceExpression:a : java.util.concurrent.atomic.AtomicIntegerArray + +Conversions: +a[0] -> $qualifier$.decrementAndGet($idx$) --$qualifier$[$idx$] --a[0] +a[0] -> $qualifier$.get($idx$) $qualifier$[$idx$] a[0] +a[0] -> $qualifier$.get($idx$) $qualifier$[$idx$] a[0] +a[0] -> $qualifier$.getAndAdd($idx$, ($val$)) $qualifier$[$idx$] += $val$ a[0] += (2) +a[0] -> $qualifier$.getAndDecrement($idx$) $qualifier$[$idx$]-- a[0]-- +a[0] -> $qualifier$.getAndIncrement($idx$) $qualifier$[$idx$]++ a[0]++ +a[0] -> $qualifier$.incrementAndGet($idx$) ++$qualifier$[$idx$] ++a[0] +a[0] -> $qualifier$.set($idx$, $qualifier$.get($idx$) * $val$) $qualifier$[$idx$]*=$val$ a[0] *= 2 +new int[0] -> new java.util.concurrent.atomic.AtomicIntegerArray($val$) $val$ new int[0] +new int[1] -> new java.util.concurrent.atomic.AtomicIntegerArray($val$) $val$ new int[1] + +New expression type changes: +Fails: diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directIntArray/after/Test.java b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directIntArray/after/Test.java new file mode 100644 index 000000000000..8dbba12048fe --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directIntArray/after/Test.java @@ -0,0 +1,20 @@ +import java.util.concurrent.atomic.AtomicIntegerArray; + +class Test { + AtomicIntegerArray a = new AtomicIntegerArray(new int[1]); + + + void foo() { + a.getAndIncrement(0); + System.out.println(a.incrementAndGet(0)); + a.getAndDecrement(0); + if (a.decrementAndGet(0) == 0) { + a.getAndAdd(0, ((2))); + a.set(0, a.get(0) * 2); + if (a.get(0) == 0) { + System.out.println(a.get(0) + 7); + } + } + a = new AtomicIntegerArray(new int[0]); + } +}
\ No newline at end of file diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directIntArray/before/Test.java b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directIntArray/before/Test.java new file mode 100644 index 000000000000..5d39cf2963c6 --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directIntArray/before/Test.java @@ -0,0 +1,18 @@ +class Test { + int[] a = new int[1]; + + + void foo() { + a[0]++; + System.out.println(++a[0]); + a[0]--; + if (--a[0] == 0) { + a[0] += (2); + a[0] *= 2; + if (a[0] == 0) { + System.out.println(a[0] + 7); + } + } + a = new int[0]; + } +}
\ No newline at end of file diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directString/after/Test.items b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directString/after/Test.items new file mode 100644 index 000000000000..0d306b0b4747 --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directString/after/Test.items @@ -0,0 +1,11 @@ +Types: +PsiField:s : java.util.concurrent.atomic.AtomicReference<java.lang.String> +PsiReferenceExpression:s : java.util.concurrent.atomic.AtomicReference<java.lang.String> +PsiReferenceExpression:s : java.util.concurrent.atomic.AtomicReference<java.lang.String> + +Conversions: +"" -> new java.util.concurrent.atomic.AtomicReference<java.lang.String>($val$) $val$ +s -> $qualifier$.get() $qualifier$ s + +New expression type changes: +Fails: diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directString/after/Test.java b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directString/after/Test.java new file mode 100644 index 000000000000..cb32e0ba130b --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directString/after/Test.java @@ -0,0 +1,11 @@ +import java.util.concurrent.atomic.AtomicReference; + +class Test { + AtomicReference<String> s = new AtomicReference<String>(""); + + void foo() { + if (s == null) { + System.out.println(s.get()); + } + } +}
\ No newline at end of file diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directString/before/Test.java b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directString/before/Test.java new file mode 100644 index 000000000000..1770416a0295 --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directString/before/Test.java @@ -0,0 +1,9 @@ +class Test { + String s = ""; + + void foo() { + if (s == null) { + System.out.println(s); + } + } +}
\ No newline at end of file diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directStringArray/after/Test.items b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directStringArray/after/Test.items new file mode 100644 index 000000000000..b90b4a347f40 --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directStringArray/after/Test.items @@ -0,0 +1,14 @@ +Types: +PsiArrayAccessExpression:s[0] : java.lang.String +PsiArrayAccessExpression:s[0] : java.lang.String +PsiField:s : java.util.concurrent.atomic.AtomicReferenceArray<java.lang.String> +PsiReferenceExpression:s : java.util.concurrent.atomic.AtomicReferenceArray<java.lang.String> +PsiReferenceExpression:s : java.util.concurrent.atomic.AtomicReferenceArray<java.lang.String> + +Conversions: +new String[2] -> new java.util.concurrent.atomic.AtomicReferenceArray<java.lang.String>($val$) $val$ new String[2] +s[0] -> $qualifier$.get($idx$) $qualifier$[$idx$] s[0] +s[0] -> $qualifier$.set($idx$, $val$) $qualifier$[$idx$] = $val$ s[0] = "" + +New expression type changes: +Fails: diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directStringArray/after/Test.java b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directStringArray/after/Test.java new file mode 100644 index 000000000000..42415d0c3141 --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directStringArray/after/Test.java @@ -0,0 +1,11 @@ +import java.util.concurrent.atomic.AtomicReferenceArray; + +class Test { + AtomicReferenceArray<String> s = new AtomicReferenceArray<String>(new String[2]); + + void foo() { + s.set(0, ""); + System.out.println(s.get(0)); + + } +}
\ No newline at end of file diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directStringArray/before/Test.java b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directStringArray/before/Test.java new file mode 100644 index 000000000000..4f19feba6479 --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/directStringArray/before/Test.java @@ -0,0 +1,9 @@ +class Test { + String[] s = new String[2]; + + void foo() { + s[0] = ""; + System.out.println(s[0]); + + } +}
\ No newline at end of file diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseAssignments/after/Test.items b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseAssignments/after/Test.items new file mode 100644 index 000000000000..767993764c48 --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseAssignments/after/Test.items @@ -0,0 +1,26 @@ +Types: +PsiField:i : int +PsiMethodCallExpression:i.addAndGet(-(9)) : int +PsiMethodCallExpression:i.addAndGet(9) : int +PsiMethodCallExpression:i.get() : int +PsiMethodCallExpression:i.getAndAdd(-5) : int +PsiMethodCallExpression:i.getAndAdd(2) : int +PsiMethodCallExpression:i.set(9) : void +PsiReferenceExpression:i : int +PsiReferenceExpression:i : int +PsiReferenceExpression:i : int +PsiReferenceExpression:i : int +PsiReferenceExpression:i : int +PsiReferenceExpression:i : int + +Conversions: +i.addAndGet(-(9)) -> $qualifier$ + $delta$ $qualifier$.addAndGet($delta$) +i.addAndGet(9) -> $qualifier$ + $delta$ $qualifier$.addAndGet($delta$) +i.get() -> $qualifier$ $qualifier$.get() +i.getAndAdd(-5) -> $qualifier$ += $val$ $qualifier$.getAndAdd($val$) +i.getAndAdd(2) -> $qualifier$ += $val$ $qualifier$.getAndAdd($val$) +i.set(9) -> $qualifier$ = $val$ $qualifier$.set($val$) +new AtomicInteger(0) -> $qualifier$ new $type$($qualifier$) + +New expression type changes: +Fails: diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseAssignments/after/Test.java b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseAssignments/after/Test.java new file mode 100644 index 000000000000..1372ccee2b27 --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseAssignments/after/Test.java @@ -0,0 +1,15 @@ +import java.util.concurrent.atomic.AtomicInteger; +class Test { + int i = 0; + + void foo() { + i += 2; + i += -5; + if (i == 0) { + i = 9; + } + + System.out.println(i + 9); + System.out.println(i + -(9)); + } +}
\ No newline at end of file diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseAssignments/before/Test.java b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseAssignments/before/Test.java new file mode 100644 index 000000000000..cfd312daa073 --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseAssignments/before/Test.java @@ -0,0 +1,15 @@ +import java.util.concurrent.atomic.AtomicInteger; +class Test { + AtomicInteger i = new AtomicInteger(0); + + void foo() { + i.getAndAdd(2); + i.getAndAdd(-5); + if (i.get() == 0) { + i.set(9); + } + + System.out.println(i.addAndGet(9)); + System.out.println(i.addAndGet(-(9))); + } +}
\ No newline at end of file diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseByte/after/Test.items b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseByte/after/Test.items new file mode 100644 index 000000000000..8585bda9e020 --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseByte/after/Test.items @@ -0,0 +1,26 @@ +Types: +PsiField:b : byte +PsiMethodCallExpression:b.get() : java.lang.Byte +PsiMethodCallExpression:b.get() : java.lang.Byte +PsiMethodCallExpression:b.get() : java.lang.Byte +PsiMethodCallExpression:b.get() : java.lang.Byte +PsiMethodCallExpression:b.getAndSet(new Byte((byte) (b.get() + 1))) : java.lang.Byte +PsiMethodCallExpression:b.set(new Byte((byte) (b.get() + 0))) : void +PsiReferenceExpression:b : byte +PsiReferenceExpression:b : byte +PsiReferenceExpression:b : byte +PsiReferenceExpression:b : byte +PsiReferenceExpression:b : byte +PsiReferenceExpression:b : byte + +Conversions: +b.get() -> $qualifier$ $qualifier$.get() +b.get() -> $qualifier$ $qualifier$.get() +b.get() -> $qualifier$ $qualifier$.get() +b.get() -> $qualifier$ $qualifier$.get() +b.getAndSet(new Byte((byte) (b.get() + 1))) -> $qualifier$ = $val$ $qualifier$.getAndSet($val$) +b.set(new Byte((byte) (b.get() + 0))) -> $qualifier$ = $val$ $qualifier$.set($val$) +new AtomicReference<Byte>((byte) 0) -> $qualifier$ new $type$($qualifier$) + +New expression type changes: +Fails: diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseByte/after/Test.java b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseByte/after/Test.java new file mode 100644 index 000000000000..28445dd31728 --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseByte/after/Test.java @@ -0,0 +1,14 @@ +import java.util.concurrent.atomic.AtomicReference; + +class Test { + byte b = (byte) 0; + + void bar() { + if (b == 0) { + b = new Byte((byte) (b + 1)); + b = new Byte((byte) (b + 0)); + //System.out.println(b + 10); + System.out.println(b); + } + } +}
\ No newline at end of file diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseByte/before/Test.java b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseByte/before/Test.java new file mode 100644 index 000000000000..a1dbfc714326 --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseByte/before/Test.java @@ -0,0 +1,14 @@ +import java.util.concurrent.atomic.AtomicReference; + +class Test { + AtomicReference<Byte> b = new AtomicReference<Byte>((byte) 0); + + void bar() { + if (b.get() == 0) { + b.getAndSet(new Byte((byte) (b.get() + 1))); + b.set(new Byte((byte) (b.get() + 0))); + //System.out.println(b + 10); + System.out.println(b.get()); + } + } +}
\ No newline at end of file diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseConditions/after/Test.items b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseConditions/after/Test.items new file mode 100644 index 000000000000..3594508bebe5 --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseConditions/after/Test.items @@ -0,0 +1,13 @@ +Types: +PsiField:b : boolean +PsiMethodCallExpression:b.get() : boolean +PsiMethodCallExpression:b.set(true) : void +PsiReferenceExpression:b : boolean +PsiReferenceExpression:b : boolean + +Conversions: +b.get() -> $qualifier$ $qualifier$.get() +b.set(true) -> $qualifier$ = $val$ $qualifier$.set($val$) + +New expression type changes: +Fails: diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseConditions/after/Test.java b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseConditions/after/Test.java new file mode 100644 index 000000000000..92f515c35936 --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseConditions/after/Test.java @@ -0,0 +1,10 @@ +import java.util.concurrent.atomic.AtomicBoolean; +class Test { + boolean b; + + void foo() { + if (b) { + b = true; + } + } +}
\ No newline at end of file diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseConditions/before/Test.java b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseConditions/before/Test.java new file mode 100644 index 000000000000..5464f705ddeb --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseConditions/before/Test.java @@ -0,0 +1,10 @@ +import java.util.concurrent.atomic.AtomicBoolean; +class Test { + AtomicBoolean b; + + void foo() { + if (b.get()) { + b.set(true); + } + } +}
\ No newline at end of file diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseIncrementDecrement/after/Test.items b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseIncrementDecrement/after/Test.items new file mode 100644 index 000000000000..cba5bc10f359 --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseIncrementDecrement/after/Test.items @@ -0,0 +1,25 @@ +Types: +PsiField:i : int +PsiMethodCallExpression:i.decrementAndGet() : int +PsiMethodCallExpression:i.decrementAndGet() : int +PsiMethodCallExpression:i.getAndDecrement() : int +PsiMethodCallExpression:i.getAndIncrement() : int +PsiMethodCallExpression:i.getAndIncrement() : int +PsiMethodCallExpression:i.incrementAndGet() : int +PsiReferenceExpression:i : int +PsiReferenceExpression:i : int +PsiReferenceExpression:i : int +PsiReferenceExpression:i : int +PsiReferenceExpression:i : int +PsiReferenceExpression:i : int + +Conversions: +i.decrementAndGet() -> --$qualifier$ $qualifier$.decrementAndGet() +i.decrementAndGet() -> --$qualifier$ $qualifier$.decrementAndGet() +i.getAndDecrement() -> $qualifier$-- $qualifier$.getAndDecrement() +i.getAndIncrement() -> $qualifier$++ $qualifier$.getAndIncrement() +i.getAndIncrement() -> $qualifier$++ $qualifier$.getAndIncrement() +i.incrementAndGet() -> ++$qualifier$ $qualifier$.incrementAndGet() + +New expression type changes: +Fails: diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseIncrementDecrement/after/Test.java b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseIncrementDecrement/after/Test.java new file mode 100644 index 000000000000..dd70e550a751 --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseIncrementDecrement/after/Test.java @@ -0,0 +1,13 @@ +import java.util.concurrent.atomic.AtomicInteger; +class Test { + int i; + + void foo() { + i++; + ++i; + i--; + --i; + System.out.println(i++); + System.out.println(--i); + } +}
\ No newline at end of file diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseIncrementDecrement/before/Test.java b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseIncrementDecrement/before/Test.java new file mode 100644 index 000000000000..853e5387aca9 --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseIncrementDecrement/before/Test.java @@ -0,0 +1,13 @@ +import java.util.concurrent.atomic.AtomicInteger; +class Test { + AtomicInteger i; + + void foo() { + i.getAndIncrement(); + i.incrementAndGet(); + i.getAndDecrement(); + i.decrementAndGet(); + System.out.println(i.getAndIncrement()); + System.out.println(i.decrementAndGet()); + } +}
\ No newline at end of file diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseIntArray/after/Test.items b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseIntArray/after/Test.items new file mode 100644 index 000000000000..55c1c7bc2574 --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseIntArray/after/Test.items @@ -0,0 +1,35 @@ +Types: +PsiField:a : int[] +PsiMethodCallExpression:a.addAndGet(0, 7) : int +PsiMethodCallExpression:a.decrementAndGet(0) : int +PsiMethodCallExpression:a.get(0) : int +PsiMethodCallExpression:a.get(0) : int +PsiMethodCallExpression:a.getAndAdd(0, ((2))) : int +PsiMethodCallExpression:a.getAndDecrement(0) : int +PsiMethodCallExpression:a.getAndIncrement(0) : int +PsiMethodCallExpression:a.incrementAndGet(0) : int +PsiMethodCallExpression:a.set(0, a.get(0) * 2) : void +PsiReferenceExpression:a : int[] +PsiReferenceExpression:a : int[] +PsiReferenceExpression:a : int[] +PsiReferenceExpression:a : int[] +PsiReferenceExpression:a : int[] +PsiReferenceExpression:a : int[] +PsiReferenceExpression:a : int[] +PsiReferenceExpression:a : int[] +PsiReferenceExpression:a : int[] + +Conversions: +a.addAndGet(0, 7) -> $qualifier$[$idx$] + $delta$ $qualifier$.addAndGet($idx$, $delta$) +a.decrementAndGet(0) -> --$qualifier$[$idx$] $qualifier$.decrementAndGet($idx$) +a.get(0) -> $qualifier$[$idx$] $qualifier$.get($idx$) +a.get(0) -> $qualifier$[$idx$] $qualifier$.get($idx$) +a.getAndAdd(0, ((2))) -> $qualifier$[$idx$] += $val$ $qualifier$.getAndAdd($idx$, $val$) +a.getAndDecrement(0) -> $qualifier$[$idx$]-- $qualifier$.getAndDecrement($idx$) +a.getAndIncrement(0) -> $qualifier$[$idx$]++ $qualifier$.getAndIncrement($idx$) +a.incrementAndGet(0) -> ++$qualifier$[$idx$] $qualifier$.incrementAndGet($idx$) +a.set(0, a.get(0) * 2) -> $qualifier$[$idx$] = $val$ $qualifier$.set($idx$, $val$) +new AtomicIntegerArray(new int[1]) -> $qualifier$ new $type$($qualifier$) + +New expression type changes: +Fails: diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseIntArray/after/Test.java b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseIntArray/after/Test.java new file mode 100644 index 000000000000..401714230d3c --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseIntArray/after/Test.java @@ -0,0 +1,19 @@ +import java.util.concurrent.atomic.AtomicIntegerArray; + +class Test { + int[] a = new int[1]; + + + void foo() { + a[0]++; + System.out.println(++a[0]); + a[0]--; + if (--a[0] == 0) { + a[0] += ((2)); + a[0] = a[0] * 2; + if (a[0] == 0) { + System.out.println(a[0] + 7); + } + } + } +}
\ No newline at end of file diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseIntArray/before/Test.java b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseIntArray/before/Test.java new file mode 100644 index 000000000000..df31528b9d7e --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseIntArray/before/Test.java @@ -0,0 +1,19 @@ +import java.util.concurrent.atomic.AtomicIntegerArray; + +class Test { + AtomicIntegerArray a = new AtomicIntegerArray(new int[1]); + + + void foo() { + a.getAndIncrement(0); + System.out.println(a.incrementAndGet(0)); + a.getAndDecrement(0); + if (a.decrementAndGet(0) == 0) { + a.getAndAdd(0, ((2))); + a.set(0, a.get(0) * 2); + if (a.get(0) == 0) { + System.out.println(a.addAndGet(0, 7)); + } + } + } +}
\ No newline at end of file diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseString/after/Test.items b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseString/after/Test.items new file mode 100644 index 000000000000..7c23d49d8bfd --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseString/after/Test.items @@ -0,0 +1,12 @@ +Types: +PsiField:s : java.lang.String +PsiMethodCallExpression:s.get() : java.lang.String +PsiReferenceExpression:s : java.lang.String +PsiReferenceExpression:s : java.lang.String + +Conversions: +new AtomicReference<String>("") -> $qualifier$ new $type$($qualifier$) +s.get() -> $qualifier$ $qualifier$.get() + +New expression type changes: +Fails: diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseString/after/Test.java b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseString/after/Test.java new file mode 100644 index 000000000000..a0106ff8d66f --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseString/after/Test.java @@ -0,0 +1,11 @@ +import java.util.concurrent.atomic.AtomicReference; + +class Test { + String s = ""; + + void foo() { + if (s == null) { + System.out.println(s); + } + } +}
\ No newline at end of file diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseString/before/Test.java b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseString/before/Test.java new file mode 100644 index 000000000000..cb32e0ba130b --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseString/before/Test.java @@ -0,0 +1,11 @@ +import java.util.concurrent.atomic.AtomicReference; + +class Test { + AtomicReference<String> s = new AtomicReference<String>(""); + + void foo() { + if (s == null) { + System.out.println(s.get()); + } + } +}
\ No newline at end of file diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseStringArray/after/Test.items b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseStringArray/after/Test.items new file mode 100644 index 000000000000..eaf82b5cc2e6 --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseStringArray/after/Test.items @@ -0,0 +1,14 @@ +Types: +PsiField:s : java.lang.String[] +PsiMethodCallExpression:s.get(0) : java.lang.String +PsiMethodCallExpression:s.set(0, "") : void +PsiReferenceExpression:s : java.lang.String[] +PsiReferenceExpression:s : java.lang.String[] + +Conversions: +new AtomicReferenceArray<String>(new String[2]) -> $qualifier$ new $type$($qualifier$) +s.get(0) -> $qualifier$[$idx$] $qualifier$.get($idx$) +s.set(0, "") -> $qualifier$[$idx$] = $val$ $qualifier$.set($idx$, $val$) + +New expression type changes: +Fails: diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseStringArray/after/Test.java b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseStringArray/after/Test.java new file mode 100644 index 000000000000..0c64ea445f01 --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseStringArray/after/Test.java @@ -0,0 +1,11 @@ +import java.util.concurrent.atomic.AtomicReferenceArray; + +class Test { + String[] s = new String[2]; + + void foo() { + s[0] = ""; + System.out.println(s[0]); + + } +}
\ No newline at end of file diff --git a/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseStringArray/before/Test.java b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseStringArray/before/Test.java new file mode 100644 index 000000000000..fbc97bc2eb36 --- /dev/null +++ b/java/typeMigration/testData/refactoring/typeMigrationByAtomic/reverseStringArray/before/Test.java @@ -0,0 +1,11 @@ +import java.util.concurrent.atomic.AtomicReferenceArray; + +class Test { + AtomicReferenceArray<String> s = new AtomicReferenceArray<String>(new String[2]); + + void foo() { + s.set(0, ""); + System.out.println(s.get(0)); + + } +}
\ No newline at end of file |