jdk/src/java.base/share/classes/java/lang/invoke/MethodHandleImpl.java

*** 23,33 ****
   * questions.
   */
  
  package java.lang.invoke;
  
- import jdk.experimental.value.ValueType;
  import jdk.internal.misc.JavaLangInvokeAccess;
  import jdk.internal.misc.SharedSecrets;
  import jdk.internal.org.objectweb.asm.AnnotationVisitor;
  import jdk.internal.org.objectweb.asm.ClassWriter;
  import jdk.internal.org.objectweb.asm.MethodVisitor;
--- 23,32 ----
*** 38,47 ****
--- 37,47 ----
  import sun.invoke.empty.Empty;
  import sun.invoke.util.ValueConversions;
  import sun.invoke.util.VerifyType;
  import sun.invoke.util.Wrapper;
  import valhalla.shady.MinimalValueTypes_1_0;
+ import valhalla.shady.ValueTypeHolder;
  
  import java.lang.reflect.Array;
  import java.util.Arrays;
  import java.util.Collections;
  import java.util.Iterator;
*** 432,443 ****
       */
      static Object valueConversion(Class<?> src, Class<?> dst, boolean strict, boolean monobox) {
          assert(!VerifyType.isNullConversion(src, dst, /*keepInterfaces=*/ strict));  // caller responsibility
          if (dst == void.class)
              return dst;
!         ValueType<?> srcVT = getValueFor(src);
!         ValueType<?> dstVT = getValueFor(dst);
          MethodHandle fn;
          if (src.isPrimitive()) {
              if (src == void.class) {
                  return void.class;  // caller must recognize this specially
              } else if (dst.isPrimitive()) {
--- 432,443 ----
       */
      static Object valueConversion(Class<?> src, Class<?> dst, boolean strict, boolean monobox) {
          assert(!VerifyType.isNullConversion(src, dst, /*keepInterfaces=*/ strict));  // caller responsibility
          if (dst == void.class)
              return dst;
!         ValueTypeHolder<?> srcVT = MinimalValueTypes_1_0.findValueType(src);
!         ValueTypeHolder<?> dstVT = MinimalValueTypes_1_0.findValueType(dst);
          MethodHandle fn;
          if (src.isPrimitive()) {
              if (src == void.class) {
                  return void.class;  // caller must recognize this specially
              } else if (dst.isPrimitive()) {
*** 494,516 ****
          }
          assert(fn.type().parameterCount() <= 1) : "pc"+Arrays.asList(src.getSimpleName(), dst.getSimpleName(), fn);
          return fn;
      }
  
-     @SuppressWarnings("unchecked")
-     static <Z> ValueType<Z> getValueFor(Class<Z> c) {
-         try {
-             if (MinimalValueTypes_1_0.isValueType(c)) {
-                 return (ValueType<Z>)ValueType.forClass(MinimalValueTypes_1_0.getValueCapableClass(c));
-             } else {
-                 return null;
-             }
-         } catch (Throwable ex) {
-             return null;
-         }
-     }
- 
      static MethodHandle makeVarargsCollector(MethodHandle target, Class<?> arrayType) {
          MethodType type = target.type();
          int last = type.parameterCount() - 1;
          if (type.parameterType(last) != arrayType)
              target = target.asType(type.changeParameterType(last, arrayType));
--- 494,503 ----
*** 1819,1829 ****
              } else {
                  Wrapper w = Wrapper.forPrimitiveType(returnType);
                  return ValueConversions.unboxExact(w);
              }
          } else if (MinimalValueTypes_1_0.isValueType(returnType)) {
!             return ValueType.forClass(MinimalValueTypes_1_0.getValueCapableClass(returnType)).unbox();
          } else {
              return MethodHandles.identity(Object.class);
          }
      }
  
--- 1806,1816 ----
              } else {
                  Wrapper w = Wrapper.forPrimitiveType(returnType);
                  return ValueConversions.unboxExact(w);
              }
          } else if (MinimalValueTypes_1_0.isValueType(returnType)) {
!             return MinimalValueTypes_1_0.findValueType(returnType).unbox();
          } else {
              return MethodHandles.identity(Object.class);
          }
      }