< prev index next >

test/jdk/java/lang/invoke/VarHandles/X-VarHandleTestMethodType.java.template

Print this page
rev 55900 : 8207257: Add VarHandle access test for value type declared in ref type
Reviewed-by: tbd

@@ -1,7 +1,7 @@
 /*
- * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2019, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.

@@ -19,16 +19,28 @@
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
 
+#warn
+
+#if[Value]
+/*
+ * @test
+ * @bug 8156486 8207257
+ * @run testng/othervm -XX:+EnableValhalla VarHandleTestMethodType$Type$
+ * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false
+ *                     -XX:+EnableValhalla  VarHandleTestMethodType$Type$
+ */
+#else[Value]
 /*
  * @test
- * @bug 8156486
+ * @bug 8156486 8207257
  * @run testng/othervm VarHandleTestMethodType$Type$
  * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false VarHandleTestMethodType$Type$
  */
+#end[Value]
 
 import org.testng.annotations.BeforeClass;
 import org.testng.annotations.DataProvider;
 import org.testng.annotations.Test;
 

@@ -134,11 +146,11 @@
         });
         checkWMTE(() -> { // receiver primitive class
             $type$ x = ($type$) vh.get(0);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void x = (Void) vh.get(recv);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.get(recv);
         });

@@ -157,11 +169,11 @@
             vh.set(null, $value1$);
         });
         checkCCE(() -> { // receiver reference class
             vh.set(Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             vh.set(recv, Void.class);
         });
         checkWMTE(() -> { // receiver primitive class
             vh.set(0, $value1$);
         });

@@ -184,11 +196,11 @@
         });
         checkWMTE(() -> { // receiver primitive class
             $type$ x = ($type$) vh.getVolatile(0);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void x = (Void) vh.getVolatile(recv);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getVolatile(recv);
         });

@@ -207,11 +219,11 @@
             vh.setVolatile(null, $value1$);
         });
         checkCCE(() -> { // receiver reference class
             vh.setVolatile(Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             vh.setVolatile(recv, Void.class);
         });
         checkWMTE(() -> { // receiver primitive class
             vh.setVolatile(0, $value1$);
         });

@@ -234,11 +246,11 @@
         });
         checkWMTE(() -> { // receiver primitive class
             $type$ x = ($type$) vh.getOpaque(0);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void x = (Void) vh.getOpaque(recv);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getOpaque(recv);
         });

@@ -257,11 +269,11 @@
             vh.setOpaque(null, $value1$);
         });
         checkCCE(() -> { // receiver reference class
             vh.setOpaque(Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             vh.setOpaque(recv, Void.class);
         });
         checkWMTE(() -> { // receiver primitive class
             vh.setOpaque(0, $value1$);
         });

@@ -284,11 +296,11 @@
         });
         checkWMTE(() -> { // receiver primitive class
             $type$ x = ($type$) vh.getAcquire(0);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void x = (Void) vh.getAcquire(recv);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAcquire(recv);
         });

