jdk-sandbox: comparison jdk/src/share/classes/sun/dyn/util/ValueConversions.java

equal deleted inserted replaced

-:2173b8120b13
+:2836ee97ee27
 * questions.
 */
 package sun.dyn.util;
-import java.dyn.*;
+import java.dyn.MethodHandle;
+import java.dyn.MethodHandles;
 import java.dyn.MethodHandles.Lookup;
+import java.dyn.MethodType;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.EnumMap;
 import java.util.List;
-import sun.dyn.Access;
-import sun.dyn.AdapterMethodHandle;
-import sun.dyn.MethodHandleImpl;
-import static sun.dyn.MemberName.uncaughtException;
 public class ValueConversions {
-private static final Access IMPL_TOKEN = Access.getToken();
+private static final Lookup IMPL_LOOKUP = MethodHandles.lookup();
-private static final Lookup IMPL_LOOKUP = MethodHandleImpl.getLookup(IMPL_TOKEN);
 private static EnumMap<Wrapper, MethodHandle>[] newWrapperCaches(int n) {
 @SuppressWarnings("unchecked")
 EnumMap<Wrapper, MethodHandle>[] caches
 = (EnumMap<Wrapper, MethodHandle>[]) new EnumMap[n];  // unchecked warning expected here
 mh = IMPL_LOOKUP.findStatic(ValueConversions.class, name, type.erase());
 } catch (ReflectiveOperationException ex) {
 mh = null;
 }
 } else {
-mh = retype(type, unbox(wrap, !exact, raw));
+mh = unbox(wrap, !exact, raw).asType(type);
 }
 if (mh != null) {
 cache.put(wrap, mh);
 return mh;
 }
 mh = IMPL_LOOKUP.findStatic(ValueConversions.class, name, type);
 } catch (ReflectiveOperationException ex) {
 mh = null;
 }
 } else {
-mh = retype(type.erase(), box(wrap, !exact, raw));
+mh = box(wrap, !exact, raw).asType(type.erase());
 }
 if (mh != null) {
 cache.put(wrap, mh);
 return mh;
 }
 mh = IMPL_LOOKUP.findStatic(ValueConversions.class, name, type);
 } catch (ReflectiveOperationException ex) {
 mh = null;
 }
 } else {
-mh = retype(IDENTITY.type(), rebox(wrap, !exact));
+mh = rebox(wrap, !exact).asType(IDENTITY.type());
 }
 if (mh != null) {
 cache.put(wrap, mh);
 return mh;
 }
 return mh;
 }
 // use the raw method
 Wrapper rawWrap = wrap.rawPrimitive();
-if (rawWrap != wrap) {
+if (mh == null && rawWrap != wrap) {
-mh = retype(type, zeroConstantFunction(rawWrap));
+mh = MethodHandles.explicitCastArguments(zeroConstantFunction(rawWrap), type);
 }
 if (mh != null) {
 cache.put(wrap, mh);
 return mh;
 }
 */
 static int identity(int x) {
 return x;
 }
+static byte identity(byte x) {
+return x;
+}
+static short identity(short x) {
+return x;
+}
+static boolean identity(boolean x) {
+return x;
+}
+static char identity(char x) {
+return x;
+}
 /**
 * Identity function on longs.
 * @param x an arbitrary long value
 * @return the same value x
 */
 static long identity(long x) {
+return x;
+}
+static float identity(float x) {
+return x;
+}
+static double identity(double x) {
 return x;
 }
 /**
 * Identity function, with reference cast.
 ALWAYS_ZERO = IMPL_LOOKUP.findStatic(ValueConversions.class, "alwaysZero", alwaysZeroType);
 ZERO_OBJECT = IMPL_LOOKUP.findStatic(ValueConversions.class, "zeroObject", zeroObjectType);
 IGNORE = IMPL_LOOKUP.findStatic(ValueConversions.class, "ignore", ignoreType);
 EMPTY = IMPL_LOOKUP.findStatic(ValueConversions.class, "empty", ignoreType.dropParameterTypes(0, 1));
 } catch (Exception ex) {
-throw uncaughtException(ex);
+Error err = new InternalError("uncaught exception");
+err.initCause(ex);
+throw err;
 }
 }
 private static final EnumMap<Wrapper, MethodHandle> WRAPPER_CASTS
 = new EnumMap<Wrapper, MethodHandle>(Wrapper.class);
 mh = ALWAYS_NULL;
 else
 mh = MethodHandles.insertArguments(CAST_REFERENCE, 0, type);
 if (exact) {
 MethodType xmt = MethodType.methodType(type, Object.class);
-mh = AdapterMethodHandle.makeRetypeRaw(IMPL_TOKEN, xmt, mh);
+mh = MethodHandles.explicitCastArguments(mh, xmt);
+//mh = AdapterMethodHandle.makeRetypeRaw(IMPL_TOKEN, xmt, mh);
 }
 if (cache != null)
 cache.put(wrap, mh);
 return mh;
 }
 public static MethodHandle identity() {
 return IDENTITY;
 }
 public static MethodHandle identity(Class<?> type) {
-if (type == Object.class)
+// This stuff has been moved into MethodHandles:
-return IDENTITY;
+return MethodHandles.identity(type);
-else if (!type.isPrimitive())
+}
-return retype(MethodType.methodType(type, type), IDENTITY);
-else
+public static MethodHandle identity(Wrapper wrap) {
-return identity(Wrapper.forPrimitiveType(type));
-}
-static MethodHandle identity(Wrapper wrap) {
 EnumMap<Wrapper, MethodHandle> cache = CONSTANT_FUNCTIONS[1];
 MethodHandle mh = cache.get(wrap);
 if (mh != null) {
 return mh;
 }
 if (mh != null) {
 cache.put(wrap, mh);
 return mh;
 }
-// use a raw conversion
-if (wrap.isSingleWord() && wrap != Wrapper.INT) {
-mh = retype(type, identity(Wrapper.INT));
-} else if (wrap.isDoubleWord() && wrap != Wrapper.LONG) {
-mh = retype(type, identity(Wrapper.LONG));
-}
 if (mh != null) {
 cache.put(wrap, mh);
 return mh;
 }
 throw new IllegalArgumentException("cannot find identity for " + wrap);
-}
-private static MethodHandle retype(MethodType type, MethodHandle mh) {
-return AdapterMethodHandle.makeRetypeRaw(IMPL_TOKEN, type, mh);
 }
 private static final Object[] NO_ARGS_ARRAY = {};
 private static Object[] makeArray(Object... args) { return args; }
 private static Object[] array() { return NO_ARGS_ARRAY; }

changeset 8821	2836ee97ee27
parent 8347	e5daa5772ffd