/*

  * Copyright (c) 2008, 2013, 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.  Oracle designates this

  * particular file as subject to the "Classpath" exception as provided

  * by Oracle in the LICENSE file that accompanied this code.

  *

  * This code is distributed in the hope that it will be useful, but WITHOUT

  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

  * version 2 for more details (a copy is included in the LICENSE file that

  * accompanied this code).

  *

  * You should have received a copy of the GNU General Public License version

  * 2 along with this work; if not, write to the Free Software Foundation,

  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

  *

  * 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.

  */

 package sun.invoke.util;

 import java.lang.invoke.MethodHandle;

 import java.lang.invoke.MethodHandles;

 import java.lang.invoke.MethodHandles.Lookup;

 import java.lang.invoke.MethodType;

 import java.security.AccessController;

 import java.security.PrivilegedAction;

 import java.util.ArrayList;

 import java.util.Arrays;

 import java.util.Collections;

 import java.util.EnumMap;

 import java.util.List;

 public class ValueConversions {

     private static final Class<?> THIS_CLASS = ValueConversions.class;

     // Do not adjust this except for special platforms:

     private static final int MAX_ARITY;

     static {

         final Object[] values = { 255 };

         AccessController.doPrivileged(new PrivilegedAction<Void>() {

                 @Override

                 public Void run() {

                     values[0] = Integer.getInteger(THIS_CLASS.getName()+".MAX_ARITY", 255);

                     return null;

                 }

             });

         MAX_ARITY = (Integer) values[0];

     }

     private static final Lookup IMPL_LOOKUP = MethodHandles.lookup();

     private static EnumMap<Wrapper, MethodHandle>[] newWrapperCaches(int n) {

         @SuppressWarnings("unchecked")  // generic array creation

         EnumMap<Wrapper, MethodHandle>[] caches

                 = (EnumMap<Wrapper, MethodHandle>[]) new EnumMap<?,?>[n];

         for (int i = 0; i < n; i++)

             caches[i] = new EnumMap<>(Wrapper.class);

         return caches;

     }

     /// Converting references to values.

     // There are several levels of this unboxing conversions:

     //   no conversions:  exactly Integer.valueOf, etc.

     //   implicit conversions sanctioned by JLS 5.1.2, etc.

     //   explicit conversions as allowed by explicitCastArguments

     static int unboxInteger(Object x, boolean cast) {

         if (x instanceof Integer)

             return ((Integer) x).intValue();

         return primitiveConversion(Wrapper.INT, x, cast).intValue();

     }

     static byte unboxByte(Object x, boolean cast) {

         if (x instanceof Byte)

             return ((Byte) x).byteValue();

         return primitiveConversion(Wrapper.BYTE, x, cast).byteValue();

     }

     static short unboxShort(Object x, boolean cast) {

         if (x instanceof Short)

             return ((Short) x).shortValue();

         return primitiveConversion(Wrapper.SHORT, x, cast).shortValue();

     }

     static boolean unboxBoolean(Object x, boolean cast) {

         if (x instanceof Boolean)

             return ((Boolean) x).booleanValue();

         return (primitiveConversion(Wrapper.BOOLEAN, x, cast).intValue() & 1) != 0;

     }

     static char unboxCharacter(Object x, boolean cast) {

         if (x instanceof Character)

             return ((Character) x).charValue();

         return (char) primitiveConversion(Wrapper.CHAR, x, cast).intValue();

     }

     static long unboxLong(Object x, boolean cast) {

         if (x instanceof Long)

             return ((Long) x).longValue();

         return primitiveConversion(Wrapper.LONG, x, cast).longValue();

     }

     static float unboxFloat(Object x, boolean cast) {

         if (x instanceof Float)

             return ((Float) x).floatValue();

         return primitiveConversion(Wrapper.FLOAT, x, cast).floatValue();

     }

     static double unboxDouble(Object x, boolean cast) {

         if (x instanceof Double)

             return ((Double) x).doubleValue();

         return primitiveConversion(Wrapper.DOUBLE, x, cast).doubleValue();

     }

     private static MethodType unboxType(Wrapper wrap) {

         return MethodType.methodType(wrap.primitiveType(), Object.class, boolean.class);

     }

     private static final EnumMap<Wrapper, MethodHandle>[]

             UNBOX_CONVERSIONS = newWrapperCaches(2);

     private static MethodHandle unbox(Wrapper wrap, boolean cast) {

         EnumMap<Wrapper, MethodHandle> cache = UNBOX_CONVERSIONS[(cast?1:0)];

         MethodHandle mh = cache.get(wrap);

         if (mh != null) {

             return mh;

         }

         // slow path

         switch (wrap) {

             case OBJECT:

                 mh = IDENTITY; break;

             case VOID:

                 mh = IGNORE; break;

         }

         if (mh != null) {

             cache.put(wrap, mh);

             return mh;

         }

         // look up the method

         String name = "unbox" + wrap.wrapperSimpleName();

         MethodType type = unboxType(wrap);

         try {

             mh = IMPL_LOOKUP.findStatic(THIS_CLASS, name, type);

         } catch (ReflectiveOperationException ex) {

             mh = null;

         }

         if (mh != null) {

             mh = MethodHandles.insertArguments(mh, 1, cast);

             cache.put(wrap, mh);

             return mh;

         }

         throw new IllegalArgumentException("cannot find unbox adapter for " + wrap

                 + (cast ? " (cast)" : ""));

     }

     public static MethodHandle unboxCast(Wrapper type) {

         return unbox(type, true);

     }

     public static MethodHandle unbox(Class<?> type) {

         return unbox(Wrapper.forPrimitiveType(type), false);

     }

     public static MethodHandle unboxCast(Class<?> type) {

         return unbox(Wrapper.forPrimitiveType(type), true);

     }

     static private final Integer ZERO_INT = 0, ONE_INT = 1;

     /// Primitive conversions

     /**

      * Produce a Number which represents the given value {@code x}

      * according to the primitive type of the given wrapper {@code wrap}.

      * Caller must invoke intValue, byteValue, longValue (etc.) on the result

      * to retrieve the desired primitive value.

      */

     public static Number primitiveConversion(Wrapper wrap, Object x, boolean cast) {

         // Maybe merge this code with Wrapper.convert/cast.

         Number res;

         if (x == null) {

             if (!cast)  return null;

             return ZERO_INT;

         }

         if (x instanceof Number) {

             res = (Number) x;

         } else if (x instanceof Boolean) {

             res = ((boolean)x ? ONE_INT : ZERO_INT);

         } else if (x instanceof Character) {

             res = (int)(char)x;

         } else {

             // this will fail with the required ClassCastException:

             res = (Number) x;

         }

         Wrapper xwrap = Wrapper.findWrapperType(x.getClass());

         if (xwrap == null || !cast && !wrap.isConvertibleFrom(xwrap))

             // this will fail with the required ClassCastException:

             return (Number) wrap.wrapperType().cast(x);

         return res;

     }

     /**

      * The JVM verifier allows boolean, byte, short, or char to widen to int.

      * Support exactly this conversion, from a boxed value type Boolean,

      * Byte, Short, Character, or Integer.

      */

     public static int widenSubword(Object x) {

         if (x instanceof Integer)

             return (int) x;

         else if (x instanceof Boolean)

             return fromBoolean((boolean) x);

         else if (x instanceof Character)

             return (char) x;

         else if (x instanceof Short)

             return (short) x;

         else if (x instanceof Byte)

             return (byte) x;

         else

             // Fail with a ClassCastException.

             return (int) x;

     }

     /// Converting primitives to references

     static Integer boxInteger(int x) {

         return x;

     }

     static Byte boxByte(byte x) {

         return x;

     }

     static Short boxShort(short x) {

         return x;

     }

     static Boolean boxBoolean(boolean x) {

         return x;

     }

     static Character boxCharacter(char x) {

         return x;

     }

     static Long boxLong(long x) {

         return x;

     }

     static Float boxFloat(float x) {

         return x;

     }

     static Double boxDouble(double x) {

         return x;

     }

     private static MethodType boxType(Wrapper wrap) {

         // be exact, since return casts are hard to compose

         Class<?> boxType = wrap.wrapperType();

         return MethodType.methodType(boxType, wrap.primitiveType());

     }

     private static final EnumMap<Wrapper, MethodHandle>[]

             BOX_CONVERSIONS = newWrapperCaches(2);

     private static MethodHandle box(Wrapper wrap, boolean exact) {

         EnumMap<Wrapper, MethodHandle> cache = BOX_CONVERSIONS[(exact?1:0)];

         MethodHandle mh = cache.get(wrap);

         if (mh != null) {

             return mh;

         }

         // slow path

         switch (wrap) {

             case OBJECT:

                 mh = IDENTITY; break;

             case VOID:

                 mh = ZERO_OBJECT;

                 break;

         }

         if (mh != null) {

             cache.put(wrap, mh);

             return mh;

         }

         // look up the method

         String name = "box" + wrap.wrapperSimpleName();

         MethodType type = boxType(wrap);

         if (exact) {

             try {

                 mh = IMPL_LOOKUP.findStatic(THIS_CLASS, name, type);

             } catch (ReflectiveOperationException ex) {

                 mh = null;

             }

         } else {

             mh = box(wrap, !exact).asType(type.erase());

         }

         if (mh != null) {

             cache.put(wrap, mh);

             return mh;

         }

         throw new IllegalArgumentException("cannot find box adapter for "

                 + wrap + (exact ? " (exact)" : ""));

     }

     public static MethodHandle box(Class<?> type) {

         boolean exact = false;

         // e.g., boxShort(short)Short if exact,

         // e.g., boxShort(short)Object if !exact

         return box(Wrapper.forPrimitiveType(type), exact);

     }

     public static MethodHandle box(Wrapper type) {

         boolean exact = false;

         return box(type, exact);

     }

     /// Constant functions

     static void ignore(Object x) {

         // no value to return; this is an unbox of null

     }

     static void empty() {

     }

     static Object zeroObject() {

         return null;

     }

     static int zeroInteger() {

         return 0;

     }

     static long zeroLong() {

         return 0;

     }

     static float zeroFloat() {

         return 0;

     }

     static double zeroDouble() {

         return 0;

     }

     private static final EnumMap<Wrapper, MethodHandle>[]

             CONSTANT_FUNCTIONS = newWrapperCaches(2);

     public static MethodHandle zeroConstantFunction(Wrapper wrap) {

         EnumMap<Wrapper, MethodHandle> cache = CONSTANT_FUNCTIONS[0];

         MethodHandle mh = cache.get(wrap);

         if (mh != null) {

             return mh;

         }

         // slow path

         MethodType type = MethodType.methodType(wrap.primitiveType());

         switch (wrap) {

             case VOID:

                 mh = EMPTY;

                 break;

             case OBJECT:

             case INT: case LONG: case FLOAT: case DOUBLE:

                 try {

                     mh = IMPL_LOOKUP.findStatic(THIS_CLASS, "zero"+wrap.wrapperSimpleName(), type);

                 } catch (ReflectiveOperationException ex) {

                     mh = null;

                 }

                 break;

         }

         if (mh != null) {

             cache.put(wrap, mh);

             return mh;

         }

         // use zeroInt and cast the result

         if (wrap.isSubwordOrInt() && wrap != Wrapper.INT) {

             mh = MethodHandles.explicitCastArguments(zeroConstantFunction(Wrapper.INT), type);

             cache.put(wrap, mh);

             return mh;

         }

         throw new IllegalArgumentException("cannot find zero constant for " + wrap);

     }

     /// Converting references to references.

     /**

      * Identity function.

      * @param x an arbitrary reference value

      * @return the same value x

      */

     static <T> T identity(T x) {

         return x;

     }

     static <T> T[] identity(T[] x) {

         return x;

     }

     /**

      * Identity function on ints.

      * @param x an arbitrary int value

      * @return the same value x

      */

     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.

      * @param t an arbitrary reference type

      * @param x an arbitrary reference value

      * @return the same value x

      */

     @SuppressWarnings("unchecked")

     static <T,U> T castReference(Class<? extends T> t, U x) {

         // inlined Class.cast because we can't ForceInline it

         if (x != null && !t.isInstance(x))

             throw newClassCastException(t, x);

         return (T) x;

     }

     private static ClassCastException newClassCastException(Class<?> t, Object obj) {

         return new ClassCastException("Cannot cast " + obj.getClass().getName() + " to " + t.getName());

     }

     private static final MethodHandle IDENTITY, CAST_REFERENCE, ZERO_OBJECT, IGNORE, EMPTY,

             ARRAY_IDENTITY, FILL_NEW_TYPED_ARRAY, FILL_NEW_ARRAY;

     static {

         try {

             MethodType idType = MethodType.genericMethodType(1);

             MethodType castType = idType.insertParameterTypes(0, Class.class);

             MethodType ignoreType = idType.changeReturnType(void.class);

             MethodType zeroObjectType = MethodType.genericMethodType(0);

             IDENTITY = IMPL_LOOKUP.findStatic(THIS_CLASS, "identity", idType);

             //CAST_REFERENCE = IMPL_LOOKUP.findVirtual(Class.class, "cast", idType);

             CAST_REFERENCE = IMPL_LOOKUP.findStatic(THIS_CLASS, "castReference", castType);

             ZERO_OBJECT = IMPL_LOOKUP.findStatic(THIS_CLASS, "zeroObject", zeroObjectType);

             IGNORE = IMPL_LOOKUP.findStatic(THIS_CLASS, "ignore", ignoreType);

             EMPTY = IMPL_LOOKUP.findStatic(THIS_CLASS, "empty", ignoreType.dropParameterTypes(0, 1));

             ARRAY_IDENTITY = IMPL_LOOKUP.findStatic(THIS_CLASS, "identity", MethodType.methodType(Object[].class, Object[].class));

             FILL_NEW_ARRAY = IMPL_LOOKUP

                     .findStatic(THIS_CLASS, "fillNewArray",

                           MethodType.methodType(Object[].class, Integer.class, Object[].class));

             FILL_NEW_TYPED_ARRAY = IMPL_LOOKUP

                     .findStatic(THIS_CLASS, "fillNewTypedArray",

                           MethodType.methodType(Object[].class, Object[].class, Integer.class, Object[].class));

         } catch (NoSuchMethodException | IllegalAccessException ex) {

             throw newInternalError("uncaught exception", ex);

         }

     }

     // Varargs methods need to be in a separately initialized class, to avoid bootstrapping problems.

     static class LazyStatics {

         private static final MethodHandle COPY_AS_REFERENCE_ARRAY, COPY_AS_PRIMITIVE_ARRAY, MAKE_LIST;

         static {

             try {

                 //MAKE_ARRAY = IMPL_LOOKUP.findStatic(THIS_CLASS, "makeArray", MethodType.methodType(Object[].class, Object[].class));

                 COPY_AS_REFERENCE_ARRAY = IMPL_LOOKUP.findStatic(THIS_CLASS, "copyAsReferenceArray", MethodType.methodType(Object[].class, Class.class, Object[].class));

                 COPY_AS_PRIMITIVE_ARRAY = IMPL_LOOKUP.findStatic(THIS_CLASS, "copyAsPrimitiveArray", MethodType.methodType(Object.class, Wrapper.class, Object[].class));

                 MAKE_LIST = IMPL_LOOKUP.findStatic(THIS_CLASS, "makeList", MethodType.methodType(List.class, Object[].class));

             } catch (ReflectiveOperationException ex) {

                 throw newInternalError("uncaught exception", ex);

             }

         }

     }

     private static final EnumMap<Wrapper, MethodHandle>[] WRAPPER_CASTS

             = newWrapperCaches(1);

     /** Return a method that casts its sole argument (an Object) to the given type

      *  and returns it as the given type.

      */

     public static MethodHandle cast(Class<?> type) {

         if (type.isPrimitive())  throw new IllegalArgumentException("cannot cast primitive type "+type);

         MethodHandle mh;

         Wrapper wrap = null;

         EnumMap<Wrapper, MethodHandle> cache = null;

         if (Wrapper.isWrapperType(type)) {

             wrap = Wrapper.forWrapperType(type);

             cache = WRAPPER_CASTS[0];

             mh = cache.get(wrap);

             if (mh != null)  return mh;

         }

         mh = MethodHandles.insertArguments(CAST_REFERENCE, 0, type);

         if (cache != null)

             cache.put(wrap, mh);

         return mh;

     }

     public static MethodHandle identity() {

         return IDENTITY;

     }

     public static MethodHandle identity(Class<?> type) {

         if (!type.isPrimitive())

             // Reference identity has been moved into MethodHandles:

             return MethodHandles.identity(type);

         return identity(Wrapper.findPrimitiveType(type));

     }

     public static MethodHandle identity(Wrapper wrap) {

         EnumMap<Wrapper, MethodHandle> cache = CONSTANT_FUNCTIONS[1];

         MethodHandle mh = cache.get(wrap);

         if (mh != null) {

             return mh;

         }

         // slow path

         MethodType type = MethodType.methodType(wrap.primitiveType());

         if (wrap != Wrapper.VOID)

             type = type.appendParameterTypes(wrap.primitiveType());

         try {

             mh = IMPL_LOOKUP.findStatic(THIS_CLASS, "identity", type);

         } catch (ReflectiveOperationException ex) {

             mh = null;

         }

         if (mh == null && wrap == Wrapper.VOID) {

             mh = EMPTY;  // #(){} : #()void

         }

         if (mh != null) {

             cache.put(wrap, mh);

             return mh;

         }

         if (mh != null) {

             cache.put(wrap, mh);

             return mh;

         }

         throw new IllegalArgumentException("cannot find identity for " + wrap);

     }

     /// Primitive conversions.

     // These are supported directly by the JVM, usually by a single instruction.

     // In the case of narrowing to a subword, there may be a pair of instructions.

     // In the case of booleans, there may be a helper routine to manage a 1-bit value.

     // This is the full 8x8 matrix (minus the diagonal).

     // narrow double to all other types:

     static float doubleToFloat(double x) {  // bytecode: d2f

         return (float) x;

     }

     static long doubleToLong(double x) {  // bytecode: d2l

         return (long) x;

     }

     static int doubleToInt(double x) {  // bytecode: d2i

         return (int) x;

     }

     static short doubleToShort(double x) {  // bytecodes: d2i, i2s

         return (short) x;

     }

     static char doubleToChar(double x) {  // bytecodes: d2i, i2c

         return (char) x;

     }

     static byte doubleToByte(double x) {  // bytecodes: d2i, i2b

         return (byte) x;

     }

     static boolean doubleToBoolean(double x) {

         return toBoolean((byte) x);

     }

     // widen float:

     static double floatToDouble(float x) {  // bytecode: f2d

         return x;

     }

     // narrow float:

     static long floatToLong(float x) {  // bytecode: f2l

         return (long) x;

     }

     static int floatToInt(float x) {  // bytecode: f2i

         return (int) x;

     }

     static short floatToShort(float x) {  // bytecodes: f2i, i2s

         return (short) x;

     }

     static char floatToChar(float x) {  // bytecodes: f2i, i2c

         return (char) x;

     }

     static byte floatToByte(float x) {  // bytecodes: f2i, i2b

         return (byte) x;

     }

     static boolean floatToBoolean(float x) {

         return toBoolean((byte) x);

     }

     // widen long:

     static double longToDouble(long x) {  // bytecode: l2d

         return x;

     }

     static float longToFloat(long x) {  // bytecode: l2f

         return x;

     }

     // narrow long:

     static int longToInt(long x) {  // bytecode: l2i

         return (int) x;

     }

     static short longToShort(long x) {  // bytecodes: f2i, i2s

         return (short) x;

     }

     static char longToChar(long x) {  // bytecodes: f2i, i2c

         return (char) x;

     }

     static byte longToByte(long x) {  // bytecodes: f2i, i2b

         return (byte) x;

     }

     static boolean longToBoolean(long x) {

         return toBoolean((byte) x);

     }

     // widen int:

     static double intToDouble(int x) {  // bytecode: i2d

         return x;

     }

     static float intToFloat(int x) {  // bytecode: i2f

         return x;

     }

     static long intToLong(int x) {  // bytecode: i2l

         return x;

     }

     // narrow int:

     static short intToShort(int x) {  // bytecode: i2s

         return (short) x;

     }

     static char intToChar(int x) {  // bytecode: i2c

         return (char) x;

     }

     static byte intToByte(int x) {  // bytecode: i2b

         return (byte) x;

     }

     static boolean intToBoolean(int x) {

         return toBoolean((byte) x);

     }

     // widen short:

     static double shortToDouble(short x) {  // bytecode: i2d (implicit 's2i')

         return x;

     }

     static float shortToFloat(short x) {  // bytecode: i2f (implicit 's2i')

         return x;

     }

     static long shortToLong(short x) {  // bytecode: i2l (implicit 's2i')

         return x;

     }

     static int shortToInt(short x) {  // (implicit 's2i')

         return x;

     }

     // narrow short:

     static char shortToChar(short x) {  // bytecode: i2c (implicit 's2i')

         return (char)x;

     }

     static byte shortToByte(short x) {  // bytecode: i2b (implicit 's2i')

         return (byte)x;

     }

     static boolean shortToBoolean(short x) {

         return toBoolean((byte) x);

     }

     // widen char:

     static double charToDouble(char x) {  // bytecode: i2d (implicit 'c2i')

         return x;

     }

     static float charToFloat(char x) {  // bytecode: i2f (implicit 'c2i')

         return x;

     }

     static long charToLong(char x) {  // bytecode: i2l (implicit 'c2i')

         return x;

     }

     static int charToInt(char x) {  // (implicit 'c2i')

         return x;

     }

     // narrow char:

     static short charToShort(char x) {  // bytecode: i2s (implicit 'c2i')

         return (short)x;

     }

     static byte charToByte(char x) {  // bytecode: i2b (implicit 'c2i')

         return (byte)x;

     }

     static boolean charToBoolean(char x) {

         return toBoolean((byte) x);

     }

     // widen byte:

     static double byteToDouble(byte x) {  // bytecode: i2d (implicit 'b2i')

         return x;

     }

     static float byteToFloat(byte x) {  // bytecode: i2f (implicit 'b2i')

         return x;

     }

     static long byteToLong(byte x) {  // bytecode: i2l (implicit 'b2i')

         return x;

     }

     static int byteToInt(byte x) {  // (implicit 'b2i')

         return x;

     }

     static short byteToShort(byte x) {  // bytecode: i2s (implicit 'b2i')

         return (short)x;

     }

     static char byteToChar(byte x) {  // bytecode: i2b (implicit 'b2i')

         return (char)x;

     }

     // narrow byte to boolean:

     static boolean byteToBoolean(byte x) {

         return toBoolean(x);

     }

     // widen boolean to all types:

     static double booleanToDouble(boolean x) {

         return fromBoolean(x);

     }

     static float booleanToFloat(boolean x) {

         return fromBoolean(x);

     }

     static long booleanToLong(boolean x) {

         return fromBoolean(x);

     }

     static int booleanToInt(boolean x) {

         return fromBoolean(x);

     }

     static short booleanToShort(boolean x) {

         return fromBoolean(x);

     }

     static char booleanToChar(boolean x) {

         return (char)fromBoolean(x);

     }

     static byte booleanToByte(boolean x) {

         return fromBoolean(x);

     }

     // helpers to force boolean into the conversion scheme:

     static boolean toBoolean(byte x) {

         // see javadoc for MethodHandles.explicitCastArguments

         return ((x & 1) != 0);

     }

     static byte fromBoolean(boolean x) {

         // see javadoc for MethodHandles.explicitCastArguments

         return (x ? (byte)1 : (byte)0);

     }

     private static final EnumMap<Wrapper, MethodHandle>[]

             CONVERT_PRIMITIVE_FUNCTIONS = newWrapperCaches(Wrapper.values().length);

     public static MethodHandle convertPrimitive(Wrapper wsrc, Wrapper wdst) {

         EnumMap<Wrapper, MethodHandle> cache = CONVERT_PRIMITIVE_FUNCTIONS[wsrc.ordinal()];

         MethodHandle mh = cache.get(wdst);

         if (mh != null) {

             return mh;

         }

         // slow path

         Class<?> src = wsrc.primitiveType();

         Class<?> dst = wdst.primitiveType();

         MethodType type = src == void.class ? MethodType.methodType(dst) : MethodType.methodType(dst, src);

         if (wsrc == wdst) {

             mh = identity(src);

         } else if (wsrc == Wrapper.VOID) {

             mh = zeroConstantFunction(wdst);

         } else if (wdst == Wrapper.VOID) {

             mh = MethodHandles.dropArguments(EMPTY, 0, src);  // Defer back to MethodHandles.

         } else if (wsrc == Wrapper.OBJECT) {

             mh = unboxCast(dst);

         } else if (wdst == Wrapper.OBJECT) {

             mh = box(src);

         } else {

             assert(src.isPrimitive() && dst.isPrimitive());

             try {

                 mh = IMPL_LOOKUP.findStatic(THIS_CLASS, src.getSimpleName()+"To"+capitalize(dst.getSimpleName()), type);

             } catch (ReflectiveOperationException ex) {

                 mh = null;

             }

         }

         if (mh != null) {

             assert(mh.type() == type) : mh;

             cache.put(wdst, mh);

             return mh;

         }

         throw new IllegalArgumentException("cannot find primitive conversion function for " +

                                            src.getSimpleName()+" -> "+dst.getSimpleName());

     }

     public static MethodHandle convertPrimitive(Class<?> src, Class<?> dst) {

         return convertPrimitive(Wrapper.forPrimitiveType(src), Wrapper.forPrimitiveType(dst));

     }

     private static String capitalize(String x) {

         return Character.toUpperCase(x.charAt(0))+x.substring(1);

     }

     /// Collection of multiple arguments.

     public static Object convertArrayElements(Class<?> arrayType, Object array) {

         Class<?> src = array.getClass().getComponentType();

         Class<?> dst = arrayType.getComponentType();

         if (src == null || dst == null)  throw new IllegalArgumentException("not array type");

         Wrapper sw = (src.isPrimitive() ? Wrapper.forPrimitiveType(src) : null);

         Wrapper dw = (dst.isPrimitive() ? Wrapper.forPrimitiveType(dst) : null);

         int length;

         if (sw == null) {

             Object[] a = (Object[]) array;

             length = a.length;

             if (dw == null)

                 return Arrays.copyOf(a, length, arrayType.asSubclass(Object[].class));

             Object res = dw.makeArray(length);

             dw.copyArrayUnboxing(a, 0, res, 0, length);

             return res;

         }

         length = java.lang.reflect.Array.getLength(array);

         Object[] res;

         if (dw == null) {

             res = Arrays.copyOf(NO_ARGS_ARRAY, length, arrayType.asSubclass(Object[].class));

         } else {

             res = new Object[length];

         }

         sw.copyArrayBoxing(array, 0, res, 0, length);

         if (dw == null)  return res;

         Object a = dw.makeArray(length);

         dw.copyArrayUnboxing(res, 0, a, 0, length);

         return a;

     }

     private static MethodHandle findCollector(String name, int nargs, Class<?> rtype, Class<?>... ptypes) {

         MethodType type = MethodType.genericMethodType(nargs)

                 .changeReturnType(rtype)

                 .insertParameterTypes(0, ptypes);

         try {

             return IMPL_LOOKUP.findStatic(THIS_CLASS, name, type);

         } catch (ReflectiveOperationException ex) {

             return null;

         }

     }

     private static final Object[] NO_ARGS_ARRAY = {};

     private static Object[] makeArray(Object... args) { return args; }

     private static Object[] array() { return NO_ARGS_ARRAY; }

     private static Object[] array(Object a0)

                 { return makeArray(a0); }

     private static Object[] array(Object a0, Object a1)

                 { return makeArray(a0, a1); }

     private static Object[] array(Object a0, Object a1, Object a2)

                 { return makeArray(a0, a1, a2); }

     private static Object[] array(Object a0, Object a1, Object a2, Object a3)

                 { return makeArray(a0, a1, a2, a3); }

     private static Object[] array(Object a0, Object a1, Object a2, Object a3,

                                   Object a4)

                 { return makeArray(a0, a1, a2, a3, a4); }

     private static Object[] array(Object a0, Object a1, Object a2, Object a3,

                                   Object a4, Object a5)

                 { return makeArray(a0, a1, a2, a3, a4, a5); }

     private static Object[] array(Object a0, Object a1, Object a2, Object a3,

                                   Object a4, Object a5, Object a6)

                 { return makeArray(a0, a1, a2, a3, a4, a5, a6); }

     private static Object[] array(Object a0, Object a1, Object a2, Object a3,

                                   Object a4, Object a5, Object a6, Object a7)

                 { return makeArray(a0, a1, a2, a3, a4, a5, a6, a7); }

     private static Object[] array(Object a0, Object a1, Object a2, Object a3,

                                   Object a4, Object a5, Object a6, Object a7,

                                   Object a8)

                 { return makeArray(a0, a1, a2, a3, a4, a5, a6, a7, a8); }

     private static Object[] array(Object a0, Object a1, Object a2, Object a3,

                                   Object a4, Object a5, Object a6, Object a7,

                                   Object a8, Object a9)

                 { return makeArray(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }

     private static MethodHandle[] makeArrays() {

         ArrayList<MethodHandle> mhs = new ArrayList<>();

         for (;;) {

             MethodHandle mh = findCollector("array", mhs.size(), Object[].class);

             if (mh == null)  break;

             mhs.add(mh);

         }

         assert(mhs.size() == 11);  // current number of methods

         return mhs.toArray(new MethodHandle[MAX_ARITY+1]);

     }

     private static final MethodHandle[] ARRAYS = makeArrays();

     // filling versions of the above:

     // using Integer len instead of int len and no varargs to avoid bootstrapping problems

     private static Object[] fillNewArray(Integer len, Object[] /*not ...*/ args) {

         Object[] a = new Object[len];

         fillWithArguments(a, 0, args);

         return a;

     }

     private static Object[] fillNewTypedArray(Object[] example, Integer len, Object[] /*not ...*/ args) {

         Object[] a = Arrays.copyOf(example, len);

         fillWithArguments(a, 0, args);

         return a;

     }

     private static void fillWithArguments(Object[] a, int pos, Object... args) {

         System.arraycopy(args, 0, a, pos, args.length);

     }

     // using Integer pos instead of int pos to avoid bootstrapping problems

     private static Object[] fillArray(Integer pos, Object[] a, Object a0)

                 { fillWithArguments(a, pos, a0); return a; }

     private static Object[] fillArray(Integer pos, Object[] a, Object a0, Object a1)

                 { fillWithArguments(a, pos, a0, a1); return a; }

     private static Object[] fillArray(Integer pos, Object[] a, Object a0, Object a1, Object a2)

                 { fillWithArguments(a, pos, a0, a1, a2); return a; }

     private static Object[] fillArray(Integer pos, Object[] a, Object a0, Object a1, Object a2, Object a3)

                 { fillWithArguments(a, pos, a0, a1, a2, a3); return a; }

     private static Object[] fillArray(Integer pos, Object[] a, Object a0, Object a1, Object a2, Object a3,

                                   Object a4)

                 { fillWithArguments(a, pos, a0, a1, a2, a3, a4); return a; }

     private static Object[] fillArray(Integer pos, Object[] a, Object a0, Object a1, Object a2, Object a3,

                                   Object a4, Object a5)

                 { fillWithArguments(a, pos, a0, a1, a2, a3, a4, a5); return a; }

     private static Object[] fillArray(Integer pos, Object[] a, Object a0, Object a1, Object a2, Object a3,

                                   Object a4, Object a5, Object a6)

                 { fillWithArguments(a, pos, a0, a1, a2, a3, a4, a5, a6); return a; }

     private static Object[] fillArray(Integer pos, Object[] a, Object a0, Object a1, Object a2, Object a3,

                                   Object a4, Object a5, Object a6, Object a7)

                 { fillWithArguments(a, pos, a0, a1, a2, a3, a4, a5, a6, a7); return a; }

     private static Object[] fillArray(Integer pos, Object[] a, Object a0, Object a1, Object a2, Object a3,

                                   Object a4, Object a5, Object a6, Object a7,

                                   Object a8)

                 { fillWithArguments(a, pos, a0, a1, a2, a3, a4, a5, a6, a7, a8); return a; }

     private static Object[] fillArray(Integer pos, Object[] a, Object a0, Object a1, Object a2, Object a3,

                                   Object a4, Object a5, Object a6, Object a7,

                                   Object a8, Object a9)

                 { fillWithArguments(a, pos, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); return a; }

     private static MethodHandle[] makeFillArrays() {

         ArrayList<MethodHandle> mhs = new ArrayList<>();

         mhs.add(null);  // there is no empty fill; at least a0 is required

         for (;;) {

             MethodHandle mh = findCollector("fillArray", mhs.size(), Object[].class, Integer.class, Object[].class);

             if (mh == null)  break;

             mhs.add(mh);

         }

         assert(mhs.size() == 11);  // current number of methods

         return mhs.toArray(new MethodHandle[0]);

     }

     private static final MethodHandle[] FILL_ARRAYS = makeFillArrays();

     private static Object[] copyAsReferenceArray(Class<? extends Object[]> arrayType, Object... a) {

         return Arrays.copyOf(a, a.length, arrayType);

     }

     private static Object copyAsPrimitiveArray(Wrapper w, Object... boxes) {

         Object a = w.makeArray(boxes.length);

         w.copyArrayUnboxing(boxes, 0, a, 0, boxes.length);

         return a;

     }

     /** Return a method handle that takes the indicated number of Object

      *  arguments and returns an Object array of them, as if for varargs.

      */

     public static MethodHandle varargsArray(int nargs) {

         MethodHandle mh = ARRAYS[nargs];

         if (mh != null)  return mh;

         mh = findCollector("array", nargs, Object[].class);

         if (mh != null)  return ARRAYS[nargs] = mh;

         mh = buildVarargsArray(FILL_NEW_ARRAY, ARRAY_IDENTITY, nargs);

         assert(assertCorrectArity(mh, nargs));

         return ARRAYS[nargs] = mh;

     }

     private static boolean assertCorrectArity(MethodHandle mh, int arity) {

         assert(mh.type().parameterCount() == arity) : "arity != "+arity+": "+mh;

         return true;

     }

     private static MethodHandle buildVarargsArray(MethodHandle newArray, MethodHandle finisher, int nargs) {

         // Build up the result mh as a sequence of fills like this:

         //   finisher(fill(fill(newArrayWA(23,x1..x10),10,x11..x20),20,x21..x23))

         // The various fill(_,10*I,___*[J]) are reusable.

         int leftLen = Math.min(nargs, LEFT_ARGS);  // absorb some arguments immediately

         int rightLen = nargs - leftLen;

         MethodHandle leftCollector = newArray.bindTo(nargs);

         leftCollector = leftCollector.asCollector(Object[].class, leftLen);

         MethodHandle mh = finisher;

         if (rightLen > 0) {

             MethodHandle rightFiller = fillToRight(LEFT_ARGS + rightLen);

             if (mh == ARRAY_IDENTITY)

                 mh = rightFiller;

             else

                 mh = MethodHandles.collectArguments(mh, 0, rightFiller);

         }

         if (mh == ARRAY_IDENTITY)

             mh = leftCollector;

         else

             mh = MethodHandles.collectArguments(mh, 0, leftCollector);

         return mh;

     }

     private static final int LEFT_ARGS = (FILL_ARRAYS.length - 1);

     private static final MethodHandle[] FILL_ARRAY_TO_RIGHT = new MethodHandle[MAX_ARITY+1];

     /** fill_array_to_right(N).invoke(a, argL..arg[N-1])

      *  fills a[L]..a[N-1] with corresponding arguments,

      *  and then returns a.  The value L is a global constant (LEFT_ARGS).

      */

     private static MethodHandle fillToRight(int nargs) {

         MethodHandle filler = FILL_ARRAY_TO_RIGHT[nargs];

         if (filler != null)  return filler;

         filler = buildFiller(nargs);

         assert(assertCorrectArity(filler, nargs - LEFT_ARGS + 1));

         return FILL_ARRAY_TO_RIGHT[nargs] = filler;

     }

     private static MethodHandle buildFiller(int nargs) {

         if (nargs <= LEFT_ARGS)

             return ARRAY_IDENTITY;  // no args to fill; return the array unchanged

         // we need room for both mh and a in mh.invoke(a, arg*[nargs])

         final int CHUNK = LEFT_ARGS;

         int rightLen = nargs % CHUNK;

         int midLen = nargs - rightLen;

         if (rightLen == 0) {

             midLen = nargs - (rightLen = CHUNK);

             if (FILL_ARRAY_TO_RIGHT[midLen] == null) {

                 // build some precursors from left to right

                 for (int j = LEFT_ARGS % CHUNK; j < midLen; j += CHUNK)

                     if (j > LEFT_ARGS)  fillToRight(j);

             }

         }

         if (midLen < LEFT_ARGS) rightLen = nargs - (midLen = LEFT_ARGS);

         assert(rightLen > 0);

         MethodHandle midFill = fillToRight(midLen);  // recursive fill

         MethodHandle rightFill = FILL_ARRAYS[rightLen].bindTo(midLen);  // [midLen..nargs-1]

         assert(midFill.type().parameterCount()   == 1 + midLen - LEFT_ARGS);

         assert(rightFill.type().parameterCount() == 1 + rightLen);

         // Combine the two fills:

         //   right(mid(a, x10..x19), x20..x23)

         // The final product will look like this:

         //   right(mid(newArrayLeft(24, x0..x9), x10..x19), x20..x23)

         if (midLen == LEFT_ARGS)

             return rightFill;

         else

             return MethodHandles.collectArguments(rightFill, 0, midFill);

     }

     // Type-polymorphic version of varargs maker.

     private static final ClassValue<MethodHandle[]> TYPED_COLLECTORS

         = new ClassValue<MethodHandle[]>() {

             @Override

             protected MethodHandle[] computeValue(Class<?> type) {

                 return new MethodHandle[256];

             }

     };

     static final int MAX_JVM_ARITY = 255;  // limit imposed by the JVM

     /** Return a method handle that takes the indicated number of

      *  typed arguments and returns an array of them.

      *  The type argument is the array type.

      */

     public static MethodHandle varargsArray(Class<?> arrayType, int nargs) {

         Class<?> elemType = arrayType.getComponentType();

         if (elemType == null)  throw new IllegalArgumentException("not an array: "+arrayType);

         // FIXME: Need more special casing and caching here.

         if (nargs >= MAX_JVM_ARITY/2 - 1) {

             int slots = nargs;

             final int MAX_ARRAY_SLOTS = MAX_JVM_ARITY - 1;  // 1 for receiver MH

             if (arrayType == double[].class || arrayType == long[].class)

                 slots *= 2;

             if (slots > MAX_ARRAY_SLOTS)

                 throw new IllegalArgumentException("too many arguments: "+arrayType.getSimpleName()+", length "+nargs);

         }

         if (elemType == Object.class)

             return varargsArray(nargs);

         // other cases:  primitive arrays, subtypes of Object[]

         MethodHandle cache[] = TYPED_COLLECTORS.get(elemType);

         MethodHandle mh = nargs < cache.length ? cache[nargs] : null;

         if (mh != null)  return mh;

         if (elemType.isPrimitive()) {

             MethodHandle builder = FILL_NEW_ARRAY;

             MethodHandle producer = buildArrayProducer(arrayType);

             mh = buildVarargsArray(builder, producer, nargs);

         } else {

             @SuppressWarnings("unchecked")

             Class<? extends Object[]> objArrayType = (Class<? extends Object[]>) arrayType;

             Object[] example = Arrays.copyOf(NO_ARGS_ARRAY, 0, objArrayType);

             MethodHandle builder = FILL_NEW_TYPED_ARRAY.bindTo(example);

             MethodHandle producer = ARRAY_IDENTITY;

             mh = buildVarargsArray(builder, producer, nargs);

         }

         mh = mh.asType(MethodType.methodType(arrayType, Collections.<Class<?>>nCopies(nargs, elemType)));

         assert(assertCorrectArity(mh, nargs));

         if (nargs < cache.length)

             cache[nargs] = mh;

         return mh;

     }

     private static MethodHandle buildArrayProducer(Class<?> arrayType) {

         Class<?> elemType = arrayType.getComponentType();

         if (elemType.isPrimitive())

             return LazyStatics.COPY_AS_PRIMITIVE_ARRAY.bindTo(Wrapper.forPrimitiveType(elemType));

         else

             return LazyStatics.COPY_AS_REFERENCE_ARRAY.bindTo(arrayType);

     }

     // List version of varargs maker.

     private static final List<Object> NO_ARGS_LIST = Arrays.asList(NO_ARGS_ARRAY);

     private static List<Object> makeList(Object... args) { return Arrays.asList(args); }

     private static List<Object> list() { return NO_ARGS_LIST; }

     private static List<Object> list(Object a0)

                 { return makeList(a0); }

     private static List<Object> list(Object a0, Object a1)

                 { return makeList(a0, a1); }

     private static List<Object> list(Object a0, Object a1, Object a2)

                 { return makeList(a0, a1, a2); }

     private static List<Object> list(Object a0, Object a1, Object a2, Object a3)

                 { return makeList(a0, a1, a2, a3); }

     private static List<Object> list(Object a0, Object a1, Object a2, Object a3,

                                      Object a4)

                 { return makeList(a0, a1, a2, a3, a4); }

     private static List<Object> list(Object a0, Object a1, Object a2, Object a3,

                                      Object a4, Object a5)

                 { return makeList(a0, a1, a2, a3, a4, a5); }

     private static List<Object> list(Object a0, Object a1, Object a2, Object a3,

                                      Object a4, Object a5, Object a6)

                 { return makeList(a0, a1, a2, a3, a4, a5, a6); }

     private static List<Object> list(Object a0, Object a1, Object a2, Object a3,

                                      Object a4, Object a5, Object a6, Object a7)

                 { return makeList(a0, a1, a2, a3, a4, a5, a6, a7); }

     private static List<Object> list(Object a0, Object a1, Object a2, Object a3,

                                      Object a4, Object a5, Object a6, Object a7,

                                      Object a8)

                 { return makeList(a0, a1, a2, a3, a4, a5, a6, a7, a8); }

     private static List<Object> list(Object a0, Object a1, Object a2, Object a3,

                                      Object a4, Object a5, Object a6, Object a7,

                                      Object a8, Object a9)

                 { return makeList(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }

     private static MethodHandle[] makeLists() {

         ArrayList<MethodHandle> mhs = new ArrayList<>();

         for (;;) {

             MethodHandle mh = findCollector("list", mhs.size(), List.class);

             if (mh == null)  break;

             mhs.add(mh);

         }

         assert(mhs.size() == 11);  // current number of methods

         return mhs.toArray(new MethodHandle[MAX_ARITY+1]);

     }

     private static final MethodHandle[] LISTS = makeLists();

     /** Return a method handle that takes the indicated number of Object

      *  arguments and returns a List.

      */

     public static MethodHandle varargsList(int nargs) {

         MethodHandle mh = LISTS[nargs];

         if (mh != null)  return mh;

         mh = findCollector("list", nargs, List.class);

         if (mh != null)  return LISTS[nargs] = mh;

         return LISTS[nargs] = buildVarargsList(nargs);

     }

     private static MethodHandle buildVarargsList(int nargs) {

         return MethodHandles.filterReturnValue(varargsArray(nargs), LazyStatics.MAKE_LIST);

     }

     // handy shared exception makers (they simplify the common case code)

     private static InternalError newInternalError(String message, Throwable cause) {

         return new InternalError(message, cause);

     }

     private static InternalError newInternalError(Throwable cause) {

         return new InternalError(cause);

     }

 }