@@ -307,11 +319,11 @@
             vh.setRelease(null, $value1$);
         });
         checkCCE(() -> { // receiver reference class
             vh.setRelease(Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             vh.setRelease(recv, Void.class);
         });
         checkWMTE(() -> { // receiver primitive class
             vh.setRelease(0, $value1$);
         });

@@ -331,14 +343,14 @@
             boolean r = vh.compareAndSet(null, $value1$, $value1$);
         });
         checkCCE(() -> { // receiver reference class
             boolean r = vh.compareAndSet(Void.class, $value1$, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // expected reference class
             boolean r = vh.compareAndSet(recv, Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // actual reference class
             boolean r = vh.compareAndSet(recv, $value1$, Void.class);
         });
         checkWMTE(() -> { // receiver primitive class
             boolean r = vh.compareAndSet(0, $value1$, $value1$);
         });

@@ -357,14 +369,14 @@
             boolean r = vh.weakCompareAndSetPlain(null, $value1$, $value1$);
         });
         checkCCE(() -> { // receiver reference class
             boolean r = vh.weakCompareAndSetPlain(Void.class, $value1$, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // expected reference class
             boolean r = vh.weakCompareAndSetPlain(recv, Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // actual reference class
             boolean r = vh.weakCompareAndSetPlain(recv, $value1$, Void.class);
         });
         checkWMTE(() -> { // receiver primitive class
             boolean r = vh.weakCompareAndSetPlain(0, $value1$, $value1$);
         });

@@ -383,14 +395,14 @@
             boolean r = vh.weakCompareAndSet(null, $value1$, $value1$);
         });
         checkCCE(() -> { // receiver reference class
             boolean r = vh.weakCompareAndSet(Void.class, $value1$, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // expected reference class
             boolean r = vh.weakCompareAndSet(recv, Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // actual reference class
             boolean r = vh.weakCompareAndSet(recv, $value1$, Void.class);
         });
         checkWMTE(() -> { // receiver primitive class
             boolean r = vh.weakCompareAndSet(0, $value1$, $value1$);
         });

@@ -409,14 +421,14 @@
             boolean r = vh.weakCompareAndSetAcquire(null, $value1$, $value1$);
         });
         checkCCE(() -> { // receiver reference class
             boolean r = vh.weakCompareAndSetAcquire(Void.class, $value1$, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // expected reference class
             boolean r = vh.weakCompareAndSetAcquire(recv, Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // actual reference class
             boolean r = vh.weakCompareAndSetAcquire(recv, $value1$, Void.class);
         });
         checkWMTE(() -> { // receiver primitive class
             boolean r = vh.weakCompareAndSetAcquire(0, $value1$, $value1$);
         });

@@ -435,14 +447,14 @@
             boolean r = vh.weakCompareAndSetRelease(null, $value1$, $value1$);
         });
         checkCCE(() -> { // receiver reference class
             boolean r = vh.weakCompareAndSetRelease(Void.class, $value1$, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // expected reference class
             boolean r = vh.weakCompareAndSetRelease(recv, Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // actual reference class
             boolean r = vh.weakCompareAndSetRelease(recv, $value1$, Void.class);
         });
         checkWMTE(() -> { // receiver primitive class
             boolean r = vh.weakCompareAndSetRelease(0, $value1$, $value1$);
         });

@@ -461,21 +473,21 @@
             $type$ x = ($type$) vh.compareAndExchange(null, $value1$, $value1$);
         });
         checkCCE(() -> { // receiver reference class
             $type$ x = ($type$) vh.compareAndExchange(Void.class, $value1$, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // expected reference class
             $type$ x = ($type$) vh.compareAndExchange(recv, Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // actual reference class
             $type$ x = ($type$) vh.compareAndExchange(recv, $value1$, Void.class);
         });
         checkWMTE(() -> { // reciever primitive class
             $type$ x = ($type$) vh.compareAndExchange(0, $value1$, $value1$);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.compareAndExchange(recv, $value1$, $value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.compareAndExchange(recv, $value1$, $value1$);
         });

@@ -494,21 +506,21 @@
             $type$ x = ($type$) vh.compareAndExchangeAcquire(null, $value1$, $value1$);
         });
         checkCCE(() -> { // receiver reference class
             $type$ x = ($type$) vh.compareAndExchangeAcquire(Void.class, $value1$, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // expected reference class
             $type$ x = ($type$) vh.compareAndExchangeAcquire(recv, Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // actual reference class
             $type$ x = ($type$) vh.compareAndExchangeAcquire(recv, $value1$, Void.class);
         });
         checkWMTE(() -> { // reciever primitive class
             $type$ x = ($type$) vh.compareAndExchangeAcquire(0, $value1$, $value1$);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.compareAndExchangeAcquire(recv, $value1$, $value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.compareAndExchangeAcquire(recv, $value1$, $value1$);
         });

@@ -527,21 +539,21 @@
             $type$ x = ($type$) vh.compareAndExchangeRelease(null, $value1$, $value1$);
         });
         checkCCE(() -> { // receiver reference class
             $type$ x = ($type$) vh.compareAndExchangeRelease(Void.class, $value1$, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // expected reference class
             $type$ x = ($type$) vh.compareAndExchangeRelease(recv, Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // actual reference class
             $type$ x = ($type$) vh.compareAndExchangeRelease(recv, $value1$, Void.class);
         });
         checkWMTE(() -> { // reciever primitive class
             $type$ x = ($type$) vh.compareAndExchangeRelease(0, $value1$, $value1$);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.compareAndExchangeRelease(recv, $value1$, $value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.compareAndExchangeRelease(recv, $value1$, $value1$);
         });

@@ -560,18 +572,18 @@
             $type$ x = ($type$) vh.getAndSet(null, $value1$);
         });
         checkCCE(() -> { // receiver reference class
             $type$ x = ($type$) vh.getAndSet(Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndSet(recv, Void.class);
         });
         checkWMTE(() -> { // reciever primitive class
             $type$ x = ($type$) vh.getAndSet(0, $value1$);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndSet(recv, $value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndSet(recv, $value1$);
         });

@@ -589,18 +601,18 @@
             $type$ x = ($type$) vh.getAndSetAcquire(null, $value1$);
         });
         checkCCE(() -> { // receiver reference class
             $type$ x = ($type$) vh.getAndSetAcquire(Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndSetAcquire(recv, Void.class);
         });
         checkWMTE(() -> { // reciever primitive class
             $type$ x = ($type$) vh.getAndSetAcquire(0, $value1$);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndSetAcquire(recv, $value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndSetAcquire(recv, $value1$);
         });

@@ -618,18 +630,18 @@
             $type$ x = ($type$) vh.getAndSetRelease(null, $value1$);
         });
         checkCCE(() -> { // receiver reference class
             $type$ x = ($type$) vh.getAndSetRelease(Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndSetRelease(recv, Void.class);
         });
         checkWMTE(() -> { // reciever primitive class
             $type$ x = ($type$) vh.getAndSetRelease(0, $value1$);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndSetRelease(recv, $value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndSetRelease(recv, $value1$);
         });

@@ -649,18 +661,18 @@
             $type$ x = ($type$) vh.getAndAdd(null, $value1$);
         });
         checkCCE(() -> { // receiver reference class
             $type$ x = ($type$) vh.getAndAdd(Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndAdd(recv, Void.class);
         });
         checkWMTE(() -> { // reciever primitive class
             $type$ x = ($type$) vh.getAndAdd(0, $value1$);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndAdd(recv, $value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndAdd(recv, $value1$);
         });

@@ -678,18 +690,18 @@
             $type$ x = ($type$) vh.getAndAddAcquire(null, $value1$);
         });
         checkCCE(() -> { // receiver reference class
             $type$ x = ($type$) vh.getAndAddAcquire(Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndAddAcquire(recv, Void.class);
         });
         checkWMTE(() -> { // reciever primitive class
             $type$ x = ($type$) vh.getAndAddAcquire(0, $value1$);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndAddAcquire(recv, $value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndAddAcquire(recv, $value1$);
         });

@@ -707,18 +719,18 @@
             $type$ x = ($type$) vh.getAndAddRelease(null, $value1$);
         });
         checkCCE(() -> { // receiver reference class
             $type$ x = ($type$) vh.getAndAddRelease(Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndAddRelease(recv, Void.class);
         });
         checkWMTE(() -> { // reciever primitive class
             $type$ x = ($type$) vh.getAndAddRelease(0, $value1$);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndAddRelease(recv, $value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndAddRelease(recv, $value1$);
         });

@@ -738,18 +750,18 @@
             $type$ x = ($type$) vh.getAndBitwiseOr(null, $value1$);
         });
         checkCCE(() -> { // receiver reference class
             $type$ x = ($type$) vh.getAndBitwiseOr(Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndBitwiseOr(recv, Void.class);
         });
         checkWMTE(() -> { // reciever primitive class
             $type$ x = ($type$) vh.getAndBitwiseOr(0, $value1$);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndBitwiseOr(recv, $value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseOr(recv, $value1$);
         });

@@ -768,18 +780,18 @@
             $type$ x = ($type$) vh.getAndBitwiseOrAcquire(null, $value1$);
         });
         checkCCE(() -> { // receiver reference class
             $type$ x = ($type$) vh.getAndBitwiseOrAcquire(Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndBitwiseOrAcquire(recv, Void.class);
         });
         checkWMTE(() -> { // reciever primitive class
             $type$ x = ($type$) vh.getAndBitwiseOrAcquire(0, $value1$);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndBitwiseOrAcquire(recv, $value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseOrAcquire(recv, $value1$);
         });

@@ -798,18 +810,18 @@
             $type$ x = ($type$) vh.getAndBitwiseOrRelease(null, $value1$);
         });
         checkCCE(() -> { // receiver reference class
             $type$ x = ($type$) vh.getAndBitwiseOr(Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndBitwiseOr(recv, Void.class);
         });
         checkWMTE(() -> { // reciever primitive class
             $type$ x = ($type$) vh.getAndBitwiseOr(0, $value1$);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndBitwiseOr(recv, $value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseOr(recv, $value1$);
         });

@@ -828,18 +840,18 @@
             $type$ x = ($type$) vh.getAndBitwiseAnd(null, $value1$);
         });
         checkCCE(() -> { // receiver reference class
             $type$ x = ($type$) vh.getAndBitwiseAnd(Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndBitwiseAnd(recv, Void.class);
         });
         checkWMTE(() -> { // reciever primitive class
             $type$ x = ($type$) vh.getAndBitwiseAnd(0, $value1$);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndBitwiseAnd(recv, $value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseAnd(recv, $value1$);
         });

@@ -858,18 +870,18 @@
             $type$ x = ($type$) vh.getAndBitwiseAndAcquire(null, $value1$);
         });
         checkCCE(() -> { // receiver reference class
             $type$ x = ($type$) vh.getAndBitwiseAndAcquire(Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndBitwiseAndAcquire(recv, Void.class);
         });
         checkWMTE(() -> { // reciever primitive class
             $type$ x = ($type$) vh.getAndBitwiseAndAcquire(0, $value1$);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndBitwiseAndAcquire(recv, $value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseAndAcquire(recv, $value1$);
         });

@@ -888,18 +900,18 @@
             $type$ x = ($type$) vh.getAndBitwiseAndRelease(null, $value1$);
         });
         checkCCE(() -> { // receiver reference class
             $type$ x = ($type$) vh.getAndBitwiseAnd(Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndBitwiseAnd(recv, Void.class);
         });
         checkWMTE(() -> { // reciever primitive class
             $type$ x = ($type$) vh.getAndBitwiseAnd(0, $value1$);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndBitwiseAnd(recv, $value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseAnd(recv, $value1$);
         });

@@ -918,18 +930,18 @@
             $type$ x = ($type$) vh.getAndBitwiseXor(null, $value1$);
         });
         checkCCE(() -> { // receiver reference class
             $type$ x = ($type$) vh.getAndBitwiseXor(Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndBitwiseXor(recv, Void.class);
         });
         checkWMTE(() -> { // reciever primitive class
             $type$ x = ($type$) vh.getAndBitwiseXor(0, $value1$);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndBitwiseXor(recv, $value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseXor(recv, $value1$);
         });

@@ -948,18 +960,18 @@
             $type$ x = ($type$) vh.getAndBitwiseXorAcquire(null, $value1$);
         });
         checkCCE(() -> { // receiver reference class
             $type$ x = ($type$) vh.getAndBitwiseXorAcquire(Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndBitwiseXorAcquire(recv, Void.class);
         });
         checkWMTE(() -> { // reciever primitive class
             $type$ x = ($type$) vh.getAndBitwiseXorAcquire(0, $value1$);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndBitwiseXorAcquire(recv, $value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseXorAcquire(recv, $value1$);
         });

@@ -978,18 +990,18 @@
             $type$ x = ($type$) vh.getAndBitwiseXorRelease(null, $value1$);
         });
         checkCCE(() -> { // receiver reference class
             $type$ x = ($type$) vh.getAndBitwiseXor(Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndBitwiseXor(recv, Void.class);
         });
         checkWMTE(() -> { // reciever primitive class
             $type$ x = ($type$) vh.getAndBitwiseXor(0, $value1$);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndBitwiseXor(recv, $value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseXor(recv, $value1$);
         });

@@ -1017,11 +1029,11 @@
             checkWMTE(() -> { // receiver primitive class
                 $type$ x = ($type$) hs.get(am, methodType($type$.class, int.class)).
                     invokeExact(0);
             });
             // Incorrect return type
-            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // reference class
+            {#if[Class]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // reference class
                 Void x = (Void) hs.get(am, methodType(Void.class, VarHandleTestMethodType$Type$.class)).
                     invokeExact(recv);
             });
             checkWMTE(() -> { // primitive class
                 $wrong_primitive_type$ x = ($wrong_primitive_type$) hs.get(am, methodType($wrong_primitive_type$.class, VarHandleTestMethodType$Type$.class)).

@@ -1046,11 +1058,11 @@
             });
             hs.checkWMTEOrCCE(() -> { // receiver reference class
                 hs.get(am, methodType(void.class, Class.class, $type$.class)).
                     invokeExact(Void.class, $value1$);
             });
-            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // value reference class
+            {#if[Class]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // value reference class
                 hs.get(am, methodType(void.class, VarHandleTestMethodType$Type$.class, Class.class)).
                     invokeExact(recv, Void.class);
             });
             checkWMTE(() -> { // receiver primitive class
                 hs.get(am, methodType(void.class, int.class, $type$.class)).

@@ -1076,15 +1088,15 @@
             });
             hs.checkWMTEOrCCE(() -> { // receiver reference class
                 boolean r = (boolean) hs.get(am, methodType(boolean.class, Class.class, $type$.class, $type$.class)).
                     invokeExact(Void.class, $value1$, $value1$);
             });
-            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // expected reference class
+            {#if[Class]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // expected reference class
                 boolean r = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodType$Type$.class, Class.class, $type$.class)).
                     invokeExact(recv, Void.class, $value1$);
             });
