mirror of
https://gitflic.ru/project/openide/openide.git
synced 2026-09-18 09:34:34 +07:00
Java: Inspection to verify parameters of VarHandle.get(), VarHandle.set(), and similar methods (IDEA-172358)
This commit is contained in:
Pavel Dolgov
+86
@@ -0,0 +1,86 @@
|
||||
import java.lang.invoke.MethodHandles;
|
||||
import java.lang.invoke.VarHandle;
|
||||
|
||||
public class ArrayVarHandle {
|
||||
void array() {
|
||||
VarHandle handle = MethodHandles.arrayElementVarHandle(Test[].class);
|
||||
Test[] array = new Test[]{new Test(), new Test(), new SubTest()};
|
||||
Test instance = new Test();
|
||||
|
||||
Test exactGet = (Test)handle.get(array, 0);
|
||||
Super superGet = (Super) handle.get(array, 1);
|
||||
Object objectGet = handle.get(array, 2);
|
||||
|
||||
Object missingIndexGet = handle.get<warning descr="2 arguments are expected">(array)</warning>;
|
||||
Object incompatibleReceiverGet = handle.get(<warning descr="Call receiver type is incompatible: 'Test[]' is expected">instance</warning>, 1);
|
||||
Object incompatibleIndexGet = handle.get(array, "abc");
|
||||
String incompatibleResultGet = (<warning descr="Should be cast to 'Test' or its superclass">String</warning>)handle.get(<warning descr="Call receiver type is incompatible: 'Test[]' is expected">instance</warning>, 1);
|
||||
|
||||
handle.set(array, 0, instance);
|
||||
handle.set(array, 1, new SubTest());
|
||||
Super superItemSet = new Test();
|
||||
handle.set(array, 1, superItemSet);
|
||||
Object objectItemSet = new Test();
|
||||
handle.set(array, 2, objectItemSet);
|
||||
|
||||
handle.set(array, instance, <warning descr="Argument is not assignable to 'Test'">0</warning>);
|
||||
handle.set<warning descr="3 arguments are expected">(array, instance)</warning>;
|
||||
handle.set(<warning descr="Call receiver type is incompatible: 'Test[]' is expected">instance</warning>, array, <warning descr="Argument is not assignable to 'Test'">0</warning>);
|
||||
handle.set<warning descr="3 arguments are expected">(array, 0)</warning>;
|
||||
handle.set(array, 0, <warning descr="Argument is not assignable to 'Test'">"abc"</warning>);
|
||||
handle.set<warning descr="3 arguments are expected">(<warning descr="Call receiver type is incompatible: 'Test[]' is expected">"abc"</warning>)</warning>;
|
||||
|
||||
Test exactGAS = (Test)handle.getAndSet(array, 0, instance);
|
||||
SubTest subGAS = (SubTest)handle.getAndSet(array, 1, instance);
|
||||
Super superGAS = (Super)handle.getAndSet(array, 2, instance);
|
||||
Object objectGAS = handle.getAndSet(array, 0, instance);
|
||||
|
||||
Object tooManyArgumentsGAS = handle.getAndSet<warning descr="3 arguments are expected">(array, 0, instance, 1)</warning>;
|
||||
Object wrongArgumentGAS = handle.getAndSet(array, instance, <warning descr="Argument is not assignable to 'Test'">0</warning>);
|
||||
Test tooFewArgumentsGAS = (Test)handle.getAndSet<warning descr="3 arguments are expected">(array, instance)</warning>;
|
||||
|
||||
boolean exactCAS = handle.compareAndSet(array, 0, instance, new Test());
|
||||
boolean subCAS = handle.compareAndSet(array, 0, new SubTest(), instance);
|
||||
|
||||
boolean tooManyArgumentsCAS = handle.compareAndSet<warning descr="4 arguments are expected">(array, 0, instance, new Test(), new Test())</warning>;
|
||||
boolean wrongArgumentCAS = handle.compareAndSet(array, instance, new Test(), <warning descr="Argument is not assignable to 'Test'">2</warning>);
|
||||
boolean tooFewArgumentsCAS = handle.compareAndSet<warning descr="4 arguments are expected">(array, 0, instance)</warning>;
|
||||
|
||||
Test exactCAE = (Test)handle.compareAndExchange(array, 0, instance, new Test());
|
||||
Super superCAE = (Super)handle.compareAndExchange(array, 0, new SubTest(), instance);
|
||||
|
||||
Test tooManyArgumentsCAE = (Test)handle.compareAndExchange<warning descr="4 arguments are expected">(array, 0, instance, new Test(), new Test())</warning>;
|
||||
Test wrongArgumentCAE = (Test)handle.compareAndExchange(array, instance, new Test(), <warning descr="Argument is not assignable to 'Test'">2</warning>);
|
||||
Test tooFewArgumentsCAE = (Test)handle.compareAndExchange<warning descr="4 arguments are expected">(array, 0, instance)</warning>;
|
||||
}
|
||||
|
||||
void array2() {
|
||||
VarHandle handle = MethodHandles.arrayElementVarHandle(Test[][].class);
|
||||
Test[] array0 = new Test[1];
|
||||
Test[][] array = new Test[][]{new Test[1]};
|
||||
Test instance = new Test();
|
||||
|
||||
Test[] exactGet = (Test[])handle.get(array, 0);
|
||||
Object incompatibleReceiverGet = handle.get(<warning descr="Call receiver type is incompatible: 'Test[][]' is expected">array0</warning>, 1);
|
||||
Test incompatibleResultGet = (<warning descr="Should be cast to 'Test[]' or its superclass">Test</warning>)handle.get(array, 1);
|
||||
|
||||
handle.set(array, 0, array0);
|
||||
handle.set(array, 0, <warning descr="Argument is not assignable to 'Test[]'">instance</warning>);
|
||||
|
||||
Test[] exactGAS = (Test[])handle.getAndSet(array, 0, array0);
|
||||
Object wrongArgumentGAS = handle.getAndSet(array, 0, <warning descr="Argument is not assignable to 'Test[]'">instance</warning>);
|
||||
|
||||
boolean exactCAS = handle.compareAndSet(array, 0, array0, new Test[0]);
|
||||
boolean wrongArgumentCAS = handle.compareAndSet(array, 0, array0, <warning descr="Argument is not assignable to 'Test[]'">instance</warning>);
|
||||
|
||||
Object exactCAE = (Object)handle.compareAndExchange(array, 0, new Test[0], array0);
|
||||
Test[] wrongArgumentCAE = (Test[])handle.compareAndExchange(array, 0, <warning descr="Argument is not assignable to 'Test[]'">instance</warning>, array0);
|
||||
Test wrongResultCAE = (<warning descr="Should be cast to 'Test[]' or its superclass">Test</warning>)handle.compareAndExchange(array, 0, array0, new Test[0]);
|
||||
}
|
||||
}
|
||||
|
||||
class Super {}
|
||||
|
||||
class Test extends Super {}
|
||||
|
||||
class SubTest extends Test {}
|
||||
+317
@@ -0,0 +1,317 @@
|
||||
import java.lang.invoke.MethodHandles;
|
||||
import java.lang.invoke.VarHandle;
|
||||
|
||||
class Main {
|
||||
void getInt() throws Throwable {
|
||||
MethodHandles.Lookup lookup = MethodHandles.lookup();
|
||||
VarHandle handle = lookup.findStaticVarHandle(Test.class, "n", int.class);
|
||||
Test instance = new Test();
|
||||
|
||||
int exact = (int) handle.get();
|
||||
Integer boxed = (Integer) handle.get();
|
||||
Object object = (Object) handle.get();
|
||||
String incompatible = (<warning descr="Should be cast to 'int'">String</warning>) handle.get();
|
||||
handle.get<warning descr="No arguments are expected">(instance)</warning>;
|
||||
|
||||
int exactV = (int) handle.getVolatile();
|
||||
Integer boxedV = (Integer) handle.getVolatile();
|
||||
Object objectV = (Object) handle.getVolatile();
|
||||
String incompatibleV = (<warning descr="Should be cast to 'int'">String</warning>) handle.getVolatile();
|
||||
handle.getVolatile<warning descr="No arguments are expected">(instance)</warning>;
|
||||
|
||||
int exactO = (int) handle.getOpaque();
|
||||
Integer boxedO = (Integer) handle.getOpaque();
|
||||
Object objectO = (Object) handle.getOpaque();
|
||||
String incompatibleO = (<warning descr="Should be cast to 'int'">String</warning>) handle.getOpaque();
|
||||
handle.getOpaque<warning descr="No arguments are expected">(instance)</warning>;
|
||||
|
||||
int exactA = (int) handle.getAcquire();
|
||||
Integer boxedA = (Integer) handle.getAcquire();
|
||||
Object objectA = (Object) handle.getAcquire();
|
||||
String incompatibleA = (<warning descr="Should be cast to 'int'">String</warning>) handle.getAcquire();
|
||||
handle.getAcquire<warning descr="No arguments are expected">(instance)</warning>;
|
||||
}
|
||||
|
||||
void setInt() throws Throwable {
|
||||
MethodHandles.Lookup lookup = MethodHandles.lookup();
|
||||
VarHandle handle = lookup.findStaticVarHandle(Test.class, "n", int.class);
|
||||
Test instance = new Test();
|
||||
Object nullArg = null;
|
||||
Object textArg = "abc";
|
||||
Object numberArg = 123;
|
||||
|
||||
handle.set(1);
|
||||
handle.set(Integer.valueOf(2));
|
||||
handle.set(numberArg);
|
||||
handle.set(textArg);
|
||||
handle.set<warning descr="One argument is expected">(instance, 1)</warning>;
|
||||
handle.set(<warning descr="Argument of type 'int' cannot be 'null'">nullArg</warning>);
|
||||
handle.set<warning descr="One argument is expected">()</warning>;
|
||||
|
||||
handle.setVolatile(1);
|
||||
handle.setVolatile(Integer.valueOf(2));
|
||||
handle.setVolatile(numberArg);
|
||||
handle.setVolatile(textArg);
|
||||
handle.setVolatile<warning descr="One argument is expected">(instance, 1)</warning>;
|
||||
handle.setVolatile(<warning descr="Argument of type 'int' cannot be 'null'">nullArg</warning>);
|
||||
handle.setVolatile<warning descr="One argument is expected">()</warning>;
|
||||
|
||||
handle.setOpaque(1);
|
||||
handle.setOpaque(Integer.valueOf(2));
|
||||
handle.setOpaque(numberArg);
|
||||
handle.setOpaque(textArg);
|
||||
handle.setOpaque<warning descr="One argument is expected">(instance, 1)</warning>;
|
||||
handle.setOpaque(<warning descr="Argument of type 'int' cannot be 'null'">nullArg</warning>);
|
||||
handle.setOpaque<warning descr="One argument is expected">()</warning>;
|
||||
|
||||
handle.setRelease(1);
|
||||
handle.setRelease(Integer.valueOf(2));
|
||||
handle.setRelease(numberArg);
|
||||
handle.setRelease(textArg);
|
||||
handle.setRelease<warning descr="One argument is expected">(instance, 1)</warning>;
|
||||
handle.setRelease(<warning descr="Argument of type 'int' cannot be 'null'">nullArg</warning>);
|
||||
handle.setRelease<warning descr="One argument is expected">()</warning>;
|
||||
}
|
||||
|
||||
void getStr() throws Throwable {
|
||||
MethodHandles.Lookup lookup = MethodHandles.lookup();
|
||||
final VarHandle handle = lookup.findStaticVarHandle(Test.class, "s", String.class);
|
||||
final Test instance = new Test();
|
||||
|
||||
String exact = (String) handle.get();
|
||||
CharSequence parent = (CharSequence) handle.get();
|
||||
Object object = (Object) handle.get();
|
||||
Integer incompatible = (<warning descr="Should be cast to 'java.lang.String' or its superclass">Integer</warning>) handle.get();
|
||||
handle.get<warning descr="No arguments are expected">(instance)</warning>;
|
||||
|
||||
String exactV = (String) handle.getVolatile();
|
||||
CharSequence parentV = (CharSequence) handle.getVolatile();
|
||||
Object objectV = (Object) handle.getVolatile();
|
||||
Integer incompatibleV = (<warning descr="Should be cast to 'java.lang.String' or its superclass">Integer</warning>) handle.getVolatile();
|
||||
handle.getVolatile<warning descr="No arguments are expected">(instance)</warning>;
|
||||
|
||||
String exactO = (String) handle.getOpaque();
|
||||
CharSequence parentO = (CharSequence) handle.getOpaque();
|
||||
Object objectO = (Object) handle.getOpaque();
|
||||
Integer incompatibleO = (<warning descr="Should be cast to 'java.lang.String' or its superclass">Integer</warning>) handle.getOpaque();
|
||||
handle.getOpaque<warning descr="No arguments are expected">(instance)</warning>;
|
||||
|
||||
String exactA = (String) handle.getAcquire();
|
||||
CharSequence parentA = (CharSequence) handle.getAcquire();
|
||||
Object objectA = (Object) handle.getAcquire();
|
||||
Integer incompatibleA = (<warning descr="Should be cast to 'java.lang.String' or its superclass">Integer</warning>) handle.getAcquire();
|
||||
handle.getAcquire<warning descr="No arguments are expected">(instance)</warning>;
|
||||
}
|
||||
|
||||
void setStr() throws Throwable {
|
||||
MethodHandles.Lookup lookup = MethodHandles.lookup();
|
||||
final VarHandle handle = lookup.findStaticVarHandle(Test.class, "s", String.class);
|
||||
final Test instance = new Test();
|
||||
final Object nullArg = null;
|
||||
final Object textArg = "abc";
|
||||
final Object numberArg = 3;
|
||||
|
||||
handle.set("a");
|
||||
handle.set(charSequence());
|
||||
handle.set(textArg);
|
||||
handle.set(nullArg);
|
||||
handle.set(numberArg);
|
||||
handle.set<warning descr="One argument is expected">(instance, "abc")</warning>;
|
||||
handle.set<warning descr="One argument is expected">()</warning>;
|
||||
|
||||
handle.setVolatile("a");
|
||||
handle.setVolatile(charSequence());
|
||||
handle.setVolatile(textArg);
|
||||
handle.setVolatile(nullArg);
|
||||
handle.setVolatile(numberArg);
|
||||
handle.setVolatile<warning descr="One argument is expected">(instance, "abc")</warning>;
|
||||
handle.setVolatile<warning descr="One argument is expected">()</warning>;
|
||||
|
||||
handle.setOpaque("a");
|
||||
handle.setOpaque(charSequence());
|
||||
handle.setOpaque(textArg);
|
||||
handle.setOpaque(nullArg);
|
||||
handle.setOpaque(numberArg);
|
||||
handle.setOpaque<warning descr="One argument is expected">(instance, "abc")</warning>;
|
||||
handle.setOpaque<warning descr="One argument is expected">()</warning>;
|
||||
|
||||
handle.setRelease("a");
|
||||
handle.setRelease(charSequence());
|
||||
handle.setRelease(textArg);
|
||||
handle.setRelease(nullArg);
|
||||
handle.setRelease(numberArg);
|
||||
handle.setRelease<warning descr="One argument is expected">(instance, "abc")</warning>;
|
||||
handle.setRelease<warning descr="One argument is expected">()</warning>;
|
||||
}
|
||||
|
||||
|
||||
private void getAndAddInt() throws Throwable {
|
||||
MethodHandles.Lookup lookup = MethodHandles.lookup();
|
||||
VarHandle handle = lookup.findStaticVarHandle(Test.class, "n", int.class);
|
||||
Test instance = new Test();
|
||||
Object nullArg = null;
|
||||
|
||||
int exact = (int) handle.getAndAdd(1);
|
||||
Integer boxed = (Integer) handle.getAndAdd(2);
|
||||
Object object = (Object) handle.getAndAdd(3);
|
||||
handle.getAndAdd(4);
|
||||
String incompatible = (<warning descr="Should be cast to 'int'">String</warning>) handle.getAndAdd(0);
|
||||
int incompatibleArg = (int) handle.getAndSet(<warning descr="Argument is not assignable to 'int'">"abc"</warning>);
|
||||
handle.getAndAdd<warning descr="One argument is expected">(1, 2)</warning>;
|
||||
handle.getAndAdd<warning descr="One argument is expected">()</warning>;
|
||||
|
||||
int exactA = (int) handle.getAndAddAcquire(1); ;
|
||||
Integer boxedA = (Integer) handle.getAndAddAcquire(2);
|
||||
Object objectA = (Object) handle.getAndAddAcquire(3);
|
||||
handle.getAndAddAcquire(4);
|
||||
String incompatibleA = (<warning descr="Should be cast to 'int'">String</warning>) handle.getAndAddAcquire<warning descr="One argument is expected">(instance, 0)</warning>;
|
||||
int incompatibleArgA = (int) handle.getAndSetAcquire(<warning descr="Argument is not assignable to 'int'">"abc"</warning>);
|
||||
handle.getAndAddAcquire<warning descr="One argument is expected">(1, 2)</warning>;
|
||||
handle.getAndAddAcquire<warning descr="One argument is expected">()</warning>;
|
||||
|
||||
int exactR = (int) handle.getAndAddRelease(1); ;
|
||||
Integer boxedR = (Integer) handle.getAndAddRelease(2);
|
||||
Object objectR = (Object) handle.getAndAddRelease(3);
|
||||
handle.getAndAddRelease(4);
|
||||
String incompatibleR = (<warning descr="Should be cast to 'int'">String</warning>) handle.getAndAdd(0);
|
||||
int incompatibleArgR = (int) handle.getAndSetRelease(<warning descr="Argument is not assignable to 'int'">"abc"</warning>);
|
||||
handle.getAndAddRelease<warning descr="One argument is expected">(1, 2)</warning>;
|
||||
handle.getAndAddRelease<warning descr="One argument is expected">()</warning>;
|
||||
}
|
||||
|
||||
private void getAndSetStr() throws Throwable {
|
||||
MethodHandles.Lookup lookup = MethodHandles.lookup();
|
||||
final VarHandle handle = lookup.findStaticVarHandle(Test.class, "s", String.class);
|
||||
final Test instance = new Test();
|
||||
final Object nullArg = null;
|
||||
|
||||
String exact = (String) handle.getAndSet("a");
|
||||
CharSequence parent = (CharSequence) handle.getAndSet("b");
|
||||
Object object = (Object) handle.getAndSet("c");
|
||||
String subclassArg = (String) handle.getAndSet(charSequence());
|
||||
String withNullArg = (String) handle.getAndSet(nullArg);
|
||||
handle.getAndSet("d");
|
||||
Integer incompatible = (<warning descr="Should be cast to 'java.lang.String' or its superclass">Integer</warning>) handle.getAndSet("e");
|
||||
String incompatibleArg = (String) handle.getAndSet(<warning descr="Argument is not assignable to 'java.lang.String'">123</warning>);
|
||||
handle.getAndSet<warning descr="One argument is expected">("a", "b")</warning>;
|
||||
handle.getAndSet<warning descr="One argument is expected">()</warning>;
|
||||
|
||||
String exactA = (String) handle.getAndSetAcquire("a");
|
||||
CharSequence parentA = (CharSequence) handle.getAndSetAcquire("b");
|
||||
Object objectA = (Object) handle.getAndSetAcquire("c");;
|
||||
String subclassArgA = (String) handle.getAndSetAcquire(charSequence());
|
||||
String withNullArgA = (String) handle.getAndSetAcquire(nullArg);
|
||||
handle.getAndSetAcquire("d");
|
||||
Integer incompatibleA = (<warning descr="Should be cast to 'java.lang.String' or its superclass">Integer</warning>) handle.getAndSetAcquire("e");
|
||||
String incompatibleArgA = (String) handle.getAndSetAcquire(<warning descr="Argument is not assignable to 'java.lang.String'">123</warning>);
|
||||
handle.getAndSetAcquire<warning descr="One argument is expected">("a", "b")</warning>;
|
||||
handle.getAndSetAcquire<warning descr="One argument is expected">()</warning>;
|
||||
|
||||
String exactR = (String) handle.getAndSetRelease("a");
|
||||
CharSequence parentR = (CharSequence) handle.getAndSetRelease("b");
|
||||
Object objectR = (Object) handle.getAndSetRelease("c");;
|
||||
String subclassArgR = (String) handle.getAndSetRelease(charSequence());
|
||||
String withNullArgR = (String) handle.getAndSetRelease(nullArg);
|
||||
handle.getAndSetRelease("d");
|
||||
Integer incompatibleR = (<warning descr="Should be cast to 'java.lang.String' or its superclass">Integer</warning>) handle.getAndSetRelease("e");
|
||||
String incompatibleArgR = (String) handle.getAndSetRelease(<warning descr="Argument is not assignable to 'java.lang.String'">123</warning>);
|
||||
handle.getAndSetRelease<warning descr="One argument is expected">("a", "b")</warning>;
|
||||
handle.getAndSetRelease<warning descr="One argument is expected">()</warning>;
|
||||
}
|
||||
|
||||
void getAndBitwise() throws Throwable {
|
||||
MethodHandles.Lookup lookup = MethodHandles.lookup();
|
||||
VarHandle handle = lookup.findStaticVarHandle(Test.class, "n", int.class);
|
||||
Test instance = new Test();
|
||||
|
||||
int exactBitwiseAnd = (int) handle.getAndBitwiseAnd(1);
|
||||
int exactBitwiseAndA = (int) handle.getAndBitwiseAndAcquire(2);
|
||||
int exactBitwiseAndR = (int) handle.getAndBitwiseAndRelease(3);
|
||||
|
||||
int wrongArgBitwiseAnd = (int) handle.getAndBitwiseAnd(<warning descr="Argument is not assignable to 'int'">"a"</warning>);
|
||||
int wrongArgBitwiseAndA = (int) handle.getAndBitwiseAndAcquire(<warning descr="Argument is not assignable to 'int'">"b"</warning>);
|
||||
int wrongArgBitwiseAndR = (int) handle.getAndBitwiseAndRelease(<warning descr="Argument is not assignable to 'int'">"c"</warning>);
|
||||
|
||||
String wrongResultBitwiseAnd = (<warning descr="Should be cast to 'int'">String</warning>) handle.getAndBitwiseAnd(1);
|
||||
String wrongResultBitwiseAndA = (<warning descr="Should be cast to 'int'">String</warning>) handle.getAndBitwiseAndAcquire(2);
|
||||
String wrongResultBitwiseAndR = (<warning descr="Should be cast to 'int'">String</warning>) handle.getAndBitwiseAndRelease(3);
|
||||
|
||||
int exactBitwiseOr = (int) handle.getAndBitwiseOr(1);
|
||||
int exactBitwiseOrA = (int) handle.getAndBitwiseOrAcquire(2);
|
||||
int exactBitwiseOrR = (int) handle.getAndBitwiseOrRelease(3);
|
||||
|
||||
int wrongArgBitwiseOr = (int) handle.getAndBitwiseOr(<warning descr="Argument is not assignable to 'int'">"a"</warning>);
|
||||
int wrongArgBitwiseOrA = (int) handle.getAndBitwiseOrAcquire(<warning descr="Argument is not assignable to 'int'">"b"</warning>);
|
||||
int wrongArgBitwiseOrR = (int) handle.getAndBitwiseOrRelease(<warning descr="Argument is not assignable to 'int'">"c"</warning>);
|
||||
|
||||
String wrongResultBitwiseOr = (<warning descr="Should be cast to 'int'">String</warning>) handle.getAndBitwiseOr(1);
|
||||
String wrongResultBitwiseOrA = (<warning descr="Should be cast to 'int'">String</warning>) handle.getAndBitwiseOrAcquire(2);
|
||||
String wrongResultBitwiseOrR = (<warning descr="Should be cast to 'int'">String</warning>) handle.getAndBitwiseOrRelease(3);
|
||||
|
||||
int exactBitwiseXor = (int) handle.getAndBitwiseXor(1);
|
||||
int exactBitwiseXorA = (int) handle.getAndBitwiseXorAcquire(2);
|
||||
int exactBitwiseXorR = (int) handle.getAndBitwiseXorRelease(3);
|
||||
|
||||
int wrongArgBitwiseXor = (int) handle.getAndBitwiseXor(<warning descr="Argument is not assignable to 'int'">"a"</warning>);
|
||||
int wrongArgBitwiseXorA = (int) handle.getAndBitwiseXorAcquire(<warning descr="Argument is not assignable to 'int'">"b"</warning>);
|
||||
int wrongArgBitwiseXorR = (int) handle.getAndBitwiseXorRelease(<warning descr="Argument is not assignable to 'int'">"c"</warning>);
|
||||
|
||||
String wrongResultBitwiseXor = (<warning descr="Should be cast to 'int'">String</warning>) handle.getAndBitwiseXor(1);
|
||||
String wrongResultBitwiseXorA = (<warning descr="Should be cast to 'int'">String</warning>) handle.getAndBitwiseXorAcquire(2);
|
||||
String wrongResultBitwiseXorR = (<warning descr="Should be cast to 'int'">String</warning>) handle.getAndBitwiseXorRelease(3);
|
||||
}
|
||||
|
||||
|
||||
void compare() throws Throwable {
|
||||
MethodHandles.Lookup lookup = MethodHandles.lookup();
|
||||
final VarHandle handle = lookup.findStaticVarHandle(Test.class, "myS", String.class);
|
||||
final Test instance = new Test();
|
||||
|
||||
boolean exactCAS = handle.compareAndSet("a", "b");
|
||||
String exactCAE = (String)handle.compareAndExchange("a", "b");
|
||||
String exactCAEA = (String)handle.compareAndExchangeAcquire("a", "b");
|
||||
String exactCAER = (String)handle.compareAndExchangeRelease("a", "b");
|
||||
|
||||
boolean badArg1CAS = handle.compareAndSet(<warning descr="Argument is not assignable to 'java.lang.String'">1</warning>, "b");
|
||||
String badArg1CAE = (String)handle.compareAndExchange(<warning descr="Argument is not assignable to 'java.lang.String'">2</warning>, "b");
|
||||
String badArg1CAEa = (String)handle.compareAndExchangeAcquire(<warning descr="Argument is not assignable to 'java.lang.String'">3</warning>, "b");
|
||||
String badArg1CAEr = (String)handle.compareAndExchangeRelease(<warning descr="Argument is not assignable to 'java.lang.String'">4</warning>, "b");
|
||||
|
||||
boolean badArg2CAS = handle.compareAndSet("a", <warning descr="Argument is not assignable to 'java.lang.String'">1</warning>);
|
||||
String badArg2CAE = (String)handle.compareAndExchange("a", <warning descr="Argument is not assignable to 'java.lang.String'">2</warning>);
|
||||
String badArg2CAEa = (String)handle.compareAndExchangeAcquire("a", <warning descr="Argument is not assignable to 'java.lang.String'">3</warning>);
|
||||
String badArg2CAEr = (String)handle.compareAndExchangeRelease("a", <warning descr="Argument is not assignable to 'java.lang.String'">4</warning>);
|
||||
|
||||
Integer badResultCAE = (<warning descr="Should be cast to 'java.lang.String' or its superclass">Integer</warning>)handle.compareAndExchange("a", "b");
|
||||
Integer badResultCAEa = (<warning descr="Should be cast to 'java.lang.String' or its superclass">Integer</warning>)handle.compareAndExchangeAcquire("a", "b");
|
||||
Integer badResultCAEr = (<warning descr="Should be cast to 'java.lang.String' or its superclass">Integer</warning>)handle.compareAndExchangeRelease("a", "b");
|
||||
}
|
||||
|
||||
void weakCompare() throws Throwable {
|
||||
MethodHandles.Lookup lookup = MethodHandles.lookup();
|
||||
final VarHandle handle = lookup.findStaticVarHandle(Test.class, "myS", String.class);
|
||||
final Test instance = new Test();
|
||||
|
||||
boolean exactCAS = handle.weakCompareAndSet("a", "b");
|
||||
boolean exactCASp = handle.weakCompareAndSetPlain("a", "b");
|
||||
boolean exactCASa = handle.weakCompareAndSetAcquire("a", "b");
|
||||
boolean exactCASr = handle.weakCompareAndSetRelease("a", "b");
|
||||
|
||||
boolean badArg1CAS = handle.weakCompareAndSet(<warning descr="Argument is not assignable to 'java.lang.String'">1</warning>, "b");
|
||||
boolean badArg1CASp = handle.weakCompareAndSetPlain(<warning descr="Argument is not assignable to 'java.lang.String'">2</warning>, "b");
|
||||
boolean badArg1CASa = handle.weakCompareAndSetAcquire(<warning descr="Argument is not assignable to 'java.lang.String'">3</warning>, "b");
|
||||
boolean badArg1CASr = handle.weakCompareAndSetRelease(<warning descr="Argument is not assignable to 'java.lang.String'">4</warning>, "b");
|
||||
|
||||
boolean badArg2CAS = handle.weakCompareAndSet("a", <warning descr="Argument is not assignable to 'java.lang.String'">1</warning>);
|
||||
boolean badArg2CASp = handle.weakCompareAndSetPlain("a", <warning descr="Argument is not assignable to 'java.lang.String'">2</warning>);
|
||||
boolean badArg2CASa = handle.weakCompareAndSetAcquire("a", <warning descr="Argument is not assignable to 'java.lang.String'">3</warning>);
|
||||
boolean badArg2CASr = handle.weakCompareAndSetRelease("a", <warning descr="Argument is not assignable to 'java.lang.String'">4</warning>);
|
||||
}
|
||||
|
||||
private static CharSequence charSequence() { return "abc"; }
|
||||
}
|
||||
|
||||
class Test {
|
||||
public static int n;
|
||||
public static String s;
|
||||
}
|
||||
@@ -0,0 +1,371 @@
|
||||
import java.lang.invoke.MethodHandles;
|
||||
import java.lang.invoke.VarHandle;
|
||||
|
||||
class Main {
|
||||
void getInt() throws Throwable {
|
||||
MethodHandles.Lookup lookup = MethodHandles.lookup();
|
||||
VarHandle handle = lookup.findVarHandle(Test.class, "n", int.class);
|
||||
Test instance = new Test();
|
||||
Object nullArg = null;
|
||||
|
||||
int exact = (int) handle.get(instance);
|
||||
Integer boxed = (Integer) handle.get(instance);
|
||||
Object object = (Object) handle.get(instance);
|
||||
String incompatible = (<warning descr="Should be cast to 'int'">String</warning>) handle.get(instance);
|
||||
handle.get<warning descr="One argument is expected">(instance, 1)</warning>;
|
||||
handle.get<warning descr="One argument is expected">()</warning>;
|
||||
handle.get(<warning descr="Call receiver is 'null'">nullArg</warning>);
|
||||
handle.get(<warning descr="Call receiver type is incompatible: 'Test' is expected">123</warning>);
|
||||
|
||||
int exactV = (int) handle.getVolatile(instance);
|
||||
Integer boxedV = (Integer) handle.getVolatile(instance);
|
||||
Object objectV = (Object) handle.getVolatile(instance);
|
||||
String incompatibleV = (<warning descr="Should be cast to 'int'">String</warning>) handle.getVolatile(instance);
|
||||
handle.getVolatile<warning descr="One argument is expected">(instance, 1)</warning>;
|
||||
handle.getVolatile<warning descr="One argument is expected">()</warning>;
|
||||
handle.getVolatile(<warning descr="Call receiver is 'null'">nullArg</warning>);
|
||||
handle.getVolatile(<warning descr="Call receiver type is incompatible: 'Test' is expected">123</warning>);
|
||||
|
||||
int exactO = (int) handle.getOpaque(instance);
|
||||
Integer boxedO = (Integer) handle.getOpaque(instance);
|
||||
Object objectO = (Object) handle.getOpaque(instance);
|
||||
String incompatibleO = (<warning descr="Should be cast to 'int'">String</warning>) handle.getOpaque(instance);
|
||||
handle.getOpaque<warning descr="One argument is expected">(instance, 1)</warning>;
|
||||
handle.getOpaque<warning descr="One argument is expected">()</warning>;
|
||||
handle.getOpaque(<warning descr="Call receiver is 'null'">nullArg</warning>);
|
||||
handle.getOpaque(<warning descr="Call receiver type is incompatible: 'Test' is expected">123</warning>);
|
||||
|
||||
int exactA = (int) handle.getAcquire(instance);
|
||||
Integer boxedA = (Integer) handle.getAcquire(instance);
|
||||
Object objectA = (Object) handle.getAcquire(instance);
|
||||
String incompatibleA = (<warning descr="Should be cast to 'int'">String</warning>) handle.getAcquire(instance);
|
||||
handle.getAcquire<warning descr="One argument is expected">(instance, 1)</warning>;
|
||||
handle.getAcquire<warning descr="One argument is expected">()</warning>;
|
||||
handle.getAcquire(<warning descr="Call receiver is 'null'">nullArg</warning>);
|
||||
handle.getAcquire(<warning descr="Call receiver type is incompatible: 'Test' is expected">123</warning>);
|
||||
}
|
||||
|
||||
void setInt() throws Throwable {
|
||||
MethodHandles.Lookup lookup = MethodHandles.lookup();
|
||||
VarHandle handle = lookup.findVarHandle(Test.class, "n", int.class);
|
||||
Test instance = new Test();
|
||||
Object nullArg = null;
|
||||
Object textArg = "abc";
|
||||
Object numberArg = 123;
|
||||
|
||||
handle.set(instance, 1);
|
||||
handle.set(instance, Integer.valueOf(2));
|
||||
handle.set(instance, numberArg);
|
||||
handle.set(instance, textArg);
|
||||
handle.set<warning descr="2 arguments are expected">(instance)</warning>;
|
||||
handle.set<warning descr="2 arguments are expected">()</warning>;
|
||||
handle.set(<warning descr="Call receiver is 'null'">nullArg</warning>, 123);
|
||||
handle.set(instance, <warning descr="Argument of type 'int' cannot be 'null'">nullArg</warning>);
|
||||
handle.set(<warning descr="Call receiver type is incompatible: 'Test' is expected">123</warning>, 42);
|
||||
|
||||
handle.setVolatile(instance, 1);
|
||||
handle.setVolatile(instance, Integer.valueOf(2));
|
||||
handle.setVolatile(instance, numberArg);
|
||||
handle.setVolatile(instance, textArg);
|
||||
handle.setVolatile<warning descr="2 arguments are expected">(instance)</warning>;
|
||||
handle.setVolatile<warning descr="2 arguments are expected">()</warning>;
|
||||
handle.setVolatile(<warning descr="Call receiver is 'null'">nullArg</warning>, 123);
|
||||
handle.setVolatile(instance, <warning descr="Argument of type 'int' cannot be 'null'">nullArg</warning>);
|
||||
handle.setVolatile(<warning descr="Call receiver type is incompatible: 'Test' is expected">123</warning>, 42);
|
||||
|
||||
handle.setOpaque(instance, 1);
|
||||
handle.setOpaque(instance, Integer.valueOf(2));
|
||||
handle.setOpaque(instance, numberArg);
|
||||
handle.setOpaque(instance, textArg);
|
||||
handle.setOpaque<warning descr="2 arguments are expected">(instance)</warning>;
|
||||
handle.setOpaque<warning descr="2 arguments are expected">()</warning>;
|
||||
handle.setOpaque(<warning descr="Call receiver is 'null'">nullArg</warning>, 123);
|
||||
handle.setOpaque(instance, <warning descr="Argument of type 'int' cannot be 'null'">nullArg</warning>);
|
||||
handle.setOpaque(<warning descr="Call receiver type is incompatible: 'Test' is expected">123</warning>, 42);
|
||||
|
||||
handle.setRelease(instance, 1);
|
||||
handle.setRelease(instance, Integer.valueOf(2));
|
||||
handle.setRelease(instance, numberArg);
|
||||
handle.setRelease(instance, textArg);
|
||||
handle.setRelease<warning descr="2 arguments are expected">(instance)</warning>;
|
||||
handle.setRelease<warning descr="2 arguments are expected">()</warning>;
|
||||
handle.setRelease(<warning descr="Call receiver is 'null'">nullArg</warning>, 123);
|
||||
handle.setRelease(instance, <warning descr="Argument of type 'int' cannot be 'null'">nullArg</warning>);
|
||||
handle.setRelease(<warning descr="Call receiver type is incompatible: 'Test' is expected">123</warning>, 42);
|
||||
}
|
||||
|
||||
void getStr() throws Throwable {
|
||||
MethodHandles.Lookup lookup = MethodHandles.lookup();
|
||||
final VarHandle handle = lookup.findVarHandle(Test.class, "s", String.class);
|
||||
final Test instance = new Test();
|
||||
final Object nullArg = null;
|
||||
|
||||
String exact = (String) handle.get(instance);
|
||||
CharSequence parent = (CharSequence) handle.get(instance);
|
||||
Object object = (Object) handle.get(instance);
|
||||
Integer incompatible = (<warning descr="Should be cast to 'java.lang.String' or its superclass">Integer</warning>) handle.get(instance);
|
||||
handle.get<warning descr="One argument is expected">(instance, 1)</warning>;
|
||||
handle.get<warning descr="One argument is expected">()</warning>;
|
||||
handle.get(<warning descr="Call receiver is 'null'">nullArg</warning>);
|
||||
handle.get(<warning descr="Call receiver type is incompatible: 'Test' is expected">123</warning>);
|
||||
|
||||
String exactV = (String) handle.getVolatile(instance);
|
||||
CharSequence parentV = (CharSequence) handle.getVolatile(instance);
|
||||
Object objectV = (Object) handle.getVolatile(instance);
|
||||
Integer incompatibleV = (<warning descr="Should be cast to 'java.lang.String' or its superclass">Integer</warning>) handle.getVolatile(instance);
|
||||
handle.getVolatile<warning descr="One argument is expected">(instance, 1)</warning>;
|
||||
handle.getVolatile<warning descr="One argument is expected">()</warning>;
|
||||
handle.getVolatile(<warning descr="Call receiver is 'null'">nullArg</warning>);
|
||||
handle.getVolatile(<warning descr="Call receiver type is incompatible: 'Test' is expected">123</warning>);
|
||||
|
||||
String exactO = (String) handle.getOpaque(instance);
|
||||
CharSequence parentO = (CharSequence) handle.getOpaque(instance);
|
||||
Object objectO = (Object) handle.getOpaque(instance);
|
||||
Integer incompatibleO = (<warning descr="Should be cast to 'java.lang.String' or its superclass">Integer</warning>) handle.getOpaque(instance);
|
||||
handle.getOpaque<warning descr="One argument is expected">(instance, 1)</warning>;
|
||||
handle.getOpaque<warning descr="One argument is expected">()</warning>;
|
||||
handle.getOpaque(<warning descr="Call receiver is 'null'">nullArg</warning>);
|
||||
handle.getOpaque(<warning descr="Call receiver type is incompatible: 'Test' is expected">"abc"</warning>);
|
||||
|
||||
String exactA = (String) handle.getAcquire(instance);
|
||||
CharSequence parentA = (CharSequence) handle.getAcquire(instance);
|
||||
Object objectA = (Object) handle.getAcquire(instance);
|
||||
Integer incompatibleA = (<warning descr="Should be cast to 'java.lang.String' or its superclass">Integer</warning>) handle.getAcquire(instance);
|
||||
handle.getAcquire<warning descr="One argument is expected">(instance, 1)</warning>;
|
||||
handle.getAcquire<warning descr="One argument is expected">()</warning>;
|
||||
handle.getAcquire(<warning descr="Call receiver is 'null'">nullArg</warning>);
|
||||
handle.getAcquire(<warning descr="Call receiver type is incompatible: 'Test' is expected">"abc"</warning>);
|
||||
}
|
||||
|
||||
void setStr() throws Throwable {
|
||||
MethodHandles.Lookup lookup = MethodHandles.lookup();
|
||||
final VarHandle handle = lookup.findVarHandle(Test.class, "s", String.class);
|
||||
final Test instance = new Test();
|
||||
final Object nullArg = null;
|
||||
final Object textArg = "abc";
|
||||
final Object numberArg = 3;
|
||||
|
||||
handle.set(instance, "a");
|
||||
handle.set(instance, charSequence());
|
||||
handle.set(instance, textArg);
|
||||
handle.set(instance, nullArg);
|
||||
handle.set(instance, numberArg);
|
||||
handle.set<warning descr="2 arguments are expected">(instance)</warning>;
|
||||
handle.set<warning descr="2 arguments are expected">()</warning>;
|
||||
handle.set<warning descr="2 arguments are expected">(<warning descr="Call receiver is 'null'">nullArg</warning>)</warning>;
|
||||
handle.set(<warning descr="Call receiver type is incompatible: 'Test' is expected">"abc"</warning>, "d");
|
||||
|
||||
handle.setVolatile(instance, "a");
|
||||
handle.setVolatile(instance, charSequence());
|
||||
handle.setVolatile(instance, textArg);
|
||||
handle.setVolatile(instance, nullArg);
|
||||
handle.setVolatile(instance, numberArg);
|
||||
handle.setVolatile<warning descr="2 arguments are expected">(instance)</warning>;
|
||||
handle.setVolatile<warning descr="2 arguments are expected">()</warning>;
|
||||
handle.setVolatile<warning descr="2 arguments are expected">(<warning descr="Call receiver is 'null'">nullArg</warning>)</warning>;
|
||||
handle.setVolatile(<warning descr="Call receiver type is incompatible: 'Test' is expected">"abc"</warning>, "d");
|
||||
|
||||
handle.setOpaque(instance, "a");
|
||||
handle.setOpaque(instance, charSequence());
|
||||
handle.setOpaque(instance, textArg);
|
||||
handle.setOpaque(instance, nullArg);
|
||||
handle.setOpaque(instance, numberArg);
|
||||
handle.setOpaque<warning descr="2 arguments are expected">(instance)</warning>;
|
||||
handle.setOpaque<warning descr="2 arguments are expected">()</warning>;
|
||||
handle.setOpaque<warning descr="2 arguments are expected">(<warning descr="Call receiver is 'null'">nullArg</warning>)</warning>;
|
||||
handle.setOpaque(<warning descr="Call receiver type is incompatible: 'Test' is expected">"abc"</warning>, "d");
|
||||
|
||||
handle.setRelease(instance, "a");
|
||||
handle.setRelease(instance, charSequence());
|
||||
handle.setRelease(instance, textArg);
|
||||
handle.setRelease(instance, nullArg);
|
||||
handle.setRelease(instance, numberArg);
|
||||
handle.setRelease<warning descr="2 arguments are expected">(instance)</warning>;
|
||||
handle.setRelease<warning descr="2 arguments are expected">()</warning>;
|
||||
handle.setRelease<warning descr="2 arguments are expected">(<warning descr="Call receiver is 'null'">nullArg</warning>)</warning>;
|
||||
handle.setRelease(<warning descr="Call receiver type is incompatible: 'Test' is expected">"abc"</warning>, "d");
|
||||
}
|
||||
|
||||
|
||||
private void getAndAddInt() throws Throwable {
|
||||
MethodHandles.Lookup lookup = MethodHandles.lookup();
|
||||
VarHandle handle = lookup.findVarHandle(Test.class, "n", int.class);
|
||||
Test instance = new Test();
|
||||
Object nullArg = null;
|
||||
|
||||
int exact = (int) handle.getAndAdd(instance, 1);
|
||||
Integer boxed = (Integer) handle.getAndAdd(instance, 2);
|
||||
Object object = (Object) handle.getAndAdd(instance, 3);
|
||||
handle.getAndAdd(instance, 4);
|
||||
String incompatible = (<warning descr="Should be cast to 'int'">String</warning>) handle.getAndAdd(instance, 0);
|
||||
int incompatibleArg = (int) handle.getAndSet(instance, <warning descr="Argument is not assignable to 'int'">"abc"</warning>);
|
||||
handle.getAndAdd<warning descr="2 arguments are expected">(instance)</warning>;
|
||||
handle.getAndAdd<warning descr="2 arguments are expected">()</warning>;
|
||||
handle.getAndAdd(<warning descr="Call receiver is 'null'">nullArg</warning>, 0);
|
||||
int wrongReceiver = (int)handle.getAndAdd(<warning descr="Call receiver type is incompatible: 'Test' is expected">123</warning>, 42);
|
||||
|
||||
int exactA = (int) handle.getAndAddAcquire(instance, 1); ;
|
||||
Integer boxedA = (Integer) handle.getAndAddAcquire(instance, 2);
|
||||
Object objectA = (Object) handle.getAndAddAcquire(instance, 3);
|
||||
handle.getAndAddAcquire(instance, 4);
|
||||
String incompatibleA = (<warning descr="Should be cast to 'int'">String</warning>) handle.getAndAddAcquire(instance, 0);
|
||||
int incompatibleArgA = (int) handle.getAndSetAcquire(instance, <warning descr="Argument is not assignable to 'int'">"abc"</warning>);
|
||||
handle.getAndAddAcquire<warning descr="2 arguments are expected">(instance)</warning>;
|
||||
handle.getAndAddAcquire<warning descr="2 arguments are expected">()</warning>;
|
||||
handle.getAndAddAcquire(<warning descr="Call receiver is 'null'">nullArg</warning>, 0);
|
||||
int <error descr="Variable 'wrongReceiver' is already defined in the scope">wrongReceiver</error> = (int)handle.getAndAddAcquire(<warning descr="Call receiver type is incompatible: 'Test' is expected">123</warning>, 42);
|
||||
|
||||
int exactR = (int) handle.getAndAddRelease(instance, 1); ;
|
||||
Integer boxedR = (Integer) handle.getAndAddRelease(instance, 2);
|
||||
Object objectR = (Object) handle.getAndAddRelease(instance, 3);
|
||||
handle.getAndAddRelease(instance, 4);
|
||||
String incompatibleR = (<warning descr="Should be cast to 'int'">String</warning>) handle.getAndAdd(instance, 0);
|
||||
int incompatibleArgR = (int) handle.getAndSetRelease(instance, <warning descr="Argument is not assignable to 'int'">"abc"</warning>);
|
||||
handle.getAndAddRelease<warning descr="2 arguments are expected">(instance)</warning>;
|
||||
handle.getAndAddRelease<warning descr="2 arguments are expected">()</warning>;
|
||||
handle.getAndAddRelease(<warning descr="Call receiver is 'null'">nullArg</warning>, 0);
|
||||
int wrongReceiverR = (int)handle.getAndAddRelease(<warning descr="Call receiver type is incompatible: 'Test' is expected">123</warning>, 42);
|
||||
}
|
||||
|
||||
private void getAndSetStr() throws Throwable {
|
||||
MethodHandles.Lookup lookup = MethodHandles.lookup();
|
||||
final VarHandle handle = lookup.findVarHandle(Test.class, "s", String.class);
|
||||
final Test instance = new Test();
|
||||
final Object nullArg = null;
|
||||
|
||||
String exact = (String) handle.getAndSet(instance, "a");
|
||||
CharSequence parent = (CharSequence) handle.getAndSet(instance, "b");
|
||||
Object object = (Object) handle.getAndSet(instance, "c");
|
||||
String subclassArg = (String) handle.getAndSet(instance, charSequence());
|
||||
String withNullArg = (String) handle.getAndSet(instance, nullArg);
|
||||
handle.getAndSet(instance, "d");
|
||||
Integer incompatible = (<warning descr="Should be cast to 'java.lang.String' or its superclass">Integer</warning>) handle.getAndSet(instance, "e");
|
||||
String incompatibleArg = (String) handle.getAndSet(instance, <warning descr="Argument is not assignable to 'java.lang.String'">123</warning>);
|
||||
handle.getAndSet<warning descr="2 arguments are expected">(instance)</warning>;
|
||||
handle.getAndSet<warning descr="2 arguments are expected">()</warning>;
|
||||
handle.getAndSet(<warning descr="Call receiver is 'null'">nullArg</warning>, "abc");
|
||||
int wrongReceiver = (<warning descr="Should be cast to 'java.lang.String' or its superclass">int</warning>)handle.getAndSet(<warning descr="Call receiver type is incompatible: 'Test' is expected">"abc"</warning>, "e");
|
||||
|
||||
String exactA = (String) handle.getAndSetAcquire(instance, "a");
|
||||
CharSequence parentA = (CharSequence) handle.getAndSetAcquire(instance, "b");
|
||||
Object objectA = (Object) handle.getAndSetAcquire(instance, "c");;
|
||||
String subclassArgA = (String) handle.getAndSetAcquire(instance, charSequence());
|
||||
String withNullArgA = (String) handle.getAndSetAcquire(instance, nullArg);
|
||||
handle.getAndSetAcquire(instance, "d");
|
||||
Integer incompatibleA = (<warning descr="Should be cast to 'java.lang.String' or its superclass">Integer</warning>) handle.getAndSetAcquire(instance, "e");
|
||||
String incompatibleArgA = (String) handle.getAndSetAcquire(instance, <warning descr="Argument is not assignable to 'java.lang.String'">123</warning>);
|
||||
handle.getAndSetAcquire<warning descr="2 arguments are expected">(instance)</warning>;
|
||||
handle.getAndSetAcquire<warning descr="2 arguments are expected">()</warning>;
|
||||
handle.getAndSetAcquire(<warning descr="Call receiver is 'null'">nullArg</warning>, "abc");
|
||||
int wrongReceiverA = (<warning descr="Should be cast to 'java.lang.String' or its superclass">int</warning>)handle.getAndSetAcquire(<warning descr="Call receiver type is incompatible: 'Test' is expected">"abc"</warning>, "e");
|
||||
|
||||
String exactR = (String) handle.getAndSetRelease(instance, "a");
|
||||
CharSequence parentR = (CharSequence) handle.getAndSetRelease(instance, "b");
|
||||
Object objectR = (Object) handle.getAndSetRelease(instance, "c");;
|
||||
String subclassArgR = (String) handle.getAndSetRelease(instance, charSequence());
|
||||
String withNullArgR = (String) handle.getAndSetRelease(instance, nullArg);
|
||||
handle.getAndSetRelease(instance, "d");
|
||||
Integer incompatibleR = (<warning descr="Should be cast to 'java.lang.String' or its superclass">Integer</warning>) handle.getAndSetRelease(instance, "e");
|
||||
String incompatibleArgR = (String) handle.getAndSetRelease(instance, <warning descr="Argument is not assignable to 'java.lang.String'">123</warning>);
|
||||
handle.getAndSetRelease<warning descr="2 arguments are expected">(instance)</warning>;
|
||||
handle.getAndSetRelease<warning descr="2 arguments are expected">()</warning>;
|
||||
handle.getAndSetRelease(<warning descr="Call receiver is 'null'">nullArg</warning>, "abc");
|
||||
int wrongReceiverR = (<warning descr="Should be cast to 'java.lang.String' or its superclass">int</warning>)handle.getAndSetRelease(<warning descr="Call receiver type is incompatible: 'Test' is expected">"abc"</warning>, "e");
|
||||
}
|
||||
|
||||
void getAndBitwise() throws Throwable {
|
||||
MethodHandles.Lookup lookup = MethodHandles.lookup();
|
||||
VarHandle handle = lookup.findVarHandle(Test.class, "n", int.class);
|
||||
Test instance = new Test();
|
||||
|
||||
int exactBitwiseAnd = (int) handle.getAndBitwiseAnd(instance, 1);
|
||||
int exactBitwiseAndA = (int) handle.getAndBitwiseAndAcquire(instance, 2);
|
||||
int exactBitwiseAndR = (int) handle.getAndBitwiseAndRelease(instance, 3);
|
||||
|
||||
int wrongArgBitwiseAnd = (int) handle.getAndBitwiseAnd(instance, <warning descr="Argument is not assignable to 'int'">"a"</warning>);
|
||||
int wrongArgBitwiseAndA = (int) handle.getAndBitwiseAndAcquire(instance, <warning descr="Argument is not assignable to 'int'">"b"</warning>);
|
||||
int wrongArgBitwiseAndR = (int) handle.getAndBitwiseAndRelease(instance, <warning descr="Argument is not assignable to 'int'">"c"</warning>);
|
||||
|
||||
String wrongResultBitwiseAnd = (<warning descr="Should be cast to 'int'">String</warning>) handle.getAndBitwiseAnd(instance, 1);
|
||||
String wrongResultBitwiseAndA = (<warning descr="Should be cast to 'int'">String</warning>) handle.getAndBitwiseAndAcquire(instance, 2);
|
||||
String wrongResultBitwiseAndR = (<warning descr="Should be cast to 'int'">String</warning>) handle.getAndBitwiseAndRelease(instance, 3);
|
||||
|
||||
int exactBitwiseOr = (int) handle.getAndBitwiseOr(instance, 1);
|
||||
int exactBitwiseOrA = (int) handle.getAndBitwiseOrAcquire(instance, 2);
|
||||
int exactBitwiseOrR = (int) handle.getAndBitwiseOrRelease(instance, 3);
|
||||
|
||||
int wrongArgBitwiseOr = (int) handle.getAndBitwiseOr(instance, <warning descr="Argument is not assignable to 'int'">"a"</warning>);
|
||||
int wrongArgBitwiseOrA = (int) handle.getAndBitwiseOrAcquire(instance, <warning descr="Argument is not assignable to 'int'">"b"</warning>);
|
||||
int wrongArgBitwiseOrR = (int) handle.getAndBitwiseOrRelease(instance, <warning descr="Argument is not assignable to 'int'">"c"</warning>);
|
||||
|
||||
String wrongResultBitwiseOr = (<warning descr="Should be cast to 'int'">String</warning>) handle.getAndBitwiseOr(instance, 1);
|
||||
String wrongResultBitwiseOrA = (<warning descr="Should be cast to 'int'">String</warning>) handle.getAndBitwiseOrAcquire(instance, 2);
|
||||
String wrongResultBitwiseOrR = (<warning descr="Should be cast to 'int'">String</warning>) handle.getAndBitwiseOrRelease(instance, 3);
|
||||
|
||||
int exactBitwiseXor = (int) handle.getAndBitwiseXor(instance, 1);
|
||||
int exactBitwiseXorA = (int) handle.getAndBitwiseXorAcquire(instance, 2);
|
||||
int exactBitwiseXorR = (int) handle.getAndBitwiseXorRelease(instance, 3);
|
||||
|
||||
int wrongArgBitwiseXor = (int) handle.getAndBitwiseXor(instance, <warning descr="Argument is not assignable to 'int'">"a"</warning>);
|
||||
int wrongArgBitwiseXorA = (int) handle.getAndBitwiseXorAcquire(instance, <warning descr="Argument is not assignable to 'int'">"b"</warning>);
|
||||
int wrongArgBitwiseXorR = (int) handle.getAndBitwiseXorRelease(instance, <warning descr="Argument is not assignable to 'int'">"c"</warning>);
|
||||
|
||||
String wrongResultBitwiseXor = (<warning descr="Should be cast to 'int'">String</warning>) handle.getAndBitwiseXor(instance, 1);
|
||||
String wrongResultBitwiseXorA = (<warning descr="Should be cast to 'int'">String</warning>) handle.getAndBitwiseXorAcquire(instance, 2);
|
||||
String wrongResultBitwiseXorR = (<warning descr="Should be cast to 'int'">String</warning>) handle.getAndBitwiseXorRelease(instance, 3);
|
||||
}
|
||||
|
||||
|
||||
void compare() throws Throwable {
|
||||
MethodHandles.Lookup lookup = MethodHandles.lookup();
|
||||
final VarHandle handle = lookup.findVarHandle(Test.class, "myS", String.class);
|
||||
final Test instance = new Test();
|
||||
|
||||
boolean exactCAS = handle.compareAndSet(instance, "a", "b");
|
||||
String exactCAE = (String)handle.compareAndExchange(instance, "a", "b");
|
||||
String exactCAEA = (String)handle.compareAndExchangeAcquire(instance, "a", "b");
|
||||
String exactCAER = (String)handle.compareAndExchangeRelease(instance, "a", "b");
|
||||
|
||||
boolean badArg2CAS = handle.compareAndSet(instance, <warning descr="Argument is not assignable to 'java.lang.String'">1</warning>, "b");
|
||||
String badArg2CAE = (String)handle.compareAndExchange(instance, <warning descr="Argument is not assignable to 'java.lang.String'">2</warning>, "b");
|
||||
String badArg2CAEa = (String)handle.compareAndExchangeAcquire(instance, <warning descr="Argument is not assignable to 'java.lang.String'">3</warning>, "b");
|
||||
String badArg2CAEr = (String)handle.compareAndExchangeRelease(instance, <warning descr="Argument is not assignable to 'java.lang.String'">4</warning>, "b");
|
||||
|
||||
boolean badArg3CAS = handle.compareAndSet(instance, "a", <warning descr="Argument is not assignable to 'java.lang.String'">1</warning>);
|
||||
String badArg3CAE = (String)handle.compareAndExchange(instance, "a", <warning descr="Argument is not assignable to 'java.lang.String'">2</warning>);
|
||||
String badArg3CAEa = (String)handle.compareAndExchangeAcquire(instance, "a", <warning descr="Argument is not assignable to 'java.lang.String'">3</warning>);
|
||||
String badArg3CAEr = (String)handle.compareAndExchangeRelease(instance, "a", <warning descr="Argument is not assignable to 'java.lang.String'">4</warning>);
|
||||
|
||||
Integer badResultCAE = (<warning descr="Should be cast to 'java.lang.String' or its superclass">Integer</warning>)handle.compareAndExchange(instance, "a", "b");
|
||||
Integer badResultCAEa = (<warning descr="Should be cast to 'java.lang.String' or its superclass">Integer</warning>)handle.compareAndExchangeAcquire(instance, "a", "b");
|
||||
Integer badResultCAEr = (<warning descr="Should be cast to 'java.lang.String' or its superclass">Integer</warning>)handle.compareAndExchangeRelease(instance, "a", "b");
|
||||
}
|
||||
|
||||
void weakCompare() throws Throwable {
|
||||
MethodHandles.Lookup lookup = MethodHandles.lookup();
|
||||
final VarHandle handle = lookup.findVarHandle(Test.class, "myS", String.class);
|
||||
final Test instance = new Test();
|
||||
|
||||
boolean exactCAS = handle.weakCompareAndSet(instance, "a", "b");
|
||||
boolean exactCASp = handle.weakCompareAndSetPlain(instance, "a", "b");
|
||||
boolean exactCASa = handle.weakCompareAndSetAcquire(instance, "a", "b");
|
||||
boolean exactCASr = handle.weakCompareAndSetRelease(instance, "a", "b");
|
||||
|
||||
boolean badArg2CAS = handle.weakCompareAndSet(instance, <warning descr="Argument is not assignable to 'java.lang.String'">1</warning>, "b");
|
||||
boolean badArg2CASp = handle.weakCompareAndSetPlain(instance, <warning descr="Argument is not assignable to 'java.lang.String'">2</warning>, "b");
|
||||
boolean badArg2CASa = handle.weakCompareAndSetAcquire(instance, <warning descr="Argument is not assignable to 'java.lang.String'">3</warning>, "b");
|
||||
boolean badArg2CASr = handle.weakCompareAndSetRelease(instance, <warning descr="Argument is not assignable to 'java.lang.String'">4</warning>, "b");
|
||||
|
||||
boolean badArg3CAS = handle.weakCompareAndSet(instance, "a", <warning descr="Argument is not assignable to 'java.lang.String'">1</warning>);
|
||||
boolean badArg3CASp = handle.weakCompareAndSetPlain(instance, "a", <warning descr="Argument is not assignable to 'java.lang.String'">2</warning>);
|
||||
boolean badArg3CASa = handle.weakCompareAndSetAcquire(instance, "a", <warning descr="Argument is not assignable to 'java.lang.String'">3</warning>);
|
||||
boolean badArg3CASr = handle.weakCompareAndSetRelease(instance, "a", <warning descr="Argument is not assignable to 'java.lang.String'">4</warning>);
|
||||
}
|
||||
|
||||
private static CharSequence charSequence() { return "abc"; }
|
||||
}
|
||||
|
||||
class Test {
|
||||
public int n;
|
||||
public String s;
|
||||
}
|
||||
+23
-11
@@ -25,17 +25,9 @@ import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase
|
||||
/**
|
||||
* @author Pavel.Dolgov
|
||||
*/
|
||||
class JavaLangReflectHandleInvocationTest : LightCodeInsightFixtureTestCase() {
|
||||
override fun setUp() {
|
||||
super.setUp()
|
||||
LanguageLevelProjectExtension.getInstance(project).languageLevel = LanguageLevel.JDK_1_7
|
||||
myFixture.enableInspections(JavaLangReflectHandleInvocationInspection())
|
||||
}
|
||||
|
||||
override fun getProjectDescriptor(): LightProjectDescriptor = LightCodeInsightFixtureTestCase.JAVA_8
|
||||
|
||||
override fun getBasePath() = JavaTestUtil.getRelativeJavaTestDataPath() + "/inspection/javaLangReflectHandleInvocation"
|
||||
|
||||
class JavaLangReflectHandleInvocationTest : JavaLangReflectHandleInvocationTestBase(LanguageLevel.JDK_1_7,
|
||||
LightCodeInsightFixtureTestCase.JAVA_8) {
|
||||
fun testVirtual() = doTest()
|
||||
fun testStatic() = doTest()
|
||||
fun testConstructor() = doTest()
|
||||
@@ -45,8 +37,28 @@ class JavaLangReflectHandleInvocationTest : LightCodeInsightFixtureTestCase() {
|
||||
|
||||
fun testStaticGetter() = doTest()
|
||||
fun testStaticSetter() = doTest()
|
||||
}
|
||||
|
||||
private fun doTest() {
|
||||
class Java9LangReflectHandleInvocationTest : JavaLangReflectHandleInvocationTestBase(LanguageLevel.JDK_1_9,
|
||||
LightCodeInsightFixtureTestCase.JAVA_9) {
|
||||
fun testVarHandle() = doTest()
|
||||
fun testStaticVarHandle() = doTest()
|
||||
fun testArrayVarHandle() = doTest()
|
||||
}
|
||||
|
||||
abstract class JavaLangReflectHandleInvocationTestBase(val languageLevel: LanguageLevel,
|
||||
val descriptor: LightProjectDescriptor) : LightCodeInsightFixtureTestCase() {
|
||||
override fun setUp() {
|
||||
super.setUp()
|
||||
LanguageLevelProjectExtension.getInstance(project).languageLevel = languageLevel
|
||||
myFixture.enableInspections(JavaLangReflectHandleInvocationInspection())
|
||||
}
|
||||
|
||||
override fun getProjectDescriptor(): LightProjectDescriptor = descriptor
|
||||
|
||||
override fun getBasePath() = JavaTestUtil.getRelativeJavaTestDataPath() + "/inspection/javaLangReflectHandleInvocation"
|
||||
|
||||
protected fun doTest() {
|
||||
myFixture.testHighlighting("${getTestName(false)}.java")
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user