*** old/src/share/classes/java/lang/invoke/MethodHandleImpl.java	Mon Mar 24 20:12:13 2014
--- new/src/share/classes/java/lang/invoke/MethodHandleImpl.java	Mon Mar 24 20:12:13 2014

*** 95,117 ****
--- 95,111 ----
          static void    setElementL(Object[]  a, int i, Object  x) {              a[i] = x; }
  
          static Object  getElementL(Class<?> arrayClass, Object[] a, int i)           { arrayClass.cast(a); return a[i]; }
          static void    setElementL(Class<?> arrayClass, Object[] a, int i, Object x) { arrayClass.cast(a); a[i] = x; }
  
          // Weakly typed wrappers of Object[] accessors:
          static Object  getElementL(Object    a, int i)            { return getElementL((Object[])a, i); }
          static void    setElementL(Object    a, int i, Object  x) {        setElementL((Object[]) a, i, x); }
          static Object  getElementL(Object   arrayClass, Object a, int i)             { return getElementL((Class<?>) arrayClass, (Object[])a, i); }
          static void    setElementL(Object   arrayClass, Object a, int i, Object x)   {        setElementL((Class<?>) arrayClass, (Object[])a, i, x); }
  
          static boolean needCast(Class<?> arrayClass) {
              Class<?> elemClass = arrayClass.getComponentType();
              return !elemClass.isPrimitive() && elemClass != Object.class;
          }
          static String name(Class<?> arrayClass, boolean isSetter) {
              Class<?> elemClass = arrayClass.getComponentType();
!             if (elemClass == null)  throw new IllegalArgumentException();
!             if (elemClass == null)  throw newIllegalArgumentException("not an array", arrayClass);
              return (!isSetter ? "getElement" : "setElement") + Wrapper.basicTypeChar(elemClass);
          }
          static final boolean USE_WEAKLY_TYPED_ARRAY_ACCESSORS = false;  // FIXME: decide
          static MethodType type(Class<?> arrayClass, boolean isSetter) {
              Class<?> elemClass = arrayClass.getComponentType();

*** 177,200 ****
--- 171,199 ----
          int conversions = 0;
          boolean[] needConv = new boolean[1+INARG_COUNT];
          for (int i = 0; i <= INARG_COUNT; i++) {
              Class<?> src = (i == INARG_COUNT) ? dstType.returnType() : srcType.parameterType(i);
              Class<?> dst = (i == INARG_COUNT) ? srcType.returnType() : dstType.parameterType(i);
!             if (!VerifyType.isNullConversion(src, dst, false) ||
                  level <= 1 && dst.isInterface() && !dst.isAssignableFrom(src)) {
                  needConv[i] = true;
                  conversions++;
              }
          }
          boolean retConv = needConv[INARG_COUNT];
+         if (retConv && srcType.returnType() == void.class) {
+             retConv = false;
+             conversions--;
+         }
  
          final int IN_MH         = 0;
          final int INARG_BASE    = 1;
          final int INARG_LIMIT   = INARG_BASE + INARG_COUNT;
          final int NAME_LIMIT    = INARG_LIMIT + conversions + 1;
          final int RETURN_CONV   = (!retConv ? -1         : NAME_LIMIT - 1);
          final int OUT_CALL      = (!retConv ? NAME_LIMIT : RETURN_CONV) - 1;
+         final int RESULT        = (srcType.returnType() == void.class ? -1 : NAME_LIMIT - 1);
  
          // Now build a LambdaForm.
          MethodType lambdaType = srcType.basicType().invokerType();
          Name[] names = arguments(NAME_LIMIT - INARG_LIMIT, lambdaType);
  

*** 228,238 ****
--- 227,237 ----
                  }
              } else {
                  if (dst.isPrimitive()) {
                      // Caller has boxed a primitive.  Unbox it for the target.
                      Wrapper w = Wrapper.forPrimitiveType(dst);
!                     if (level == 0 || VerifyType.isNullConversion(src, w.wrapperType(), false)) {
                          fn = ValueConversions.unbox(dst);
                      } else if (src == Object.class || !Wrapper.isWrapperType(src)) {
                          // Examples:  Object->int, Number->int, Comparable->int; Byte->int, Character->int
                          // must include additional conversions
                          // src must be examined at runtime, to detect Byte, Character, etc.

*** 287,297 ****
--- 286,296 ----
              assert(names[RETURN_CONV] == null);
              names[RETURN_CONV] = new Name(fn, arg);
              assert(RETURN_CONV == names.length-1);
          }
  
!         LambdaForm form = new LambdaForm("convert", lambdaType.parameterCount(), names, RESULT);
          return SimpleMethodHandle.make(srcType, form);
      }
  
      /**
       * Identity function, with reference cast.