-            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // actual reference class
+            {#if[Class]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // actual reference class
                 boolean r = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodType$Type$.class, $type$.class, Class.class)).
                     invokeExact(recv, $value1$, Void.class);
             });
             checkWMTE(() -> { // receiver primitive class
                 boolean r = (boolean) hs.get(am, methodType(boolean.class, int.class , $type$.class, $type$.class)).

@@ -1108,24 +1120,24 @@
             });
             hs.checkWMTEOrCCE(() -> { // receiver reference class
                 $type$ x = ($type$) hs.get(am, methodType($type$.class, Class.class, $type$.class, $type$.class)).
                     invokeExact(Void.class, $value1$, $value1$);
             });
-            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // expected reference class
+            {#if[Class]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // expected reference class
                 $type$ x = ($type$) hs.get(am, methodType($type$.class, VarHandleTestMethodType$Type$.class, Class.class, $type$.class)).
                     invokeExact(recv, Void.class, $value1$);
             });
-            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // actual reference class
+            {#if[Class]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // actual reference class
                 $type$ x = ($type$) hs.get(am, methodType($type$.class, VarHandleTestMethodType$Type$.class, $type$.class, Class.class)).
                     invokeExact(recv, $value1$, Void.class);
             });
             checkWMTE(() -> { // reciever primitive class
                 $type$ x = ($type$) hs.get(am, methodType($type$.class, int.class , $type$.class, $type$.class)).
                     invokeExact(0, $value1$, $value1$);
             });
             // Incorrect return type
-            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // reference class
+            {#if[Class]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // reference class
                 Void r = (Void) hs.get(am, methodType(Void.class, VarHandleTestMethodType$Type$.class , $type$.class, $type$.class)).
                     invokeExact(recv, $value1$, $value1$);
             });
             checkWMTE(() -> { // primitive class
                 $wrong_primitive_type$ x = ($wrong_primitive_type$) hs.get(am, methodType($wrong_primitive_type$.class, VarHandleTestMethodType$Type$.class , $type$.class, $type$.class)).

@@ -1149,20 +1161,20 @@
             });
             hs.checkWMTEOrCCE(() -> { // receiver reference class
                 $type$ x = ($type$) hs.get(am, methodType($type$.class, Class.class, $type$.class)).
                     invokeExact(Void.class, $value1$);
             });
-            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // value reference class
+            {#if[Class]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // value reference class
                 $type$ x = ($type$) hs.get(am, methodType($type$.class, VarHandleTestMethodType$Type$.class, Class.class)).
                     invokeExact(recv, Void.class);
             });
             checkWMTE(() -> { // reciever primitive class
                 $type$ x = ($type$) hs.get(am, methodType($type$.class, int.class, $type$.class)).
                     invokeExact(0, $value1$);
             });
             // Incorrect return type
-            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // reference class
+            {#if[Class]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // reference class
                 Void r = (Void) hs.get(am, methodType(Void.class, VarHandleTestMethodType$Type$.class, $type$.class)).
                     invokeExact(recv, $value1$);
             });
             checkWMTE(() -> { // primitive class
                 $wrong_primitive_type$ x = ($wrong_primitive_type$) hs.get(am, methodType($wrong_primitive_type$.class, VarHandleTestMethodType$Type$.class, $type$.class)).

@@ -1188,20 +1200,20 @@
             });
             hs.checkWMTEOrCCE(() -> { // receiver reference class
                 $type$ x = ($type$) hs.get(am, methodType($type$.class, Class.class, $type$.class)).
                     invokeExact(Void.class, $value1$);
             });
-            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // value reference class
+            {#if[Class]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // value reference class
                 $type$ x = ($type$) hs.get(am, methodType($type$.class, VarHandleTestMethodType$Type$.class, Class.class)).
                     invokeExact(recv, Void.class);
             });
             checkWMTE(() -> { // reciever primitive class
                 $type$ x = ($type$) hs.get(am, methodType($type$.class, int.class, $type$.class)).
                     invokeExact(0, $value1$);
             });
             // Incorrect return type
-            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // reference class
+            {#if[Class]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // reference class
                 Void r = (Void) hs.get(am, methodType(Void.class, VarHandleTestMethodType$Type$.class, $type$.class)).
                     invokeExact(recv, $value1$);
             });
             checkWMTE(() -> { // primitive class
                 $wrong_primitive_type$ x = ($wrong_primitive_type$) hs.get(am, methodType($wrong_primitive_type$.class, VarHandleTestMethodType$Type$.class, $type$.class)).

@@ -1227,20 +1239,20 @@
             });
             hs.checkWMTEOrCCE(() -> { // receiver reference class
                 $type$ x = ($type$) hs.get(am, methodType($type$.class, Class.class, $type$.class)).
                     invokeExact(Void.class, $value1$);
             });
-            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // value reference class
+            {#if[Class]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // value reference class
                 $type$ x = ($type$) hs.get(am, methodType($type$.class, VarHandleTestMethodType$Type$.class, Class.class)).
                     invokeExact(recv, Void.class);
             });
             checkWMTE(() -> { // reciever primitive class
                 $type$ x = ($type$) hs.get(am, methodType($type$.class, int.class, $type$.class)).
                     invokeExact(0, $value1$);
             });
             // Incorrect return type
-            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // reference class
+            {#if[Class]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // reference class
                 Void r = (Void) hs.get(am, methodType(Void.class, VarHandleTestMethodType$Type$.class, $type$.class)).
                     invokeExact(recv, $value1$);
             });
             checkWMTE(() -> { // primitive class
                 $wrong_primitive_type$ x = ($wrong_primitive_type$) hs.get(am, methodType($wrong_primitive_type$.class, VarHandleTestMethodType$Type$.class, $type$.class)).

@@ -1261,11 +1273,11 @@
 
 
     static void testStaticFieldWrongMethodType(VarHandle vh) throws Throwable {
         // Get
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void x = (Void) vh.get();
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.get();
         });

@@ -1275,11 +1287,11 @@
         });
 
 
         // Set
         // Incorrect argument types
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             vh.set(Void.class);
         });
         // Incorrect arity
         checkWMTE(() -> { // 0
             vh.set();

@@ -1289,11 +1301,11 @@
         });
 
 
         // GetVolatile
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void x = (Void) vh.getVolatile();
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getVolatile();
         });

@@ -1302,11 +1314,11 @@
         });
 
 
         // SetVolatile
         // Incorrect argument types
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             vh.setVolatile(Void.class);
         });
         // Incorrect arity
         checkWMTE(() -> { // 0
             vh.setVolatile();

@@ -1316,11 +1328,11 @@
         });
 
 
         // GetOpaque
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void x = (Void) vh.getOpaque();
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getOpaque();
         });

@@ -1329,11 +1341,11 @@
         });
 
 
         // SetOpaque
         // Incorrect argument types
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             vh.setOpaque(Void.class);
         });
         // Incorrect arity
         checkWMTE(() -> { // 0
             vh.setOpaque();

@@ -1343,11 +1355,11 @@
         });
 
 
         // GetAcquire
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void x = (Void) vh.getAcquire();
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAcquire();
         });

@@ -1356,11 +1368,11 @@
         });
 
 
         // SetRelease
         // Incorrect argument types
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             vh.setRelease(Void.class);
         });
         // Incorrect arity
         checkWMTE(() -> { // 0
             vh.setRelease();

@@ -1371,14 +1383,14 @@
 
 
 #if[CAS]
         // CompareAndSet
         // Incorrect argument types
-        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // expected reference class
             boolean r = vh.compareAndSet(Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // actual reference class
             boolean r = vh.compareAndSet($value1$, Void.class);
         });
         // Incorrect arity
         checkWMTE(() -> { // 0
             boolean r = vh.compareAndSet();

@@ -1388,14 +1400,14 @@
         });
 
 
         // WeakCompareAndSet
         // Incorrect argument types
-        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // expected reference class
             boolean r = vh.weakCompareAndSetPlain(Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // actual reference class
             boolean r = vh.weakCompareAndSetPlain($value1$, Void.class);
         });
         // Incorrect arity
         checkWMTE(() -> { // 0
             boolean r = vh.weakCompareAndSetPlain();

@@ -1405,14 +1417,14 @@
         });
 
 
         // WeakCompareAndSetVolatile
         // Incorrect argument types
-        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // expected reference class
             boolean r = vh.weakCompareAndSet(Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // actual reference class
             boolean r = vh.weakCompareAndSet($value1$, Void.class);
         });
         // Incorrect arity
         checkWMTE(() -> { // 0
             boolean r = vh.weakCompareAndSet();

@@ -1422,14 +1434,14 @@
         });
 
 
         // WeakCompareAndSetAcquire
         // Incorrect argument types
-        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // expected reference class
             boolean r = vh.weakCompareAndSetAcquire(Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // actual reference class
             boolean r = vh.weakCompareAndSetAcquire($value1$, Void.class);
         });
         // Incorrect arity
         checkWMTE(() -> { // 0
             boolean r = vh.weakCompareAndSetAcquire();

@@ -1439,14 +1451,14 @@
         });
 
 
         // WeakCompareAndSetRelease
         // Incorrect argument types
-        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // expected reference class
             boolean r = vh.weakCompareAndSetRelease(Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // actual reference class
             boolean r = vh.weakCompareAndSetRelease($value1$, Void.class);
         });
         // Incorrect arity
         checkWMTE(() -> { // 0
             boolean r = vh.weakCompareAndSetRelease();

@@ -1456,18 +1468,18 @@
         });
 
 
         // CompareAndExchange
         // Incorrect argument types
-        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // expected reference class
             $type$ x = ($type$) vh.compareAndExchange(Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // actual reference class
             $type$ x = ($type$) vh.compareAndExchange($value1$, Void.class);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.compareAndExchange($value1$, $value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.compareAndExchange($value1$, $value1$);
         });

@@ -1480,18 +1492,18 @@
         });
 
 
         // CompareAndExchangeAcquire
         // Incorrect argument types
-        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // expected reference class
             $type$ x = ($type$) vh.compareAndExchangeAcquire(Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // actual reference class
             $type$ x = ($type$) vh.compareAndExchangeAcquire($value1$, Void.class);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.compareAndExchangeAcquire($value1$, $value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.compareAndExchangeAcquire($value1$, $value1$);
         });

@@ -1504,18 +1516,18 @@
         });
 
 
         // CompareAndExchangeRelease
         // Incorrect argument types
-        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // expected reference class
             $type$ x = ($type$) vh.compareAndExchangeRelease(Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // actual reference class
             $type$ x = ($type$) vh.compareAndExchangeRelease($value1$, Void.class);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.compareAndExchangeRelease($value1$, $value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.compareAndExchangeRelease($value1$, $value1$);
         });

@@ -1528,15 +1540,15 @@
         });
 
 
         // GetAndSet
         // Incorrect argument types
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndSet(Void.class);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndSet($value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndSet($value1$);
         });

@@ -1549,15 +1561,15 @@
         });
 
 
         // GetAndSetAcquire
         // Incorrect argument types
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndSetAcquire(Void.class);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndSetAcquire($value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndSetAcquire($value1$);
         });

@@ -1570,15 +1582,15 @@
         });
 
 
         // GetAndSetRelease
         // Incorrect argument types
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndSetRelease(Void.class);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndSetRelease($value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndSetRelease($value1$);
         });

@@ -1592,15 +1604,15 @@
 #end[CAS]
 
 #if[AtomicAdd]
         // GetAndAdd
         // Incorrect argument types
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndAdd(Void.class);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndAdd($value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndAdd($value1$);
         });

@@ -1613,15 +1625,15 @@
         });
 
 
         // GetAndAddAcquire
         // Incorrect argument types
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndAddAcquire(Void.class);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndAddAcquire($value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndAddAcquire($value1$);
         });

@@ -1634,15 +1646,15 @@
         });
 
 
         // GetAndAddRelease
         // Incorrect argument types
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndAddRelease(Void.class);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndAddRelease($value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndAddRelease($value1$);
         });

@@ -1656,15 +1668,15 @@
 #end[AtomicAdd]
 
 #if[Bitwise]
         // GetAndBitwiseOr
         // Incorrect argument types
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndBitwiseOr(Void.class);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndBitwiseOr($value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseOr($value1$);
         });

@@ -1677,15 +1689,15 @@
         });
 
 
         // GetAndBitwiseOrAcquire
         // Incorrect argument types
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndBitwiseOrAcquire(Void.class);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndBitwiseOrAcquire($value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseOrAcquire($value1$);
         });

@@ -1698,15 +1710,15 @@
         });
 
 
         // GetAndBitwiseOrReleaseRelease
         // Incorrect argument types
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndBitwiseOrRelease(Void.class);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndBitwiseOrRelease($value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseOrRelease($value1$);
         });

@@ -1719,15 +1731,15 @@
         });
 
 
         // GetAndBitwiseAnd
         // Incorrect argument types
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndBitwiseAnd(Void.class);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndBitwiseAnd($value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseAnd($value1$);
         });

@@ -1740,15 +1752,15 @@
         });
 
 
         // GetAndBitwiseAndAcquire
         // Incorrect argument types
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndBitwiseAndAcquire(Void.class);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndBitwiseAndAcquire($value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseAndAcquire($value1$);
         });

@@ -1761,15 +1773,15 @@
         });
 
 
         // GetAndBitwiseAndReleaseRelease
         // Incorrect argument types
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndBitwiseAndRelease(Void.class);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndBitwiseAndRelease($value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseAndRelease($value1$);
         });

@@ -1782,15 +1794,15 @@
         });
 
 
         // GetAndBitwiseXor
         // Incorrect argument types
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndBitwiseXor(Void.class);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndBitwiseXor($value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseXor($value1$);
         });

@@ -1803,15 +1815,15 @@
         });
 
 
         // GetAndBitwiseXorAcquire
         // Incorrect argument types
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndBitwiseXorAcquire(Void.class);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndBitwiseXorAcquire($value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseXorAcquire($value1$);
         });

@@ -1824,15 +1836,15 @@
         });
 
 
         // GetAndBitwiseXorReleaseRelease
         // Incorrect argument types
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndBitwiseXorRelease(Void.class);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndBitwiseXorRelease($value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseXorRelease($value1$);
         });

@@ -1849,11 +1861,11 @@
     static void testStaticFieldWrongMethodType(Handles hs) throws Throwable {
         int i = 0;
 
         for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET)) {
             // Incorrect return type
-            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // reference class
+            {#if[Class]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // reference class
                 Void x = (Void) hs.get(am, methodType(Void.class)).
                     invokeExact();
             });
             checkWMTE(() -> { // primitive class
                 $wrong_primitive_type$ x = ($wrong_primitive_type$) hs.get(am, methodType($wrong_primitive_type$.class)).

@@ -1865,11 +1877,11 @@
                     invokeExact(Void.class);
             });
         }
 
         for (TestAccessMode am : testAccessModesOfType(TestAccessType.SET)) {
-            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // value reference class
+            {#if[Class]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // value reference class
                 hs.get(am, methodType(void.class, Class.class)).
                     invokeExact(Void.class);
             });
             // Incorrect arity
             checkWMTE(() -> { // 0

@@ -1882,15 +1894,15 @@
             });
         }
 #if[CAS]
         for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_SET)) {
             // Incorrect argument types
-            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // expected reference class
+            {#if[Class]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // expected reference class
                 boolean r = (boolean) hs.get(am, methodType(boolean.class, Class.class, $type$.class)).
                     invokeExact(Void.class, $value1$);
             });
-            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // actual reference class
+            {#if[Class]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // actual reference class
                 boolean r = (boolean) hs.get(am, methodType(boolean.class, $type$.class, Class.class)).
                     invokeExact($value1$, Void.class);
             });
             // Incorrect arity
             checkWMTE(() -> { // 0

@@ -1903,20 +1915,20 @@
             });
         }
 
         for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_EXCHANGE)) {
             // Incorrect argument types
-            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // expected reference class
+            {#if[Class]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // expected reference class
                 $type$ x = ($type$) hs.get(am, methodType($type$.class, Class.class, $type$.class)).
                     invokeExact(Void.class, $value1$);
             });
-            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // actual reference class
+            {#if[Class]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // actual reference class
                 $type$ x = ($type$) hs.get(am, methodType($type$.class, $type$.class, Class.class)).
                     invokeExact($value1$, Void.class);
             });
             // Incorrect return type
-            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // reference class
+            {#if[Class]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // reference class
                 Void r = (Void) hs.get(am, methodType(Void.class, $type$.class, $type$.class)).
                     invokeExact($value1$, $value1$);
             });
             checkWMTE(() -> { // primitive class
                 $wrong_primitive_type$ x = ($wrong_primitive_type$) hs.get(am, methodType($wrong_primitive_type$.class, $type$.class, $type$.class)).

@@ -1933,16 +1945,16 @@
             });
         }
 
         for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_SET)) {
             // Incorrect argument types
-            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // value reference class
+            {#if[Class]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // value reference class
                 $type$ x = ($type$) hs.get(am, methodType($type$.class, Class.class)).
                     invokeExact(Void.class);
             });
             // Incorrect return type
-            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // reference class
+            {#if[Class]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // reference class
                 Void r = (Void) hs.get(am, methodType(Void.class, $type$.class)).
                     invokeExact($value1$);
             });
             checkWMTE(() -> { // primitive class
                 $wrong_primitive_type$ x = ($wrong_primitive_type$) hs.get(am, methodType($wrong_primitive_type$.class, $type$.class)).

@@ -1961,16 +1973,16 @@
 #end[CAS]
 
 #if[AtomicAdd]
         for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_ADD)) {
             // Incorrect argument types
-            check{#if[String]?CCE:WMTE}(() -> { // value reference class
+            check{#if[Class]?CCE:WMTE}(() -> { // value reference class
                 $type$ x = ($type$) hs.get(am, methodType($type$.class, Class.class)).
                     invokeExact(Void.class);
             });
             // Incorrect return type
-            check{#if[String]?CCE:WMTE}(() -> { // reference class
+            check{#if[Class]?CCE:WMTE}(() -> { // reference class
                 Void r = (Void) hs.get(am, methodType(Void.class, $type$.class)).
                     invokeExact($value1$);
             });
             checkWMTE(() -> { // primitive class
                 $wrong_primitive_type$ x = ($wrong_primitive_type$) hs.get(am, methodType($wrong_primitive_type$.class, $type$.class)).

@@ -1989,16 +2001,16 @@
 #end[AtomicAdd]
 
 #if[Bitwise]
         for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_BITWISE)) {
             // Incorrect argument types
-            check{#if[String]?CCE:WMTE}(() -> { // value reference class
+            check{#if[Class]?CCE:WMTE}(() -> { // value reference class
                 $type$ x = ($type$) hs.get(am, methodType($type$.class, Class.class)).
                     invokeExact(Void.class);
             });
             // Incorrect return type
-            check{#if[String]?CCE:WMTE}(() -> { // reference class
+            check{#if[Class]?CCE:WMTE}(() -> { // reference class
                 Void r = (Void) hs.get(am, methodType(Void.class, $type$.class)).
                     invokeExact($value1$);
             });
             checkWMTE(() -> { // primitive class
                 $wrong_primitive_type$ x = ($wrong_primitive_type$) hs.get(am, methodType($wrong_primitive_type$.class, $type$.class)).

@@ -2035,11 +2047,11 @@
         });
         checkWMTE(() -> { // index reference class
             $type$ x = ($type$) vh.get(array, Void.class);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void x = (Void) vh.get(array, 0);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.get(array, 0);
         });

@@ -2058,11 +2070,11 @@
             vh.set(null, 0, $value1$);
         });
         checkCCE(() -> { // array reference class
             vh.set(Void.class, 0, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             vh.set(array, 0, Void.class);
         });
         checkWMTE(() -> { // receiver primitive class
             vh.set(0, 0, $value1$);
         });

@@ -2091,11 +2103,11 @@
         });
         checkWMTE(() -> { // index reference class
             $type$ x = ($type$) vh.getVolatile(array, Void.class);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void x = (Void) vh.getVolatile(array, 0);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getVolatile(array, 0);
         });

@@ -2114,11 +2126,11 @@
             vh.setVolatile(null, 0, $value1$);
         });
         checkCCE(() -> { // array reference class
             vh.setVolatile(Void.class, 0, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             vh.setVolatile(array, 0, Void.class);
         });
         checkWMTE(() -> { // receiver primitive class
             vh.setVolatile(0, 0, $value1$);
         });

@@ -2147,11 +2159,11 @@
         });
         checkWMTE(() -> { // index reference class
             $type$ x = ($type$) vh.getOpaque(array, Void.class);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void x = (Void) vh.getOpaque(array, 0);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getOpaque(array, 0);
         });

@@ -2170,11 +2182,11 @@
             vh.setOpaque(null, 0, $value1$);
         });
         checkCCE(() -> { // array reference class
             vh.setOpaque(Void.class, 0, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             vh.setOpaque(array, 0, Void.class);
         });
         checkWMTE(() -> { // receiver primitive class
             vh.setOpaque(0, 0, $value1$);
         });

@@ -2203,11 +2215,11 @@
         });
         checkWMTE(() -> { // index reference class
             $type$ x = ($type$) vh.getAcquire(array, Void.class);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void x = (Void) vh.getAcquire(array, 0);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAcquire(array, 0);
         });

@@ -2226,11 +2238,11 @@
             vh.setRelease(null, 0, $value1$);
         });
         checkCCE(() -> { // array reference class
             vh.setRelease(Void.class, 0, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             vh.setRelease(array, 0, Void.class);
         });
         checkWMTE(() -> { // receiver primitive class
             vh.setRelease(0, 0, $value1$);
         });

@@ -2253,14 +2265,14 @@
             boolean r = vh.compareAndSet(null, 0, $value1$, $value1$);
         });
         checkCCE(() -> { // receiver reference class
             boolean r = vh.compareAndSet(Void.class, 0, $value1$, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // expected reference class
             boolean r = vh.compareAndSet(array, 0, Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // actual reference class
             boolean r = vh.compareAndSet(array, 0, $value1$, Void.class);
         });
         checkWMTE(() -> { // receiver primitive class
             boolean r = vh.compareAndSet(0, 0, $value1$, $value1$);
         });

@@ -2282,14 +2294,14 @@
             boolean r = vh.weakCompareAndSetPlain(null, 0, $value1$, $value1$);
         });
         checkCCE(() -> { // receiver reference class
             boolean r = vh.weakCompareAndSetPlain(Void.class, 0, $value1$, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // expected reference class
             boolean r = vh.weakCompareAndSetPlain(array, 0, Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // actual reference class
             boolean r = vh.weakCompareAndSetPlain(array, 0, $value1$, Void.class);
         });
         checkWMTE(() -> { // receiver primitive class
             boolean r = vh.weakCompareAndSetPlain(0, 0, $value1$, $value1$);
         });

@@ -2311,14 +2323,14 @@
             boolean r = vh.weakCompareAndSet(null, 0, $value1$, $value1$);
         });
         checkCCE(() -> { // receiver reference class
             boolean r = vh.weakCompareAndSet(Void.class, 0, $value1$, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // expected reference class
             boolean r = vh.weakCompareAndSet(array, 0, Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // actual reference class
             boolean r = vh.weakCompareAndSet(array, 0, $value1$, Void.class);
         });
         checkWMTE(() -> { // receiver primitive class
             boolean r = vh.weakCompareAndSet(0, 0, $value1$, $value1$);
         });

@@ -2340,14 +2352,14 @@
             boolean r = vh.weakCompareAndSetAcquire(null, 0, $value1$, $value1$);
         });
         checkCCE(() -> { // receiver reference class
             boolean r = vh.weakCompareAndSetAcquire(Void.class, 0, $value1$, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // expected reference class
             boolean r = vh.weakCompareAndSetAcquire(array, 0, Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // actual reference class
             boolean r = vh.weakCompareAndSetAcquire(array, 0, $value1$, Void.class);
         });
         checkWMTE(() -> { // receiver primitive class
             boolean r = vh.weakCompareAndSetAcquire(0, 0, $value1$, $value1$);
         });

@@ -2369,14 +2381,14 @@
             boolean r = vh.weakCompareAndSetRelease(null, 0, $value1$, $value1$);
         });
         checkCCE(() -> { // receiver reference class
             boolean r = vh.weakCompareAndSetRelease(Void.class, 0, $value1$, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // expected reference class
             boolean r = vh.weakCompareAndSetRelease(array, 0, Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // actual reference class
             boolean r = vh.weakCompareAndSetRelease(array, 0, $value1$, Void.class);
         });
         checkWMTE(() -> { // receiver primitive class
             boolean r = vh.weakCompareAndSetRelease(0, 0, $value1$, $value1$);
         });

@@ -2398,24 +2410,24 @@
             $type$ x = ($type$) vh.compareAndExchange(null, 0, $value1$, $value1$);
         });
         checkCCE(() -> { // array reference class
             $type$ x = ($type$) vh.compareAndExchange(Void.class, 0, $value1$, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // expected reference class
             $type$ x = ($type$) vh.compareAndExchange(array, 0, Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // actual reference class
             $type$ x = ($type$) vh.compareAndExchange(array, 0, $value1$, Void.class);
         });
         checkWMTE(() -> { // array primitive class
             $type$ x = ($type$) vh.compareAndExchange(0, 0, $value1$, $value1$);
         });
         checkWMTE(() -> { // index reference class
             $type$ x = ($type$) vh.compareAndExchange(array, Void.class, $value1$, $value1$);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.compareAndExchange(array, 0, $value1$, $value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.compareAndExchange(array, 0, $value1$, $value1$);
         });

@@ -2434,24 +2446,24 @@
             $type$ x = ($type$) vh.compareAndExchangeAcquire(null, 0, $value1$, $value1$);
         });
         checkCCE(() -> { // array reference class
             $type$ x = ($type$) vh.compareAndExchangeAcquire(Void.class, 0, $value1$, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // expected reference class
             $type$ x = ($type$) vh.compareAndExchangeAcquire(array, 0, Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // actual reference class
             $type$ x = ($type$) vh.compareAndExchangeAcquire(array, 0, $value1$, Void.class);
         });
         checkWMTE(() -> { // array primitive class
             $type$ x = ($type$) vh.compareAndExchangeAcquire(0, 0, $value1$, $value1$);
         });
         checkWMTE(() -> { // index reference class
             $type$ x = ($type$) vh.compareAndExchangeAcquire(array, Void.class, $value1$, $value1$);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.compareAndExchangeAcquire(array, 0, $value1$, $value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.compareAndExchangeAcquire(array, 0, $value1$, $value1$);
         });

@@ -2470,24 +2482,24 @@
             $type$ x = ($type$) vh.compareAndExchangeRelease(null, 0, $value1$, $value1$);
         });
         checkCCE(() -> { // array reference class
             $type$ x = ($type$) vh.compareAndExchangeRelease(Void.class, 0, $value1$, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // expected reference class
             $type$ x = ($type$) vh.compareAndExchangeRelease(array, 0, Void.class, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // actual reference class
             $type$ x = ($type$) vh.compareAndExchangeRelease(array, 0, $value1$, Void.class);
         });
         checkWMTE(() -> { // array primitive class
             $type$ x = ($type$) vh.compareAndExchangeRelease(0, 0, $value1$, $value1$);
         });
         checkWMTE(() -> { // index reference class
             $type$ x = ($type$) vh.compareAndExchangeRelease(array, Void.class, $value1$, $value1$);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.compareAndExchangeRelease(array, 0, $value1$, $value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.compareAndExchangeRelease(array, 0, $value1$, $value1$);
         });

@@ -2506,21 +2518,21 @@
             $type$ x = ($type$) vh.getAndSet(null, 0, $value1$);
         });
         checkCCE(() -> { // array reference class
             $type$ x = ($type$) vh.getAndSet(Void.class, 0, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndSet(array, 0, Void.class);
         });
         checkWMTE(() -> { // reciarrayever primitive class
             $type$ x = ($type$) vh.getAndSet(0, 0, $value1$);
         });
         checkWMTE(() -> { // index reference class
             $type$ x = ($type$) vh.getAndSet(array, Void.class, $value1$);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndSet(array, 0, $value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndSet(array, 0, $value1$);
         });

@@ -2539,21 +2551,21 @@
             $type$ x = ($type$) vh.getAndSetAcquire(null, 0, $value1$);
         });
         checkCCE(() -> { // array reference class
             $type$ x = ($type$) vh.getAndSetAcquire(Void.class, 0, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndSetAcquire(array, 0, Void.class);
         });
         checkWMTE(() -> { // reciarrayever primitive class
             $type$ x = ($type$) vh.getAndSetAcquire(0, 0, $value1$);
         });
         checkWMTE(() -> { // index reference class
             $type$ x = ($type$) vh.getAndSetAcquire(array, Void.class, $value1$);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndSetAcquire(array, 0, $value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndSetAcquire(array, 0, $value1$);
         });

@@ -2572,21 +2584,21 @@
             $type$ x = ($type$) vh.getAndSetRelease(null, 0, $value1$);
         });
         checkCCE(() -> { // array reference class
             $type$ x = ($type$) vh.getAndSetRelease(Void.class, 0, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndSetRelease(array, 0, Void.class);
         });
         checkWMTE(() -> { // reciarrayever primitive class
             $type$ x = ($type$) vh.getAndSetRelease(0, 0, $value1$);
         });
         checkWMTE(() -> { // index reference class
             $type$ x = ($type$) vh.getAndSetRelease(array, Void.class, $value1$);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndSetRelease(array, 0, $value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndSetRelease(array, 0, $value1$);
         });

@@ -2606,21 +2618,21 @@
             $type$ x = ($type$) vh.getAndAdd(null, 0, $value1$);
         });
         checkCCE(() -> { // array reference class
             $type$ x = ($type$) vh.getAndAdd(Void.class, 0, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndAdd(array, 0, Void.class);
         });
         checkWMTE(() -> { // array primitive class
             $type$ x = ($type$) vh.getAndAdd(0, 0, $value1$);
         });
         checkWMTE(() -> { // index reference class
             $type$ x = ($type$) vh.getAndAdd(array, Void.class, $value1$);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndAdd(array, 0, $value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndAdd(array, 0, $value1$);
         });

@@ -2639,21 +2651,21 @@
             $type$ x = ($type$) vh.getAndAddAcquire(null, 0, $value1$);
         });
         checkCCE(() -> { // array reference class
             $type$ x = ($type$) vh.getAndAddAcquire(Void.class, 0, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndAddAcquire(array, 0, Void.class);
         });
         checkWMTE(() -> { // array primitive class
             $type$ x = ($type$) vh.getAndAddAcquire(0, 0, $value1$);
         });
         checkWMTE(() -> { // index reference class
             $type$ x = ($type$) vh.getAndAddAcquire(array, Void.class, $value1$);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndAddAcquire(array, 0, $value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndAddAcquire(array, 0, $value1$);
         });

@@ -2672,21 +2684,21 @@
             $type$ x = ($type$) vh.getAndAddRelease(null, 0, $value1$);
         });
         checkCCE(() -> { // array reference class
             $type$ x = ($type$) vh.getAndAddRelease(Void.class, 0, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndAddRelease(array, 0, Void.class);
         });
         checkWMTE(() -> { // array primitive class
             $type$ x = ($type$) vh.getAndAddRelease(0, 0, $value1$);
         });
         checkWMTE(() -> { // index reference class
             $type$ x = ($type$) vh.getAndAddRelease(array, Void.class, $value1$);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndAddRelease(array, 0, $value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndAddRelease(array, 0, $value1$);
         });

@@ -2706,21 +2718,21 @@
             $type$ x = ($type$) vh.getAndBitwiseOr(null, 0, $value1$);
         });
         checkCCE(() -> { // array reference class
             $type$ x = ($type$) vh.getAndBitwiseOr(Void.class, 0, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndBitwiseOr(array, 0, Void.class);
         });
         checkWMTE(() -> { // array primitive class
             $type$ x = ($type$) vh.getAndBitwiseOr(0, 0, $value1$);
         });
         checkWMTE(() -> { // index reference class
             $type$ x = ($type$) vh.getAndBitwiseOr(array, Void.class, $value1$);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndBitwiseOr(array, 0, $value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseOr(array, 0, $value1$);
         });

@@ -2739,21 +2751,21 @@
             $type$ x = ($type$) vh.getAndBitwiseOrAcquire(null, 0, $value1$);
         });
         checkCCE(() -> { // array reference class
             $type$ x = ($type$) vh.getAndBitwiseOrAcquire(Void.class, 0, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndBitwiseOrAcquire(array, 0, Void.class);
         });
         checkWMTE(() -> { // array primitive class
             $type$ x = ($type$) vh.getAndBitwiseOrAcquire(0, 0, $value1$);
         });
         checkWMTE(() -> { // index reference class
             $type$ x = ($type$) vh.getAndBitwiseOrAcquire(array, Void.class, $value1$);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndBitwiseOrAcquire(array, 0, $value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseOrAcquire(array, 0, $value1$);
         });

@@ -2772,21 +2784,21 @@
             $type$ x = ($type$) vh.getAndBitwiseOrRelease(null, 0, $value1$);
         });
         checkCCE(() -> { // array reference class
             $type$ x = ($type$) vh.getAndBitwiseOrRelease(Void.class, 0, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndBitwiseOrRelease(array, 0, Void.class);
         });
         checkWMTE(() -> { // array primitive class
             $type$ x = ($type$) vh.getAndBitwiseOrRelease(0, 0, $value1$);
         });
         checkWMTE(() -> { // index reference class
             $type$ x = ($type$) vh.getAndBitwiseOrRelease(array, Void.class, $value1$);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndBitwiseOrRelease(array, 0, $value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseOrRelease(array, 0, $value1$);
         });

@@ -2805,21 +2817,21 @@
             $type$ x = ($type$) vh.getAndBitwiseAnd(null, 0, $value1$);
         });
         checkCCE(() -> { // array reference class
             $type$ x = ($type$) vh.getAndBitwiseAnd(Void.class, 0, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndBitwiseAnd(array, 0, Void.class);
         });
         checkWMTE(() -> { // array primitive class
             $type$ x = ($type$) vh.getAndBitwiseAnd(0, 0, $value1$);
         });
         checkWMTE(() -> { // index reference class
             $type$ x = ($type$) vh.getAndBitwiseAnd(array, Void.class, $value1$);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndBitwiseAnd(array, 0, $value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseAnd(array, 0, $value1$);
         });

@@ -2838,21 +2850,21 @@
             $type$ x = ($type$) vh.getAndBitwiseAndAcquire(null, 0, $value1$);
         });
         checkCCE(() -> { // array reference class
             $type$ x = ($type$) vh.getAndBitwiseAndAcquire(Void.class, 0, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndBitwiseAndAcquire(array, 0, Void.class);
         });
         checkWMTE(() -> { // array primitive class
             $type$ x = ($type$) vh.getAndBitwiseAndAcquire(0, 0, $value1$);
         });
         checkWMTE(() -> { // index reference class
             $type$ x = ($type$) vh.getAndBitwiseAndAcquire(array, Void.class, $value1$);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndBitwiseAndAcquire(array, 0, $value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseAndAcquire(array, 0, $value1$);
         });

@@ -2871,21 +2883,21 @@
             $type$ x = ($type$) vh.getAndBitwiseAndRelease(null, 0, $value1$);
         });
         checkCCE(() -> { // array reference class
             $type$ x = ($type$) vh.getAndBitwiseAndRelease(Void.class, 0, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndBitwiseAndRelease(array, 0, Void.class);
         });
         checkWMTE(() -> { // array primitive class
             $type$ x = ($type$) vh.getAndBitwiseAndRelease(0, 0, $value1$);
         });
         checkWMTE(() -> { // index reference class
             $type$ x = ($type$) vh.getAndBitwiseAndRelease(array, Void.class, $value1$);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndBitwiseAndRelease(array, 0, $value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseAndRelease(array, 0, $value1$);
         });

@@ -2904,21 +2916,21 @@
             $type$ x = ($type$) vh.getAndBitwiseXor(null, 0, $value1$);
         });
         checkCCE(() -> { // array reference class
             $type$ x = ($type$) vh.getAndBitwiseXor(Void.class, 0, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndBitwiseXor(array, 0, Void.class);
         });
         checkWMTE(() -> { // array primitive class
             $type$ x = ($type$) vh.getAndBitwiseXor(0, 0, $value1$);
         });
         checkWMTE(() -> { // index reference class
             $type$ x = ($type$) vh.getAndBitwiseXor(array, Void.class, $value1$);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndBitwiseXor(array, 0, $value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseXor(array, 0, $value1$);
         });

@@ -2937,21 +2949,21 @@
             $type$ x = ($type$) vh.getAndBitwiseXorAcquire(null, 0, $value1$);
         });
         checkCCE(() -> { // array reference class
             $type$ x = ($type$) vh.getAndBitwiseXorAcquire(Void.class, 0, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndBitwiseXorAcquire(array, 0, Void.class);
         });
         checkWMTE(() -> { // array primitive class
             $type$ x = ($type$) vh.getAndBitwiseXorAcquire(0, 0, $value1$);
         });
         checkWMTE(() -> { // index reference class
             $type$ x = ($type$) vh.getAndBitwiseXorAcquire(array, Void.class, $value1$);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndBitwiseXorAcquire(array, 0, $value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseXorAcquire(array, 0, $value1$);
         });

@@ -2970,21 +2982,21 @@
             $type$ x = ($type$) vh.getAndBitwiseXorRelease(null, 0, $value1$);
         });
         checkCCE(() -> { // array reference class
             $type$ x = ($type$) vh.getAndBitwiseXorRelease(Void.class, 0, $value1$);
         });
-        check{#if[String]?CCE:WMTE}(() -> { // value reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // value reference class
             $type$ x = ($type$) vh.getAndBitwiseXorRelease(array, 0, Void.class);
         });
         checkWMTE(() -> { // array primitive class
             $type$ x = ($type$) vh.getAndBitwiseXorRelease(0, 0, $value1$);
         });
         checkWMTE(() -> { // index reference class
             $type$ x = ($type$) vh.getAndBitwiseXorRelease(array, Void.class, $value1$);
         });
         // Incorrect return type
-        check{#if[String]?CCE:WMTE}(() -> { // reference class
+        check{#if[Class]?CCE:WMTE}(() -> { // reference class
             Void r = (Void) vh.getAndBitwiseXorRelease(array, 0, $value1$);
         });
         checkWMTE(() -> { // primitive class
             $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseXorRelease(array, 0, $value1$);
         });

@@ -3019,11 +3031,11 @@
             checkWMTE(() -> { // index reference class
                 $type$ x = ($type$) hs.get(am, methodType($type$.class, $type$[].class, Class.class)).
                     invokeExact(array, Void.class);
             });
             // Incorrect return type
-            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // reference class
+            {#if[Class]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // reference class
                 Void x = (Void) hs.get(am, methodType(Void.class, $type$[].class, int.class)).
                     invokeExact(array, 0);
             });
             checkWMTE(() -> { // primitive class
                 $wrong_primitive_type$ x = ($wrong_primitive_type$) hs.get(am, methodType($wrong_primitive_type$.class, $type$[].class, int.class)).

@@ -3048,11 +3060,11 @@
             });
             hs.checkWMTEOrCCE(() -> { // array reference class
                 hs.get(am, methodType(void.class, Class.class, int.class, $type$.class)).
                     invokeExact(Void.class, 0, $value1$);
             });
-            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // value reference class
+            {#if[Class]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // value reference class
                 hs.get(am, methodType(void.class, $type$[].class, int.class, Class.class)).
                     invokeExact(array, 0, Void.class);
             });
             checkWMTE(() -> { // receiver primitive class
                 hs.get(am, methodType(void.class, int.class, int.class, $type$.class)).

@@ -3081,15 +3093,15 @@
             });
             hs.checkWMTEOrCCE(() -> { // receiver reference class
                 boolean r = (boolean) hs.get(am, methodType(boolean.class, Class.class, int.class, $type$.class, $type$.class)).
                     invokeExact(Void.class, 0, $value1$, $value1$);
             });
-            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // expected reference class
+            {#if[Class]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // expected reference class
                 boolean r = (boolean) hs.get(am, methodType(boolean.class, $type$[].class, int.class, Class.class, $type$.class)).
                     invokeExact(array, 0, Void.class, $value1$);
             });
-            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // actual reference class
+            {#if[Class]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // actual reference class
                 boolean r = (boolean) hs.get(am, methodType(boolean.class, $type$[].class, int.class, $type$.class, Class.class)).
                     invokeExact(array, 0, $value1$, Void.class);
             });
             checkWMTE(() -> { // receiver primitive class
                 boolean r = (boolean) hs.get(am, methodType(boolean.class, int.class, int.class, $type$.class, $type$.class)).

@@ -3118,15 +3130,15 @@
             });
             hs.checkWMTEOrCCE(() -> { // array reference class
                 $type$ x = ($type$) hs.get(am, methodType($type$.class, Class.class, int.class, $type$.class, $type$.class)).
                     invokeExact(Void.class, 0, $value1$, $value1$);
             });
-            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // expected reference class
+            {#if[Class]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // expected reference class
                 $type$ x = ($type$) hs.get(am, methodType($type$.class, $type$[].class, int.class, Class.class, $type$.class)).
                     invokeExact(array, 0, Void.class, $value1$);
             });
-            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // actual reference class
+            {#if[Class]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // actual reference class
                 $type$ x = ($type$) hs.get(am, methodType($type$.class, $type$[].class, int.class, $type$.class, Class.class)).
                     invokeExact(array, 0, $value1$, Void.class);
             });
             checkWMTE(() -> { // array primitive class
                 $type$ x = ($type$) hs.get(am, methodType($type$.class, int.class, int.class, $type$.class, $type$.class)).

@@ -3135,11 +3147,11 @@
             checkWMTE(() -> { // index reference class
                 $type$ x = ($type$) hs.get(am, methodType($type$.class, $type$[].class, Class.class, $type$.class, $type$.class)).
                     invokeExact(array, Void.class, $value1$, $value1$);
             });
             // Incorrect return type
-            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // reference class
+            {#if[Class]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // reference class
                 Void r = (Void) hs.get(am, methodType(Void.class, $type$[].class, int.class, $type$.class, $type$.class)).
                     invokeExact(array, 0, $value1$, $value1$);
             });
             checkWMTE(() -> { // primitive class
                 $wrong_primitive_type$ x = ($wrong_primitive_type$) hs.get(am, methodType($wrong_primitive_type$.class, $type$[].class, int.class, $type$.class, $type$.class)).

@@ -3164,11 +3176,11 @@
             });
             hs.checkWMTEOrCCE(() -> { // array reference class
                 $type$ x = ($type$) hs.get(am, methodType($type$.class, Class.class, int.class, $type$.class)).
                     invokeExact(Void.class, 0, $value1$);
             });
-            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // value reference class
+            {#if[Class]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // value reference class
                 $type$ x = ($type$) hs.get(am, methodType($type$.class, $type$[].class, int.class, Class.class)).
                     invokeExact(array, 0, Void.class);
             });
             checkWMTE(() -> { // array primitive class
                 $type$ x = ($type$) hs.get(am, methodType($type$.class, int.class, int.class, $type$.class)).

@@ -3177,11 +3189,11 @@
             checkWMTE(() -> { // index reference class
                 $type$ x = ($type$) hs.get(am, methodType($type$.class, $type$[].class, Class.class, $type$.class)).
                     invokeExact(array, Void.class, $value1$);
             });
             // Incorrect return type
-            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // reference class
+            {#if[Class]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // reference class
                 Void r = (Void) hs.get(am, methodType(Void.class, $type$[].class, int.class, $type$.class)).
                     invokeExact(array, 0, $value1$);
             });
             checkWMTE(() -> { // primitive class
                 $wrong_primitive_type$ x = ($wrong_primitive_type$) hs.get(am, methodType($wrong_primitive_type$.class, $type$[].class, int.class, $type$.class)).

@@ -3208,11 +3220,11 @@
             });
             hs.checkWMTEOrCCE(() -> { // array reference class
                 $type$ x = ($type$) hs.get(am, methodType($type$.class, Class.class, int.class, $type$.class)).
                     invokeExact(Void.class, 0, $value1$);
             });
-            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // value reference class
+            {#if[Class]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // value reference class
                 $type$ x = ($type$) hs.get(am, methodType($type$.class, $type$[].class, int.class, Class.class)).
                     invokeExact(array, 0, Void.class);
             });
             checkWMTE(() -> { // array primitive class
                 $type$ x = ($type$) hs.get(am, methodType($type$.class, int.class, int.class, $type$.class)).

@@ -3221,11 +3233,11 @@
             checkWMTE(() -> { // index reference class
                 $type$ x = ($type$) hs.get(am, methodType($type$.class, $type$[].class, Class.class, $type$.class)).
                     invokeExact(array, Void.class, $value1$);
             });
             // Incorrect return type
-            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // reference class
+            {#if[Class]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // reference class
                 Void r = (Void) hs.get(am, methodType(Void.class, $type$[].class, int.class, $type$.class)).
                     invokeExact(array, 0, $value1$);
             });
             checkWMTE(() -> { // primitive class
                 $wrong_primitive_type$ x = ($wrong_primitive_type$) hs.get(am, methodType($wrong_primitive_type$.class, $type$[].class, int.class, $type$.class)).

@@ -3252,11 +3264,11 @@
             });
             hs.checkWMTEOrCCE(() -> { // array reference class
                 $type$ x = ($type$) hs.get(am, methodType($type$.class, Class.class, int.class, $type$.class)).
                     invokeExact(Void.class, 0, $value1$);
             });
-            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // value reference class
+            {#if[Class]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // value reference class
                 $type$ x = ($type$) hs.get(am, methodType($type$.class, $type$[].class, int.class, Class.class)).
                     invokeExact(array, 0, Void.class);
             });
             checkWMTE(() -> { // array primitive class
                 $type$ x = ($type$) hs.get(am, methodType($type$.class, int.class, int.class, $type$.class)).

@@ -3265,11 +3277,11 @@
             checkWMTE(() -> { // index reference class
                 $type$ x = ($type$) hs.get(am, methodType($type$.class, $type$[].class, Class.class, $type$.class)).
                     invokeExact(array, Void.class, $value1$);
             });
             // Incorrect return type
-            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // reference class
+            {#if[Class]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // reference class
                 Void r = (Void) hs.get(am, methodType(Void.class, $type$[].class, int.class, $type$.class)).
                     invokeExact(array, 0, $value1$);
             });
             checkWMTE(() -> { // primitive class
                 $wrong_primitive_type$ x = ($wrong_primitive_type$) hs.get(am, methodType($wrong_primitive_type$.class, $type$[].class, int.class, $type$.class)).
< prev index next >