Mercurial > hg > openjdk > jdk7 > jdk
changeset 4289:1f39ca0b9598
Merge
| author | mullan |
|---|---|
| date | Sat, 04 Jun 2011 06:52:01 -0700 |
| parents | 49aef5a5416e (current diff) 53d759eb580c (diff) |
| children | 1e04b38b3824 6e961c328276 |
| files | |
| diffstat | 93 files changed, 2299 insertions(+), 1377 deletions(-) [+] |
line wrap: on
line diff
--- a/.hgtags Sat Jun 04 06:45:17 2011 -0700 +++ b/.hgtags Sat Jun 04 06:52:01 2011 -0700 @@ -118,3 +118,4 @@ 63eeefe118da18c75ba3d36266768cd1ccaaca6b jdk7-b141 312612e89ece62633f4809706dec00bcd5fe7c2d jdk7-b142 efbf75c24b0f31847c9c403f6dc07dc80551908d jdk7-b143 +23bdcede4e3945894574892e80b848bd9f15b5f3 jdk7-b144
--- a/make/common/Defs-embedded.gmk Sat Jun 04 06:45:17 2011 -0700 +++ b/make/common/Defs-embedded.gmk Sat Jun 04 06:52:01 2011 -0700 @@ -49,5 +49,16 @@ JRE_REDUCED_HEADLESS_IMAGE_DIR = $(ABS_OUTPUTDIR)/j2re-reduced-headless-image JRE_REDUCED_IMAGE_DIR = $(ABS_OUTPUTDIR)/j2re-reduced-image +# Override on linux to further reduce binary/lib sizes in product build +ifeq ($(PLATFORM), linux) + ifeq ($(VARIANT), OPT) + ifneq ($(NO_STRIP), true) + ifneq ($(DEBUG_BINARIES), true) + POST_STRIP_PROCESS = $(STRIP) --strip-unneeded + endif + endif + endif +endif + endif # JAVASE_EMBEDDED
--- a/make/common/Release-embedded.gmk Sat Jun 04 06:45:17 2011 -0700 +++ b/make/common/Release-embedded.gmk Sat Jun 04 06:52:01 2011 -0700 @@ -53,25 +53,30 @@ $(RM) $(HEADLESS_CLASSLIST) $(RM) $(NOT_HEADLESS_RT_JAR_LIST) $(CP) $(NOT_RT_JAR_LIST) $(NOT_HEADLESS_RT_JAR_LIST) +# List all the packages to be excluded $(ECHO) "sun/awt/motif/" >> $@ $(ECHO) "sun/awt/X11/" >> $@ $(ECHO) "sun/applet/" >> $@ $(ECHO) "sun/java2d/opengl/" >> $@ $(ECHO) "com/sun/java/swing/plaf/" >> $@ - $(ECHO) "sun/awt/motif/MFontConfiguration" >$(HEADLESS_CLASSLIST) - $(ECHO) "sun/applet/AppContextCreator" >>$(HEADLESS_CLASSLIST) - $(ECHO) "sun/applet/AppletAudioClip" >>$(HEADLESS_CLASSLIST) - $(ECHO) "sun/java2d/opengl/GLXSurfaceData" >>$(HEADLESS_CLASSLIST) - $(ECHO) "sun/java2d/opengl/GLXSurfaceData"\$$"GLXOffScreenSurfaceData" >>$(HEADLESS_CLASSLIST) - $(ECHO) "sun/java2d/opengl/GLXVolatileSurfaceManager" >>$(HEADLESS_CLASSLIST) - $(ECHO) "sun/java2d/opengl/OGLSurfaceData" >>$(HEADLESS_CLASSLIST) +# List all the individual classes to be included + $(ECHO) "sun/awt/motif/MFontConfiguration.class" >$(HEADLESS_CLASSLIST) + $(ECHO) "sun/applet/AppContextCreator.class" >>$(HEADLESS_CLASSLIST) + $(ECHO) "sun/applet/AppletAudioClip.class" >>$(HEADLESS_CLASSLIST) + $(ECHO) "sun/java2d/opengl/GLXSurfaceData.class" >>$(HEADLESS_CLASSLIST) + $(ECHO) "sun/java2d/opengl/GLXSurfaceData"\$$"GLXOffScreenSurfaceData.class" >>$(HEADLESS_CLASSLIST) + $(ECHO) "sun/java2d/opengl/GLXVolatileSurfaceManager.class" >>$(HEADLESS_CLASSLIST) + $(ECHO) "sun/java2d/opengl/OGLSurfaceData.class" >>$(HEADLESS_CLASSLIST) + $(TOTAL_HEADLESS_JAR_FILELIST): $(JARREORDER_JARFILE) $(NOT_HEADLESS_RT_JAR_LIST) $(prep-target) $(RM) $@.temp $(CD) $(CLASSBINDIR) ; \ $(BOOT_JAVA_CMD) -jar $(JARREORDER_JARFILE) \ - -o $@.temp $(HEADLESS_CLASSLIST) $(NOT_HEADLESS_RT_JAR_LIST) . + -o $@.temp - $(NOT_HEADLESS_RT_JAR_LIST) . +# Add on the explicitly included class files from the otherwise excluded packages + $(CAT) $(HEADLESS_CLASSLIST) >> $@.temp $(MV) $@.temp $@ @$(CD) $(CLASSBINDIR); $(java-vm-cleanup) @@ -124,13 +129,9 @@ $(LIBARCH)/libjavaplugin_nscp.so \ $(LIBARCH)/libjavaplugin_oji.so - -ifeq ($(PLATFORM), linux) - STRIP_OPTS = --strip-unneeded -else - STRIP_OPTS = -x -endif - +# JRE docs that don't get included in reduced jre image top directory +NOT_REDUCEDJRE_DOC = \ + Welcome.html reduced-image-jre:: @$(ECHO) Starting to Produce Reduced JRE @@ -142,12 +143,6 @@ $(CD) $(JRE_IMAGE_DIR); \ $(TAR) cf - . | ($(CD) $(JRE_REDUCED_IMAGE_DIR); $(TAR) xf - ); - @# strip the main .so files - $(STRIP) $(STRIP_OPTS) $(JRE_REDUCED_IMAGE_DIR)/lib/$(LIBARCH)/client/libjvm.so -ifndef BUILD_CLIENT_ONLY - $(STRIP) $(STRIP_OPTS) $(JRE_REDUCED_IMAGE_DIR)/lib/$(LIBARCH)/server/libjvm.so -endif - @# @# Remove all of the files that are not needed for the @# reduced JRE @@ -158,6 +153,9 @@ for l in $(NOT_REDUCEDJRE_LIB) ; do \ $(RM) $(JRE_REDUCED_IMAGE_DIR)/lib/$$l ; \ done + for l in $(NOT_REDUCEDJRE_DOC) ; do \ + $(RM) $(JRE_REDUCED_IMAGE_DIR)/$$l ; \ + done @# Remove misc. other files $(RM) -r $(JRE_REDUCED_IMAGE_DIR)/man
--- a/src/linux/doc/man/ja/keytool.1 Sat Jun 04 06:45:17 2011 -0700 +++ b/src/linux/doc/man/ja/keytool.1 Sat Jun 04 06:52:01 2011 -0700 @@ -1,4 +1,4 @@ -." Copyright (c) 1998-2011 keytool tool, Oracle and/or its affiliates. All rights reserved. +." Copyright (c) 1998, 2011, 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
--- a/src/linux/doc/man/keytool.1 Sat Jun 04 06:45:17 2011 -0700 +++ b/src/linux/doc/man/keytool.1 Sat Jun 04 06:52:01 2011 -0700 @@ -1,4 +1,4 @@ -." Copyright (c) 1998-2011 keytool tool, Oracle and/or its affiliates. All rights reserved. +." Copyright (c) 1998, 2011, 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
--- a/src/share/classes/com/sun/java/swing/plaf/gtk/resources/gtk.properties Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/com/sun/java/swing/plaf/gtk/resources/gtk.properties Sat Jun 04 06:52:01 2011 -0700 @@ -56,9 +56,9 @@ FileChooser.renameFileButtonText=Rename File FileChooser.renameFileButtonMnemonic=82 FileChooser.cancelButtonText=Cancel -#FileChooser.cancelButtonMnemonic=67 +FileChooser.cancelButtonMnemonic=67 FileChooser.saveButtonText=OK -#FileChooser.saveButtonMnemonic=79 +FileChooser.saveButtonMnemonic=79 FileChooser.openButtonText=OK FileChooser.openButtonMnemonic=79 FileChooser.saveDialogTitleText=Save @@ -79,5 +79,5 @@ FileChooser.renameFileErrorTitle=Error FileChooser.renameFileErrorText=Error renaming file "{0}" to "{1}" -#OptionPane.okButtonMnemonic=79 -#OptionPane.cancelButtonMnemonic=67 +OptionPane.okButtonMnemonic=79 +OptionPane.cancelButtonMnemonic=67
--- a/src/share/classes/java/awt/Toolkit.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/java/awt/Toolkit.java Sat Jun 04 06:52:01 2011 -0700 @@ -1857,7 +1857,7 @@ /** * Adds the specified property change listener for the named desktop - * property. When a {@link PropertyChangeListenerProxy} object is added, + * property. When a {@link java.beans.PropertyChangeListenerProxy} object is added, * its property name is ignored, and the wrapped listener is added. * If {@code name} is {@code null} or {@code pcl} is {@code null}, * no exception is thrown and no action is performed. @@ -1874,7 +1874,7 @@ /** * Removes the specified property change listener for the named - * desktop property. When a {@link PropertyChangeListenerProxy} object + * desktop property. When a {@link java.beans.PropertyChangeListenerProxy} object * is removed, its property name is ignored, and * the wrapped listener is removed. * If {@code name} is {@code null} or {@code pcl} is {@code null}, @@ -1893,11 +1893,11 @@ /** * Returns an array of all the property change listeners * registered on this toolkit. The returned array - * contains {@code PropertyChangeListenerProxy} objects + * contains {@link java.beans.PropertyChangeListenerProxy} objects * that associate listeners with the names of desktop properties. * - * @return all of this toolkit's {@ code PropertyChangeListener} - * objects wrapped in {@code PropertyChangeListenerProxy} objects + * @return all of this toolkit's {@link PropertyChangeListener} + * objects wrapped in {@code java.beans.PropertyChangeListenerProxy} objects * or an empty array if no listeners are added * * @see PropertyChangeSupport#getPropertyChangeListeners()
--- a/src/share/classes/java/io/SerialCallbackContext.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/java/io/SerialCallbackContext.java Sat Jun 04 06:52:01 2011 -0700 @@ -1,7 +1,5 @@ /* - * %W% %E% - * - * Copyright (c) 2006, 2010 Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */
--- a/src/share/classes/java/lang/BootstrapMethodError.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/java/lang/BootstrapMethodError.java Sat Jun 04 06:52:01 2011 -0700 @@ -39,14 +39,14 @@ private static final long serialVersionUID = 292L; /** - * Constructs an {@code BootstrapMethodError} with no detail message. + * Constructs a {@code BootstrapMethodError} with no detail message. */ public BootstrapMethodError() { super(); } /** - * Constructs an {@code BootstrapMethodError} with the specified + * Constructs a {@code BootstrapMethodError} with the specified * detail message. * * @param s the detail message.
--- a/src/share/classes/java/lang/ClassValue.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/java/lang/ClassValue.java Sat Jun 04 06:52:01 2011 -0700 @@ -39,6 +39,13 @@ */ public abstract class ClassValue<T> { /** + * Sole constructor. (For invocation by subclass constructors, typically + * implicit.) + */ + protected ClassValue() { + } + + /** * Computes the given class's derived value for this {@code ClassValue}. * <p> * This method will be invoked within the first thread that accesses @@ -100,7 +107,7 @@ * If this value is subsequently {@linkplain #get read} for the same class, * its value will be reinitialized by invoking its {@link #computeValue computeValue} method. * This may result in an additional invocation of the - * {@code computeValue computeValue} method for the given class. + * {@code computeValue} method for the given class. * <p> * In order to explain the interaction between {@code get} and {@code remove} calls, * we must model the state transitions of a class value to take into account @@ -193,6 +200,7 @@ = new WeakHashMap<Class<?>, ClassValueMap>(); private static ClassValueMap getMap(Class<?> type) { + type.getClass(); // test for null return ROOT.get(type); }
--- a/src/share/classes/java/lang/invoke/AdapterMethodHandle.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/java/lang/invoke/AdapterMethodHandle.java Sat Jun 04 06:52:01 2011 -0700 @@ -29,6 +29,8 @@ import sun.invoke.util.Wrapper; import sun.invoke.util.ValueConversions; import java.util.Arrays; +import java.util.ArrayList; +import java.util.Collections; import static java.lang.invoke.MethodHandleNatives.Constants.*; import static java.lang.invoke.MethodHandleStatics.*; @@ -62,7 +64,7 @@ // the target and change its type, instead of adding another layer. /** Can a JVM-level adapter directly implement the proposed - * argument conversions, as if by MethodHandles.convertArguments? + * argument conversions, as if by fixed-arity MethodHandle.asType? */ static boolean canPairwiseConvert(MethodType newType, MethodType oldType, int level) { // same number of args, of course @@ -92,7 +94,7 @@ } /** Can a JVM-level adapter directly implement the proposed - * argument conversion, as if by MethodHandles.convertArguments? + * argument conversion, as if by fixed-arity MethodHandle.asType? */ static boolean canConvertArgument(Class<?> src, Class<?> dst, int level) { // ? Retool this logic to use RETYPE_ONLY, CHECK_CAST, etc., as opcodes, @@ -141,7 +143,7 @@ while (lastConv >= 0) { Class<?> src = newType.parameterType(lastConv); // source type Class<?> dst = oldType.parameterType(lastConv); // destination type - if (VerifyType.isNullConversion(src, dst)) { + if (isTrivialConversion(src, dst, level)) { --lastConv; } else { break; @@ -150,7 +152,7 @@ Class<?> needReturn = newType.returnType(); Class<?> haveReturn = oldType.returnType(); - boolean retConv = !VerifyType.isNullConversion(haveReturn, needReturn); + boolean retConv = !isTrivialConversion(haveReturn, needReturn, level); // Now build a chain of one or more adapters. MethodHandle adapter = target, adapter2; @@ -158,7 +160,7 @@ for (int i = 0; i <= lastConv; i++) { Class<?> src = newType.parameterType(i); // source type Class<?> dst = midType.parameterType(i); // destination type - if (VerifyType.isNullConversion(src, dst)) { + if (isTrivialConversion(src, dst, level)) { // do nothing: difference is trivial continue; } @@ -219,6 +221,22 @@ return adapter; } + private static boolean isTrivialConversion(Class<?> src, Class<?> dst, int level) { + if (src == dst || dst == void.class) return true; + if (!VerifyType.isNullConversion(src, dst)) return false; + if (level > 1) return true; // explicitCastArguments + boolean sp = src.isPrimitive(); + boolean dp = dst.isPrimitive(); + if (sp != dp) return false; + if (sp) { + // in addition to being a null conversion, forbid boolean->int etc. + return Wrapper.forPrimitiveType(dst) + .isConvertibleFrom(Wrapper.forPrimitiveType(src)); + } else { + return dst.isAssignableFrom(src); + } + } + private static MethodHandle makeReturnConversion(MethodHandle target, Class<?> haveReturn, Class<?> needReturn) { MethodHandle adjustReturn; if (haveReturn == void.class) { @@ -530,6 +548,11 @@ } 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)); + target = target.asFixedArity(); // make sure this attribute is turned off return new AsVarargsCollector(target, arrayType); } @@ -551,6 +574,11 @@ } @Override + public MethodHandle asFixedArity() { + return target; + } + + @Override public MethodHandle asType(MethodType newType) { MethodType type = this.type(); int collectArg = type.parameterCount() - 1; @@ -574,14 +602,6 @@ cache = collector; return collector.asType(newType); } - - @Override - public MethodHandle asVarargsCollector(Class<?> arrayType) { - MethodType type = this.type(); - if (type.parameterType(type.parameterCount()-1) == arrayType) - return this; - return super.asVarargsCollector(arrayType); - } } /** Can a checkcast adapter validly convert the target to newType? @@ -596,7 +616,7 @@ || !VerifyType.isNullConversion(castType, dst)) return false; int diff = diffTypes(newType, targetType, false); - return (diff == arg+1); // arg is sole non-trivial diff + return (diff == arg+1) || (diff == 0); // arg is sole non-trivial diff } /** Can an primitive conversion adapter validly convert src to dst? */ static boolean canCheckCast(Class<?> src, Class<?> dst) { @@ -727,8 +747,31 @@ if (!canUnboxArgument(newType, oldType, arg, convType, level)) return null; MethodType castDone = newType; - if (!VerifyType.isNullConversion(src, boxType)) + if (!VerifyType.isNullConversion(src, boxType)) { + // Examples: Object->int, Number->int, Comparable->int; Byte->int, Character->int + if (level != 0) { + // must include additional conversions + if (src == Object.class || !Wrapper.isWrapperType(src)) { + // src must be examined at runtime, to detect Byte, Character, etc. + MethodHandle unboxMethod = (level == 1 + ? ValueConversions.unbox(dst) + : ValueConversions.unboxCast(dst)); + long conv = makeConv(OP_COLLECT_ARGS, arg, basicType(src), basicType(dst)); + return new AdapterMethodHandle(target, newType, conv, unboxMethod); + } + // Example: Byte->int + // Do this by reformulating the problem to Byte->byte. + Class<?> srcPrim = Wrapper.forWrapperType(src).primitiveType(); + MethodType midType = newType.changeParameterType(arg, srcPrim); + MethodHandle fixPrim; // makePairwiseConvert(midType, target, 0); + if (canPrimCast(midType, oldType, arg, dst)) + fixPrim = makePrimCast(midType, target, arg, dst); + else + fixPrim = target; + return makeUnboxArgument(newType, fixPrim, arg, srcPrim, 0); + } castDone = newType.changeParameterType(arg, boxType); + } long conv = makeConv(OP_REF_TO_PRIM, arg, T_OBJECT, basicType(primType)); MethodHandle adapter = new AdapterMethodHandle(target, castDone, conv, boxType); if (castDone == newType) @@ -897,6 +940,20 @@ if (swapArg1 == swapArg2) return target; if (swapArg1 > swapArg2) { int t = swapArg1; swapArg1 = swapArg2; swapArg2 = t; } + if (type2size(newType.parameterType(swapArg1)) != + type2size(newType.parameterType(swapArg2))) { + // turn a swap into a pair of rotates: + // [x a b c y] => [a b c y x] => [y a b c x] + int argc = swapArg2 - swapArg1 + 1; + final int ROT = 1; + ArrayList<Class<?>> rot1Params = new ArrayList<Class<?>>(target.type().parameterList()); + Collections.rotate(rot1Params.subList(swapArg1, swapArg1 + argc), -ROT); + MethodType rot1Type = MethodType.methodType(target.type().returnType(), rot1Params); + MethodHandle rot1 = makeRotateArguments(rot1Type, target, swapArg1, argc, +ROT); + if (argc == 2) return rot1; + MethodHandle rot2 = makeRotateArguments(newType, rot1, swapArg1, argc-1, -ROT); + return rot2; + } if (!canSwapArguments(newType, target.type(), swapArg1, swapArg2)) return null; Class<?> swapType = newType.parameterType(swapArg1); @@ -926,7 +983,6 @@ static boolean canRotateArguments(MethodType newType, MethodType targetType, int firstArg, int argCount, int rotateBy) { if (!convOpSupported(OP_ROT_ARGS)) return false; - if (argCount <= 2) return false; // must be a swap, not a rotate rotateBy = positiveRotation(argCount, rotateBy); if (rotateBy == 0) return false; // no rotation if (rotateBy > MAX_ARG_ROTATION && rotateBy < argCount - MAX_ARG_ROTATION) @@ -972,6 +1028,7 @@ // From here on out, it assumes a single-argument shift. assert(MAX_ARG_ROTATION == 1); int srcArg, dstArg; + int dstSlot; byte basicType; if (chunk2Slots <= chunk1Slots) { // Rotate right/down N (rotateBy = +N, N small, c2 small): @@ -979,6 +1036,7 @@ // out arglist: [0: ...keep1 | arg1: c2 | arg1+N: c1... | limit: keep2... ] srcArg = limit-1; dstArg = firstArg; + dstSlot = depth0 - chunk2Slots; basicType = basicType(newType.parameterType(srcArg)); assert(chunk2Slots == type2size(basicType)); } else { @@ -987,10 +1045,10 @@ // out arglist: [0: ...keep1 | arg1: c2 ... | limit-N: c1 | limit: keep2... ] srcArg = firstArg; dstArg = limit-1; + dstSlot = depth2; basicType = basicType(newType.parameterType(srcArg)); assert(chunk1Slots == type2size(basicType)); } - int dstSlot = newType.parameterSlotDepth(dstArg + 1); long conv = makeSwapConv(OP_ROT_ARGS, srcArg, basicType, dstSlot); return new AdapterMethodHandle(target, newType, conv); } @@ -1033,8 +1091,9 @@ Class<?> spreadArgType, int spreadArgPos, int spreadArgCount) { // FIXME: Get rid of newType; derive new arguments from structure of spreadArgType MethodType targetType = target.type(); - if (!canSpreadArguments(newType, targetType, spreadArgType, spreadArgPos, spreadArgCount)) - return null; + assert(canSpreadArguments(newType, targetType, spreadArgType, spreadArgPos, spreadArgCount)) + : "[newType, targetType, spreadArgType, spreadArgPos, spreadArgCount] = " + + Arrays.asList(newType, targetType, spreadArgType, spreadArgPos, spreadArgCount); // dest is not significant; remove? int dest = T_VOID; for (int i = 0; i < spreadArgCount; i++) { @@ -1127,7 +1186,7 @@ } @Override - public String toString() { + String debugString() { return getNameString(nonAdapter((MethodHandle)vmtarget), this); }
--- a/src/share/classes/java/lang/invoke/BoundMethodHandle.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/java/lang/invoke/BoundMethodHandle.java Sat Jun 04 06:52:01 2011 -0700 @@ -151,11 +151,11 @@ final static RuntimeException badBoundArgumentException(Object argument, MethodHandle mh, int argnum) { String atype = (argument == null) ? "null" : argument.getClass().toString(); - return new WrongMethodTypeException("cannot bind "+atype+" argument to parameter #"+argnum+" of "+mh.type()); + return new ClassCastException("cannot bind "+atype+" argument to parameter #"+argnum+" of "+mh.type()); } @Override - public String toString() { + String debugString() { return addTypeString(baseName(), this); }
--- a/src/share/classes/java/lang/invoke/CallSite.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/java/lang/invoke/CallSite.java Sat Jun 04 06:52:01 2011 -0700 @@ -111,7 +111,7 @@ } /** - * Make a blank call site object, possibly equipped with an initial target method handle. + * Make a call site object equipped with an initial target method handle. * @param target the method handle which will be the initial target of the call site * @throws NullPointerException if the proposed target is null */ @@ -122,6 +122,25 @@ } /** + * Make a call site object equipped with an initial target method handle. + * @param targetType the desired type of the call site + * @param createTargetHook a hook which will bind the call site to the target method handle + * @throws WrongMethodTypeException if the hook cannot be invoked on the required arguments, + * or if the target returned by the hook is not of the given {@code targetType} + * @throws NullPointerException if the hook returns a null value + * @throws ClassCastException if the hook returns something other than a {@code MethodHandle} + * @throws Throwable anything else thrown by the the hook function + */ + /*package-private*/ + CallSite(MethodType targetType, MethodHandle createTargetHook) throws Throwable { + this(targetType); + ConstantCallSite selfCCS = (ConstantCallSite) this; + MethodHandle boundTarget = (MethodHandle) createTargetHook.invokeWithArguments(selfCCS); + checkTargetChange(this.target, boundTarget); + this.target = boundTarget; + } + + /** * Returns the type of this call site's target. * Although targets may change, any call site's type is permanent, and can never change to an unequal type. * The {@code setTarget} method enforces this invariant by refusing any new target that does @@ -129,6 +148,7 @@ * @return the type of the current target, which is also the type of any future target */ public MethodType type() { + // warning: do not call getTarget here, because CCS.getTarget can throw IllegalStateException return target.type(); } @@ -294,8 +314,8 @@ } else { throw new ClassCastException("bootstrap method failed to produce a CallSite"); } - assert(site.getTarget() != null); - assert(site.getTarget().type().equals(type)); + if (!site.getTarget().type().equals(type)) + throw new WrongMethodTypeException("wrong type: "+site.getTarget()); } catch (Throwable ex) { BootstrapMethodError bex; if (ex instanceof BootstrapMethodError)
--- a/src/share/classes/java/lang/invoke/ConstantCallSite.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/java/lang/invoke/ConstantCallSite.java Sat Jun 04 06:52:01 2011 -0700 @@ -32,6 +32,8 @@ * @author John Rose, JSR 292 EG */ public class ConstantCallSite extends CallSite { + private final boolean isFrozen; + /** * Creates a call site with a permanent target. * @param target the target to be permanently associated with this call site @@ -39,6 +41,45 @@ */ public ConstantCallSite(MethodHandle target) { super(target); + isFrozen = true; + } + + /** + * Creates a call site with a permanent target, possibly bound to the call site itself. + * <p> + * During construction of the call site, the {@code createTargetHook} is invoked to + * produce the actual target, as if by a call of the form + * {@code (MethodHandle) createTargetHook.invoke(this)}. + * <p> + * Note that user code cannot perform such an action directly in a subclass constructor, + * since the target must be fixed before the {@code ConstantCallSite} constructor returns. + * <p> + * The hook is said to bind the call site to a target method handle, + * and a typical action would be {@code someTarget.bindTo(this)}. + * However, the hook is free to take any action whatever, + * including ignoring the call site and returning a constant target. + * <p> + * The result returned by the hook must be a method handle of exactly + * the same type as the call site. + * <p> + * While the hook is being called, the new {@code ConstantCallSite} + * object is in a partially constructed state. + * In this state, + * a call to {@code getTarget}, or any other attempt to use the target, + * will result in an {@code IllegalStateException}. + * It is legal at all times to obtain the call site's type using the {@code type} method. + * + * @param targetType the type of the method handle to be permanently associated with this call site + * @param createTargetHook a method handle to invoke (on the call site) to produce the call site's target + * @throws WrongMethodTypeException if the hook cannot be invoked on the required arguments, + * or if the target returned by the hook is not of the given {@code targetType} + * @throws NullPointerException if the hook returns a null value + * @throws ClassCastException if the hook returns something other than a {@code MethodHandle} + * @throws Throwable anything else thrown by the the hook function + */ + protected ConstantCallSite(MethodType targetType, MethodHandle createTargetHook) throws Throwable { + super(targetType, createTargetHook); + isFrozen = true; } /** @@ -48,9 +89,10 @@ * to the constructor call which created this instance. * * @return the immutable linkage state of this call site, a constant method handle - * @throws UnsupportedOperationException because this kind of call site cannot change its target + * @throws IllegalStateException if the {@code ConstantCallSite} constructor has not completed */ @Override public final MethodHandle getTarget() { + if (!isFrozen) throw new IllegalStateException(); return target; } @@ -61,7 +103,7 @@ * @throws UnsupportedOperationException because this kind of call site cannot change its target */ @Override public final void setTarget(MethodHandle ignore) { - throw new UnsupportedOperationException("ConstantCallSite"); + throw new UnsupportedOperationException(); } /** @@ -69,6 +111,7 @@ * Since that target will never change, this is a correct implementation * of {@link CallSite#dynamicInvoker CallSite.dynamicInvoker}. * @return the immutable linkage state of this call site, a constant method handle + * @throws IllegalStateException if the {@code ConstantCallSite} constructor has not completed */ @Override public final MethodHandle dynamicInvoker() {
--- a/src/share/classes/java/lang/invoke/FilterGeneric.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/java/lang/invoke/FilterGeneric.java Sat Jun 04 06:52:01 2011 -0700 @@ -234,7 +234,7 @@ protected final MethodHandle target; // ultimate target @Override - public String toString() { + String debugString() { return addTypeString(target, this); }
--- a/src/share/classes/java/lang/invoke/FilterOneArgument.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/java/lang/invoke/FilterOneArgument.java Sat Jun 04 06:52:01 2011 -0700 @@ -41,7 +41,7 @@ protected final MethodHandle target; // Object -> Object @Override - public String toString() { + String debugString() { return target.toString(); }
--- a/src/share/classes/java/lang/invoke/FromGeneric.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/java/lang/invoke/FromGeneric.java Sat Jun 04 06:52:01 2011 -0700 @@ -260,7 +260,7 @@ protected final MethodHandle target; // (any**N) => R @Override - public String toString() { + String debugString() { return addTypeString(target, this); }
--- a/src/share/classes/java/lang/invoke/InvokeGeneric.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/java/lang/invoke/InvokeGeneric.java Sat Jun 04 06:52:01 2011 -0700 @@ -129,20 +129,17 @@ if (needType == erasedCallerType.returnType()) return false; // no conversions possible, since must be primitive or Object Class<?> haveType = target.type().returnType(); - if (VerifyType.isNullConversion(haveType, needType)) + if (VerifyType.isNullConversion(haveType, needType) && !needType.isInterface()) return false; return true; } - private MethodHandle addReturnConversion(MethodHandle target, Class<?> type) { - if (true) throw new RuntimeException("NYI"); + private MethodHandle addReturnConversion(MethodHandle finisher, Class<?> type) { // FIXME: This is slow because it creates a closure node on every call that requires a return cast. - MethodType targetType = target.type(); + MethodType finisherType = finisher.type(); MethodHandle caster = ValueConversions.identity(type); - caster = caster.asType(MethodType.methodType(type, targetType.returnType())); - // Drop irrelevant arguments, because we only care about the return value: - caster = MethodHandles.dropArguments(caster, 1, targetType.parameterList()); - MethodHandle result = MethodHandles.foldArguments(caster, target); - return result.asType(target.type()); + caster = caster.asType(caster.type().changeParameterType(0, finisherType.returnType())); + finisher = MethodHandles.filterReturnValue(finisher, caster); + return finisher.asType(finisherType); } public String toString() {
--- a/src/share/classes/java/lang/invoke/Invokers.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/java/lang/invoke/Invokers.java Sat Jun 04 06:52:01 2011 -0700 @@ -46,7 +46,10 @@ // general invoker for the outgoing call private /*lazy*/ MethodHandle generalInvoker; - // general invoker for the outgoing call; accepts a single Object[] + // general invoker for the outgoing call, uses varargs + private /*lazy*/ MethodHandle varargsInvoker; + + // general invoker for the outgoing call; accepts a trailing Object[] private final /*lazy*/ MethodHandle[] spreadInvokers; // invoker for an unbound callsite @@ -67,45 +70,56 @@ /*non-public*/ MethodHandle exactInvoker() { MethodHandle invoker = exactInvoker; if (invoker != null) return invoker; - try { - invoker = IMPL_LOOKUP.findVirtual(MethodHandle.class, "invokeExact", targetType); - } catch (ReflectiveOperationException ex) { - throw new InternalError("JVM cannot find invoker for "+targetType); - } - assert(invokerType(targetType) == invoker.type()); + invoker = lookupInvoker("invokeExact"); exactInvoker = invoker; return invoker; } /*non-public*/ MethodHandle generalInvoker() { - MethodHandle invoker1 = exactInvoker(); MethodHandle invoker = generalInvoker; if (invoker != null) return invoker; - MethodType generalType = targetType.generic(); - invoker = invoker1.asType(invokerType(generalType)); + invoker = lookupInvoker("invoke"); generalInvoker = invoker; return invoker; } + private MethodHandle lookupInvoker(String name) { + MethodHandle invoker; + try { + invoker = IMPL_LOOKUP.findVirtual(MethodHandle.class, name, targetType); + } catch (ReflectiveOperationException ex) { + throw new InternalError("JVM cannot find invoker for "+targetType); + } + assert(invokerType(targetType) == invoker.type()); + assert(!invoker.isVarargsCollector()); + return invoker; + } + /*non-public*/ MethodHandle erasedInvoker() { - MethodHandle invoker1 = exactInvoker(); + MethodHandle xinvoker = exactInvoker(); MethodHandle invoker = erasedInvoker; if (invoker != null) return invoker; MethodType erasedType = targetType.erase(); - if (erasedType == targetType.generic()) - invoker = generalInvoker(); - else - invoker = invoker1.asType(invokerType(erasedType)); + invoker = xinvoker.asType(invokerType(erasedType)); erasedInvoker = invoker; return invoker; } - /*non-public*/ MethodHandle spreadInvoker(int objectArgCount) { - MethodHandle vaInvoker = spreadInvokers[objectArgCount]; + /*non-public*/ MethodHandle spreadInvoker(int leadingArgCount) { + MethodHandle vaInvoker = spreadInvokers[leadingArgCount]; if (vaInvoker != null) return vaInvoker; MethodHandle gInvoker = generalInvoker(); - vaInvoker = gInvoker.asSpreader(Object[].class, targetType.parameterCount() - objectArgCount); - spreadInvokers[objectArgCount] = vaInvoker; + int spreadArgCount = targetType.parameterCount() - leadingArgCount; + vaInvoker = gInvoker.asSpreader(Object[].class, spreadArgCount); + spreadInvokers[leadingArgCount] = vaInvoker; + return vaInvoker; + } + + /*non-public*/ MethodHandle varargsInvoker() { + MethodHandle vaInvoker = varargsInvoker; + if (vaInvoker != null) return vaInvoker; + vaInvoker = spreadInvoker(0).asType(invokerType(MethodType.genericMethodType(0, true))); + varargsInvoker = vaInvoker; return vaInvoker; }
--- a/src/share/classes/java/lang/invoke/MemberName.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/java/lang/invoke/MemberName.java Sat Jun 04 06:52:01 2011 -0700 @@ -506,8 +506,18 @@ if (from != null) message += ", from " + from; return new IllegalAccessException(message); } - public ReflectiveOperationException makeAccessException(String message) { - message = message + ": "+ toString(); + private String message() { + if (isResolved()) + return "no access"; + else if (isConstructor()) + return "no such constructor"; + else if (isMethod()) + return "no such method"; + else + return "no such field"; + } + public ReflectiveOperationException makeAccessException() { + String message = message() + ": "+ toString(); if (isResolved()) return new IllegalAccessException(message); else if (isConstructor()) @@ -641,7 +651,7 @@ MemberName result = resolveOrNull(m, searchSupers, lookupClass); if (result != null) return result; - ReflectiveOperationException ex = m.makeAccessException("no access"); + ReflectiveOperationException ex = m.makeAccessException(); if (ex instanceof IllegalAccessException) throw (IllegalAccessException) ex; throw nsmClass.cast(ex); }
--- a/src/share/classes/java/lang/invoke/MethodHandle.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/java/lang/invoke/MethodHandle.java Sat Jun 04 06:52:01 2011 -0700 @@ -26,6 +26,7 @@ package java.lang.invoke; +import java.util.ArrayList; import sun.invoke.util.ValueConversions; import static java.lang.invoke.MethodHandleStatics.*; @@ -40,12 +41,12 @@ * and {@linkplain java.lang.invoke.MethodHandles#filterArguments substitution}. * * <h3>Method handle contents</h3> - * Method handles are dynamically and strongly typed according to type descriptor. - * They are not distinguished by the name or defining class of their underlying methods. - * A method handle must be invoked using type descriptor which matches - * the method handle's own {@linkplain #type method type}. + * Method handles are dynamically and strongly typed according to their parameter and return types. + * They are not distinguished by the name or the defining class of their underlying methods. + * A method handle must be invoked using a symbolic type descriptor which matches + * the method handle's own {@linkplain #type type descriptor}. * <p> - * Every method handle reports its type via the {@link #type type} accessor. + * Every method handle reports its type descriptor via the {@link #type type} accessor. * This type descriptor is a {@link java.lang.invoke.MethodType MethodType} object, * whose structure is a series of classes, one of which is * the return type of the method (or {@code void.class} if none). @@ -82,7 +83,7 @@ * From the viewpoint of source code, these methods can take any arguments * and their result can be cast to any return type. * Formally this is accomplished by giving the invoker methods - * {@code Object} return types and variable-arity {@code Object} arguments, + * {@code Object} return types and variable arity {@code Object} arguments, * but they have an additional quality called <em>signature polymorphism</em> * which connects this freedom of invocation directly to the JVM execution stack. * <p> @@ -92,17 +93,17 @@ * and may not perform method invocation conversions on the arguments. * Instead, it must push them on the stack according to their own unconverted types. * The method handle object itself is pushed on the stack before the arguments. - * The compiler then calls the method handle with a type descriptor which + * The compiler then calls the method handle with a symbolic type descriptor which * describes the argument and return types. * <p> - * To issue a complete type descriptor, the compiler must also determine + * To issue a complete symbolic type descriptor, the compiler must also determine * the return type. This is based on a cast on the method invocation expression, * if there is one, or else {@code Object} if the invocation is an expression * or else {@code void} if the invocation is a statement. * The cast may be to a primitive type (but not {@code void}). * <p> * As a corner case, an uncasted {@code null} argument is given - * a type descriptor of {@code java.lang.Void}. + * a symbolic type descriptor of {@code java.lang.Void}. * The ambiguity with the type {@code Void} is harmless, since there are no references of type * {@code Void} except the null reference. * @@ -111,16 +112,16 @@ * it is linked, by symbolically resolving the names in the instruction * and verifying that the method call is statically legal. * This is true of calls to {@code invokeExact} and {@code invoke}. - * In this case, the type descriptor emitted by the compiler is checked for + * In this case, the symbolic type descriptor emitted by the compiler is checked for * correct syntax and names it contains are resolved. * Thus, an {@code invokevirtual} instruction which invokes * a method handle will always link, as long - * as the type descriptor is syntactically well-formed + * as the symbolic type descriptor is syntactically well-formed * and the types exist. * <p> * When the {@code invokevirtual} is executed after linking, * the receiving method handle's type is first checked by the JVM - * to ensure that it matches the descriptor. + * to ensure that it matches the symbolic type descriptor. * If the type match fails, it means that the method which the * caller is invoking is not present on the individual * method handle being invoked. @@ -137,7 +138,7 @@ * (or other behavior, as the case may be). * <p> * A call to plain {@code invoke} works the same as a call to - * {@code invokeExact}, if the type descriptor specified by the caller + * {@code invokeExact}, if the symbolic type descriptor specified by the caller * exactly matches the method handle's own type. * If there is a type mismatch, {@code invoke} attempts * to adjust the type of the receiving method handle, @@ -164,9 +165,9 @@ * method type matching takes into account both types names and class loaders. * Thus, even if a method handle {@code M} is created in one * class loader {@code L1} and used in another {@code L2}, - * method handle calls are type-safe, because the caller's type + * method handle calls are type-safe, because the caller's symbolic type * descriptor, as resolved in {@code L2}, - * is matched against the original callee method's type descriptor, + * is matched against the original callee method's symbolic type descriptor, * as resolved in {@code L1}. * The resolution in {@code L1} happens when {@code M} is created * and its type is assigned, while the resolution in {@code L2} happens @@ -242,24 +243,24 @@ mh = lookup.findVirtual(String.class, "replace", mt); s = (String) mh.invokeExact("daddy",'d','n'); // invokeExact(Ljava/lang/String;CC)Ljava/lang/String; -assert(s.equals("nanny")); +assertEquals(s, "nanny"); // weakly typed invocation (using MHs.invoke) s = (String) mh.invokeWithArguments("sappy", 'p', 'v'); -assert(s.equals("savvy")); +assertEquals(s, "savvy"); // mt is (Object[])List mt = MethodType.methodType(java.util.List.class, Object[].class); mh = lookup.findStatic(java.util.Arrays.class, "asList", mt); assert(mh.isVarargsCollector()); x = mh.invoke("one", "two"); // invoke(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Object; -assert(x.equals(java.util.Arrays.asList("one","two"))); +assertEquals(x, java.util.Arrays.asList("one","two")); // mt is (Object,Object,Object)Object mt = MethodType.genericMethodType(3); mh = mh.asType(mt); x = mh.invokeExact((Object)1, (Object)2, (Object)3); // invokeExact(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object; -assert(x.equals(java.util.Arrays.asList(1,2,3))); -// mt is int() +assertEquals(x, java.util.Arrays.asList(1,2,3)); +// mt is ()int mt = MethodType.methodType(int.class); mh = lookup.findVirtual(java.util.List.class, "size", mt); i = (int) mh.invokeExact(java.util.Arrays.asList(1,2,3)); @@ -272,7 +273,10 @@ * </pre></blockquote> * Each of the above calls to {@code invokeExact} or plain {@code invoke} * generates a single invokevirtual instruction with - * the type descriptor indicated in the following comment. + * the symbolic type descriptor indicated in the following comment. + * In these examples, the helper method {@code assertEquals} is assumed to + * be a method which calls {@link Objects.equals java.util.Objects#equals} + * on its arguments, and asserts that the result is true. * * <h3>Exceptions</h3> * The methods {@code invokeExact} and {@code invoke} are declared @@ -283,7 +287,7 @@ * there is no particular effect on bytecode shape from ascribing * checked exceptions to method handle invocations. But in Java source * code, methods which perform method handle calls must either explicitly - * throw {@code java.lang.Throwable Throwable}, or else must catch all + * throw {@code Throwable}, or else must catch all * throwables locally, rethrowing only those which are legal in the context, * and wrapping ones which are illegal. * @@ -291,77 +295,26 @@ * The unusual compilation and linkage behavior of * {@code invokeExact} and plain {@code invoke} * is referenced by the term <em>signature polymorphism</em>. - * A signature polymorphic method is one which can operate with + * As defined in the Java Language Specification, + * a signature polymorphic method is one which can operate with * any of a wide range of call signatures and return types. - * In order to make this work, both the Java compiler and the JVM must - * give special treatment to signature polymorphic methods. * <p> * In source code, a call to a signature polymorphic method will - * compile, regardless of the requested type descriptor. + * compile, regardless of the requested symbolic type descriptor. * As usual, the Java compiler emits an {@code invokevirtual} - * instruction with the given type descriptor against the named method. - * The unusual part is that the type descriptor is derived from + * instruction with the given symbolic type descriptor against the named method. + * The unusual part is that the symbolic type descriptor is derived from * the actual argument and return types, not from the method declaration. * <p> * When the JVM processes bytecode containing signature polymorphic calls, - * it will successfully link any such call, regardless of its type descriptor. + * it will successfully link any such call, regardless of its symbolic type descriptor. * (In order to retain type safety, the JVM will guard such calls with suitable * dynamic type checks, as described elsewhere.) * <p> * Bytecode generators, including the compiler back end, are required to emit - * untransformed type descriptors for these methods. + * untransformed symbolic type descriptors for these methods. * Tools which determine symbolic linkage are required to accept such * untransformed descriptors, without reporting linkage errors. - * <p> - * For the sake of tools (but not as a programming API), the signature polymorphic - * methods are marked with a private yet standard annotation, - * {@code @java.lang.invoke.MethodHandle.PolymorphicSignature}. - * The annotation's retention is {@code RUNTIME}, so that all tools can see it. - * - * <h3>Formal rules for processing signature polymorphic methods</h3> - * <p> - * The following methods (and no others) are signature polymorphic: - * <ul> - * <li>{@link java.lang.invoke.MethodHandle#invokeExact MethodHandle.invokeExact} - * <li>{@link java.lang.invoke.MethodHandle#invoke MethodHandle.invoke} - * </ul> - * <p> - * A signature polymorphic method will be declared with the following properties: - * <ul> - * <li>It must be native. - * <li>It must take a single varargs parameter of the form {@code Object...}. - * <li>It must produce a return value of type {@code Object}. - * <li>It must be contained within the {@code java.lang.invoke} package. - * </ul> - * Because of these requirements, a signature polymorphic method is able to accept - * any number and type of actual arguments, and can, with a cast, produce a value of any type. - * However, the JVM will treat these declaration features as a documentation convention, - * rather than a description of the actual structure of the methods as executed. - * <p> - * When a call to a signature polymorphic method is compiled, the associated linkage information for - * its arguments is not array of {@code Object} (as for other similar varargs methods) - * but rather the erasure of the static types of all the arguments. - * <p> - * In an argument position of a method invocation on a signature polymorphic method, - * a null literal has type {@code java.lang.Void}, unless cast to a reference type. - * (<em>Note:</em> This typing rule allows the null type to have its own encoding in linkage information - * distinct from other types. - * <p> - * The linkage information for the return type is derived from a context-dependent target typing convention. - * The return type for a signature polymorphic method invocation is determined as follows: - * <ul> - * <li>If the method invocation expression is an expression statement, the method is {@code void}. - * <li>Otherwise, if the method invocation expression is the immediate operand of a cast, - * the return type is the erasure of the cast type. - * <li>Otherwise, the return type is the method's nominal return type, {@code Object}. - * </ul> - * (Programmers are encouraged to use explicit casts unless it is clear that a signature polymorphic - * call will be used as a plain {@code Object} expression.) - * <p> - * The linkage information for argument and return types is stored in the descriptor for the - * compiled (bytecode) call site. As for any invocation instruction, the arguments and return value - * will be passed directly on the JVM stack, in accordance with the descriptor, - * and without implicit boxing or unboxing. * * <h3>Interoperation between method handles and the Core Reflection API</h3> * Using factory methods in the {@link java.lang.invoke.MethodHandles.Lookup Lookup} API, @@ -385,14 +338,14 @@ * declared method, including in this case {@code native} and {@code varargs} bits. * <p> * As with any reflected method, these methods (when reflected) may be - * invoked via {@link java.lang.reflect.Method#invoke Method.invoke}. + * invoked via {@link java.lang.reflect.Method#invoke java.lang.reflect.Method.invoke}. * However, such reflective calls do not result in method handle invocations. * Such a call, if passed the required argument * (a single one, of type {@code Object[]}), will ignore the argument and * will throw an {@code UnsupportedOperationException}. * <p> * Since {@code invokevirtual} instructions can natively - * invoke method handles under any type descriptor, this reflective view conflicts + * invoke method handles under any symbolic type descriptor, this reflective view conflicts * with the normal presentation of these methods via bytecodes. * Thus, these two native methods, when reflectively viewed by * {@code Class.getDeclaredMethod}, may be regarded as placeholders only. @@ -413,7 +366,7 @@ * When a method handle is invoked, the types of its arguments * or the return value cast type may be generic types or type instances. * If this occurs, the compiler will replace those - * types by their erasures when when it constructs the type descriptor + * types by their erasures when it constructs the symbolic type descriptor * for the {@code invokevirtual} instruction. * <p> * Method handles do not represent @@ -502,17 +455,17 @@ /** * Invokes the method handle, allowing any caller type descriptor, but requiring an exact type match. - * The type descriptor at the call site of {@code invokeExact} must + * The symbolic type descriptor at the call site of {@code invokeExact} must * exactly match this method handle's {@link #type type}. * No conversions are allowed on arguments or return values. * <p> * When this method is observed via the Core Reflection API, * it will appear as a single native method, taking an object array and returning an object. * If this native method is invoked directly via - * {@link java.lang.reflect.Method#invoke Method.invoke}, via JNI, + * {@link java.lang.reflect.Method#invoke java.lang.reflect.Method.invoke}, via JNI, * or indirectly via {@link java.lang.invoke.MethodHandles.Lookup#unreflect Lookup.unreflect}, * it will throw an {@code UnsupportedOperationException}. - * @throws WrongMethodTypeException if the target's type is not identical with the caller's type descriptor + * @throws WrongMethodTypeException if the target's type is not identical with the caller's symbolic type descriptor * @throws Throwable anything thrown by the underlying method propagates unchanged through the method handle call */ public final native @PolymorphicSignature Object invokeExact(Object... args) throws Throwable; @@ -521,7 +474,7 @@ * Invokes the method handle, allowing any caller type descriptor, * and optionally performing conversions on arguments and return values. * <p> - * If the call site type descriptor exactly matches this method handle's {@link #type type}, + * If the call site's symbolic type descriptor exactly matches this method handle's {@link #type type}, * the call proceeds as if by {@link #invokeExact invokeExact}. * <p> * Otherwise, the call proceeds as if this method handle were first @@ -534,7 +487,7 @@ * adaptations directly on the caller's arguments, * and call the target method handle according to its own exact type. * <p> - * The type descriptor at the call site of {@code invoke} must + * The resolved type descriptor at the call site of {@code invoke} must * be a valid argument to the receivers {@code asType} method. * In particular, the caller must specify the same argument arity * as the callee's type, @@ -543,24 +496,17 @@ * When this method is observed via the Core Reflection API, * it will appear as a single native method, taking an object array and returning an object. * If this native method is invoked directly via - * {@link java.lang.reflect.Method#invoke Method.invoke}, via JNI, + * {@link java.lang.reflect.Method#invoke java.lang.reflect.Method.invoke}, via JNI, * or indirectly via {@link java.lang.invoke.MethodHandles.Lookup#unreflect Lookup.unreflect}, * it will throw an {@code UnsupportedOperationException}. - * @throws WrongMethodTypeException if the target's type cannot be adjusted to the caller's type descriptor + * @throws WrongMethodTypeException if the target's type cannot be adjusted to the caller's symbolic type descriptor * @throws ClassCastException if the target's type can be adjusted to the caller, but a reference cast fails * @throws Throwable anything thrown by the underlying method propagates unchanged through the method handle call */ public final native @PolymorphicSignature Object invoke(Object... args) throws Throwable; /** - * <em>Temporary alias</em> for {@link #invoke}, for backward compatibility with some versions of JSR 292. - * On some JVMs, support can be excluded by the flags {@code -XX:+UnlockExperimentalVMOptions -XX:-AllowInvokeGeneric}. - * @deprecated Will be removed for JSR 292 Proposed Final Draft. - */ - public final native @PolymorphicSignature Object invokeGeneric(Object... args) throws Throwable; - - /** - * Performs a varargs invocation, passing the arguments in the given array + * Performs a variable arity invocation, passing the arguments in the given array * to the method handle, as if via an inexact {@link #invoke invoke} from a call site * which mentions only the type {@code Object}, and whose arity is the length * of the argument array. @@ -612,56 +558,16 @@ public Object invokeWithArguments(Object... arguments) throws Throwable { int argc = arguments == null ? 0 : arguments.length; MethodType type = type(); - if (type.parameterCount() != argc) { + if (type.parameterCount() != argc || isVarargsCollector()) { // simulate invoke return asType(MethodType.genericMethodType(argc)).invokeWithArguments(arguments); } - if (argc <= 10) { - MethodHandle invoker = type.invokers().generalInvoker(); - switch (argc) { - case 0: return invoker.invokeExact(this); - case 1: return invoker.invokeExact(this, - arguments[0]); - case 2: return invoker.invokeExact(this, - arguments[0], arguments[1]); - case 3: return invoker.invokeExact(this, - arguments[0], arguments[1], arguments[2]); - case 4: return invoker.invokeExact(this, - arguments[0], arguments[1], arguments[2], - arguments[3]); - case 5: return invoker.invokeExact(this, - arguments[0], arguments[1], arguments[2], - arguments[3], arguments[4]); - case 6: return invoker.invokeExact(this, - arguments[0], arguments[1], arguments[2], - arguments[3], arguments[4], arguments[5]); - case 7: return invoker.invokeExact(this, - arguments[0], arguments[1], arguments[2], - arguments[3], arguments[4], arguments[5], - arguments[6]); - case 8: return invoker.invokeExact(this, - arguments[0], arguments[1], arguments[2], - arguments[3], arguments[4], arguments[5], - arguments[6], arguments[7]); - case 9: return invoker.invokeExact(this, - arguments[0], arguments[1], arguments[2], - arguments[3], arguments[4], arguments[5], - arguments[6], arguments[7], arguments[8]); - case 10: return invoker.invokeExact(this, - arguments[0], arguments[1], arguments[2], - arguments[3], arguments[4], arguments[5], - arguments[6], arguments[7], arguments[8], - arguments[9]); - } - } - - // more than ten arguments get boxed in a varargs list: - MethodHandle invoker = type.invokers().spreadInvoker(0); + MethodHandle invoker = type.invokers().varargsInvoker(); return invoker.invokeExact(this, arguments); } /** - * Performs a varargs invocation, passing the arguments in the given array + * Performs a variable arity invocation, passing the arguments in the given array * to the method handle, as if via an inexact {@link #invoke invoke} from a call site * which mentions only the type {@code Object}, and whose arity is the length * of the argument array. @@ -673,6 +579,7 @@ * * @param arguments the arguments to pass to the target * @return the result returned by the target + * @throws NullPointerException if {@code arguments} is a null reference * @throws ClassCastException if an argument cannot be converted by reference casting * @throws WrongMethodTypeException if the target's type cannot be adjusted to take the given number of {@code Object} arguments * @throws Throwable anything thrown by the target method invocation @@ -689,32 +596,105 @@ * <p> * If the original type and new type are equal, returns {@code this}. * <p> + * The new method handle, when invoked, will perform the following + * steps: + * <ul> + * <li>Convert the incoming argument list to match the original + * method handle's argument list. + * <li>Invoke the original method handle on the converted argument list. + * <li>Convert any result returned by the original method handle + * to the return type of new method handle. + * </ul> + * <p> * This method provides the crucial behavioral difference between - * {@link #invokeExact invokeExact} and plain, inexact {@link #invoke invoke}. The two methods - * perform the same steps when the caller's type descriptor is identical - * with the callee's, but when the types differ, plain {@link #invoke invoke} + * {@link #invokeExact invokeExact} and plain, inexact {@link #invoke invoke}. + * The two methods + * perform the same steps when the caller's type descriptor exactly m atches + * the callee's, but when the types differ, plain {@link #invoke invoke} * also calls {@code asType} (or some internal equivalent) in order * to match up the caller's and callee's types. * <p> - * This method is equivalent to {@link MethodHandles#convertArguments convertArguments}, - * except for variable arity method handles produced by {@link #asVarargsCollector asVarargsCollector}. + * If the current method is a variable arity method handle + * argument list conversion may involve the conversion and collection + * of several arguments into an array, as + * {@linkplain #asVarargsCollector described elsewhere}. + * In every other case, all conversions are applied <em>pairwise</em>, + * which means that each argument or return value is converted to + * exactly one argument or return value (or no return value). + * The applied conversions are defined by consulting the + * the corresponding component types of the old and new + * method handle types. + * <p> + * Let <em>T0</em> and <em>T1</em> be corresponding new and old parameter types, + * or old and new return types. Specifically, for some valid index {@code i}, let + * <em>T0</em>{@code =newType.parameterType(i)} and <em>T1</em>{@code =this.type().parameterType(i)}. + * Or else, going the other way for return values, let + * <em>T0</em>{@code =this.type().returnType()} and <em>T1</em>{@code =newType.returnType()}. + * If the types are the same, the new method handle makes no change + * to the corresponding argument or return value (if any). + * Otherwise, one of the following conversions is applied + * if possible: + * <ul> + * <li>If <em>T0</em> and <em>T1</em> are references, then a cast to <em>T1</em> is applied. + * (The types do not need to be related in any particular way. + * This is because a dynamic value of null can convert to any reference type.) + * <li>If <em>T0</em> and <em>T1</em> are primitives, then a Java method invocation + * conversion (JLS 5.3) is applied, if one exists. + * (Specifically, <em>T0</em> must convert to <em>T1</em> by a widening primitive conversion.) + * <li>If <em>T0</em> is a primitive and <em>T1</em> a reference, + * a Java casting conversion (JLS 5.5) is applied if one exists. + * (Specifically, the value is boxed from <em>T0</em> to its wrapper class, + * which is then widened as needed to <em>T1</em>.) + * <li>If <em>T0</em> is a reference and <em>T1</em> a primitive, an unboxing + * conversion will be applied at runtime, possibly followed + * by a Java method invocation conversion (JLS 5.3) + * on the primitive value. (These are the primitive widening conversions.) + * <em>T0</em> must be a wrapper class or a supertype of one. + * (In the case where <em>T0</em> is Object, these are the conversions + * allowed by {@link java.lang.reflect.Method#invoke java.lang.reflect.Method.invoke}.) + * The unboxing conversion must have a possibility of success, which means that + * if <em>T0</em> is not itself a wrapper class, there must exist at least one + * wrapper class <em>TW</em> which is a subtype of <em>T0</em> and whose unboxed + * primitive value can be widened to <em>T1</em>. + * <li>If the return type <em>T1</em> is marked as void, any returned value is discarded + * <li>If the return type <em>T0</em> is void and <em>T1</em> a reference, a null value is introduced. + * <li>If the return type <em>T0</em> is void and <em>T1</em> a primitive, + * a zero value is introduced. + * </ul> + * (<em>Note:</em> Both <em>T0</em> and <em>T1</em> may be regarded as static types, + * because neither corresponds specifically to the <em>dynamic type</em> of any + * actual argument or return value.) + * <p> + * The method handle conversion cannot be made if any one of the required + * pairwise conversions cannot be made. + * <p> + * At runtime, the conversions applied to reference arguments + * or return values may require additional runtime checks which can fail. + * An unboxing operation may fail because the original reference is null, + * causing a {@link java.lang.NullPointerException NullPointerException}. + * An unboxing operation or a reference cast may also fail on a reference + * to an object of the wrong type, + * causing a {@link java.lang.ClassCastException ClassCastException}. + * Although an unboxing operation may accept several kinds of wrappers, + * if none are available, a {@code ClassCastException} will be thrown. * * @param newType the expected type of the new method handle * @return a method handle which delegates to {@code this} after performing * any necessary argument conversions, and arranges for any * necessary return value conversions + * @throws NullPointerException if {@code newType} is a null reference * @throws WrongMethodTypeException if the conversion cannot be made - * @see MethodHandles#convertArguments + * @see MethodHandles#explicitCastArguments */ public MethodHandle asType(MethodType newType) { if (!type.isConvertibleTo(newType)) { - throw new WrongMethodTypeException("cannot convert "+type+" to "+newType); + throw new WrongMethodTypeException("cannot convert "+this+" to "+newType); } - return MethodHandles.convertArguments(this, newType); + return MethodHandleImpl.convertArguments(this, newType, 1); } /** - * Makes an adapter which accepts a trailing array argument + * Makes an <em>array-spreading</em> method handle, which accepts a trailing array argument * and spreads its elements as positional arguments. * The new method handle adapts, as its <i>target</i>, * the current method handle. The type of the adapter will be @@ -739,26 +719,103 @@ * contains exactly enough elements to provide a correct argument count * to the target method handle. * (The array may also be null when zero elements are required.) + * <p> + * Here are some simple examples of array-spreading method handles: + * <blockquote><pre> +MethodHandle equals = publicLookup() + .findVirtual(String.class, "equals", methodType(boolean.class, Object.class)); +assert( (boolean) equals.invokeExact("me", (Object)"me")); +assert(!(boolean) equals.invokeExact("me", (Object)"thee")); +// spread both arguments from a 2-array: +MethodHandle eq2 = equals.asSpreader(Object[].class, 2); +assert( (boolean) eq2.invokeExact(new Object[]{ "me", "me" })); +assert(!(boolean) eq2.invokeExact(new Object[]{ "me", "thee" })); +// spread both arguments from a String array: +MethodHandle eq2s = equals.asSpreader(String[].class, 2); +assert( (boolean) eq2s.invokeExact(new String[]{ "me", "me" })); +assert(!(boolean) eq2s.invokeExact(new String[]{ "me", "thee" })); +// spread second arguments from a 1-array: +MethodHandle eq1 = equals.asSpreader(Object[].class, 1); +assert( (boolean) eq1.invokeExact("me", new Object[]{ "me" })); +assert(!(boolean) eq1.invokeExact("me", new Object[]{ "thee" })); +// spread no arguments from a 0-array or null: +MethodHandle eq0 = equals.asSpreader(Object[].class, 0); +assert( (boolean) eq0.invokeExact("me", (Object)"me", new Object[0])); +assert(!(boolean) eq0.invokeExact("me", (Object)"thee", (Object[])null)); +// asSpreader and asCollector are approximate inverses: +for (int n = 0; n <= 2; n++) { + for (Class<?> a : new Class<?>[]{Object[].class, String[].class, CharSequence[].class}) { + MethodHandle equals2 = equals.asSpreader(a, n).asCollector(a, n); + assert( (boolean) equals2.invokeWithArguments("me", "me")); + assert(!(boolean) equals2.invokeWithArguments("me", "thee")); + } +} +MethodHandle caToString = publicLookup() + .findStatic(Arrays.class, "toString", methodType(String.class, char[].class)); +assertEquals("[A, B, C]", (String) caToString.invokeExact("ABC".toCharArray())); +MethodHandle caString3 = caToString.asCollector(char[].class, 3); +assertEquals("[A, B, C]", (String) caString3.invokeExact('A', 'B', 'C')); +MethodHandle caToString2 = caString3.asSpreader(char[].class, 2); +assertEquals("[A, B, C]", (String) caToString2.invokeExact('A', "BC".toCharArray())); + * </pre></blockquote> * @param arrayType usually {@code Object[]}, the type of the array argument from which to extract the spread arguments * @param arrayLength the number of arguments to spread from an incoming array argument * @return a new method handle which spreads its final array argument, * before calling the original method handle + * @throws NullPointerException if {@code arrayType} is a null reference * @throws IllegalArgumentException if {@code arrayType} is not an array type * @throws IllegalArgumentException if target does not have at least - * {@code arrayLength} parameter types + * {@code arrayLength} parameter types, + * or if {@code arrayLength} is negative * @throws WrongMethodTypeException if the implied {@code asType} call fails * @see #asCollector */ public MethodHandle asSpreader(Class<?> arrayType, int arrayLength) { - Class<?> arrayElement = arrayType.getComponentType(); - if (arrayElement == null) throw newIllegalArgumentException("not an array type"); - int nargs = type().parameterCount(); - if (nargs < arrayLength) throw newIllegalArgumentException("bad spread array length"); + asSpreaderChecks(arrayType, arrayLength); return MethodHandleImpl.spreadArguments(this, arrayType, arrayLength); } + private void asSpreaderChecks(Class<?> arrayType, int arrayLength) { + spreadArrayChecks(arrayType, arrayLength); + int nargs = type().parameterCount(); + if (nargs < arrayLength || arrayLength < 0) + throw newIllegalArgumentException("bad spread array length"); + if (arrayType != Object[].class && arrayLength != 0) { + boolean sawProblem = false; + Class<?> arrayElement = arrayType.getComponentType(); + for (int i = nargs - arrayLength; i < nargs; i++) { + if (!MethodType.canConvert(arrayElement, type().parameterType(i))) { + sawProblem = true; + break; + } + } + if (sawProblem) { + ArrayList<Class<?>> ptypes = new ArrayList<Class<?>>(type().parameterList()); + for (int i = nargs - arrayLength; i < nargs; i++) { + ptypes.set(i, arrayElement); + } + // elicit an error: + this.asType(MethodType.methodType(type().returnType(), ptypes)); + } + } + } + + private void spreadArrayChecks(Class<?> arrayType, int arrayLength) { + Class<?> arrayElement = arrayType.getComponentType(); + if (arrayElement == null) + throw newIllegalArgumentException("not an array type", arrayType); + if ((arrayLength & 0x7F) != arrayLength) { + if ((arrayLength & 0xFF) != arrayLength) + throw newIllegalArgumentException("array length is not legal", arrayLength); + assert(arrayLength >= 128); + if (arrayElement == long.class || + arrayElement == double.class) + throw newIllegalArgumentException("array length is not legal for long[] or double[]", arrayLength); + } + } + /** - * Makes an adapter which accepts a given number of trailing + * Makes an <em>array-collecting</em> method handle, which accepts a given number of trailing * positional arguments and collects them into an array argument. * The new method handle adapts, as its <i>target</i>, * the current method handle. The type of the adapter will be @@ -785,10 +842,40 @@ * <p> * In order to create a collecting adapter which is not restricted to a particular * number of collected arguments, use {@link #asVarargsCollector asVarargsCollector} instead. + * <p> + * Here are some examples of array-collecting method handles: + * <blockquote><pre> +MethodHandle deepToString = publicLookup() + .findStatic(Arrays.class, "deepToString", methodType(String.class, Object[].class)); +assertEquals("[won]", (String) deepToString.invokeExact(new Object[]{"won"})); +MethodHandle ts1 = deepToString.asCollector(Object[].class, 1); +assertEquals(methodType(String.class, Object.class), ts1.type()); +//assertEquals("[won]", (String) ts1.invokeExact( new Object[]{"won"})); //FAIL +assertEquals("[[won]]", (String) ts1.invokeExact((Object) new Object[]{"won"})); +// arrayType can be a subtype of Object[] +MethodHandle ts2 = deepToString.asCollector(String[].class, 2); +assertEquals(methodType(String.class, String.class, String.class), ts2.type()); +assertEquals("[two, too]", (String) ts2.invokeExact("two", "too")); +MethodHandle ts0 = deepToString.asCollector(Object[].class, 0); +assertEquals("[]", (String) ts0.invokeExact()); +// collectors can be nested, Lisp-style +MethodHandle ts22 = deepToString.asCollector(Object[].class, 3).asCollector(String[].class, 2); +assertEquals("[A, B, [C, D]]", ((String) ts22.invokeExact((Object)'A', (Object)"B", "C", "D"))); +// arrayType can be any primitive array type +MethodHandle bytesToString = publicLookup() + .findStatic(Arrays.class, "toString", methodType(String.class, byte[].class)) + .asCollector(byte[].class, 3); +assertEquals("[1, 2, 3]", (String) bytesToString.invokeExact((byte)1, (byte)2, (byte)3)); +MethodHandle longsToString = publicLookup() + .findStatic(Arrays.class, "toString", methodType(String.class, long[].class)) + .asCollector(long[].class, 1); +assertEquals("[123]", (String) longsToString.invokeExact((long)123)); + * </pre></blockquote> * @param arrayType often {@code Object[]}, the type of the array argument which will collect the arguments * @param arrayLength the number of arguments to collect into a new array argument * @return a new method handle which collects some trailing argument * into an array, before calling the original method handle + * @throws NullPointerException if {@code arrayType} is a null reference * @throws IllegalArgumentException if {@code arrayType} is not an array type * or {@code arrayType} is not assignable to this method handle's trailing parameter type, * or {@code arrayLength} is not a legal array size @@ -802,13 +889,16 @@ return MethodHandleImpl.collectArguments(this, type.parameterCount()-1, collector); } - private void asCollectorChecks(Class<?> arrayType, int arrayLength) { - Class<?> arrayElement = arrayType.getComponentType(); - if (arrayElement == null) - throw newIllegalArgumentException("not an array type", arrayType); + // private API: return true if last param exactly matches arrayType + private boolean asCollectorChecks(Class<?> arrayType, int arrayLength) { + spreadArrayChecks(arrayType, arrayLength); int nargs = type().parameterCount(); - if (nargs == 0 || !type().parameterType(nargs-1).isAssignableFrom(arrayType)) - throw newIllegalArgumentException("array type not assignable to trailing argument", this, arrayType); + if (nargs != 0) { + Class<?> lastParam = type().parameterType(nargs-1); + if (lastParam == arrayType) return true; + if (lastParam.isAssignableFrom(arrayType)) return false; + } + throw newIllegalArgumentException("array type not assignable to trailing argument", this, arrayType); } /** @@ -825,6 +915,10 @@ * {@code arrayType}, even if the target has a different * last parameter type. * <p> + * This transformation may return {@code this} if the method handle is + * already of variable arity and its trailing parameter type + * is identical to {@code arrayType}. + * <p> * When called with {@link #invokeExact invokeExact}, the adapter invokes * the target with no argument changes. * (<em>Note:</em> This behavior is different from a @@ -841,8 +935,8 @@ * trailing parameter type of the caller is a reference type identical to * or assignable to the trailing parameter type of the adapter, * the arguments and return values are converted pairwise, - * as if by {@link MethodHandles#convertArguments convertArguments}. - * (This is also normal behavior for {@code invoke} in such a case.) + * as if by {@link #asType asType} on a fixed arity + * method handle. * <p> * Otherwise, the arities differ, or the adapter's trailing parameter * type is not assignable from the corresponding caller type. @@ -910,14 +1004,24 @@ * <p> * Here is an example, of a list-making variable arity method handle: * <blockquote><pre> +MethodHandle deepToString = publicLookup() + .findStatic(Arrays.class, "deepToString", methodType(String.class, Object[].class)); +MethodHandle ts1 = deepToString.asVarargsCollector(Object[].class); +assertEquals("[won]", (String) ts1.invokeExact( new Object[]{"won"})); +assertEquals("[won]", (String) ts1.invoke( new Object[]{"won"})); +assertEquals("[won]", (String) ts1.invoke( "won" )); +assertEquals("[[won]]", (String) ts1.invoke((Object) new Object[]{"won"})); +// findStatic of Arrays.asList(...) produces a variable arity method handle: MethodHandle asList = publicLookup() - .findStatic(Arrays.class, "asList", methodType(List.class, Object[].class)) - .asVarargsCollector(Object[].class); + .findStatic(Arrays.class, "asList", methodType(List.class, Object[].class)); +assertEquals(methodType(List.class, Object[].class), asList.type()); +assert(asList.isVarargsCollector()); assertEquals("[]", asList.invoke().toString()); assertEquals("[1]", asList.invoke(1).toString()); assertEquals("[two, too]", asList.invoke("two", "too").toString()); -Object[] argv = { "three", "thee", "tee" }; +String[] argv = { "three", "thee", "tee" }; assertEquals("[three, thee, tee]", asList.invoke(argv).toString()); +assertEquals("[three, thee, tee]", asList.invoke((Object[])argv).toString()); List ls = (List) asList.invoke((Object)argv); assertEquals(1, ls.size()); assertEquals("[three, thee, tee]", Arrays.toString((Object[])ls.get(0))); @@ -934,39 +1038,25 @@ * or not a single trailing argument is interpreted as a whole * array or a single element of an array to be collected. * Note that the dynamic type of the trailing argument has no - * effect on this decision, only a comparison between the static - * type descriptor of the call site and the type of the method handle.) - * <p style="font-size:smaller;"> - * As a result of the previously stated rules, the variable arity behavior - * of a method handle may be suppressed, by binding it to the exact invoker - * of its own type, as follows: - * <blockquote><pre> -MethodHandle vamh = publicLookup() - .findStatic(Arrays.class, "asList", methodType(List.class, Object[].class)) - .asVarargsCollector(Object[].class); -MethodHandle mh = MethodHandles.exactInvoker(vamh.type()).bindTo(vamh); -assert(vamh.type().equals(mh.type())); -assertEquals("[1, 2, 3]", vamh.invoke(1,2,3).toString()); -boolean failed = false; -try { mh.invoke(1,2,3); } -catch (WrongMethodTypeException ex) { failed = true; } -assert(failed); - * </pre></blockquote> - * This transformation has no behavioral effect if the method handle is - * not of variable arity. + * effect on this decision, only a comparison between the symbolic + * type descriptor of the call site and the type descriptor of the method handle.) * * @param arrayType often {@code Object[]}, the type of the array argument which will collect the arguments * @return a new method handle which can collect any number of trailing arguments * into an array, before calling the original method handle + * @throws NullPointerException if {@code arrayType} is a null reference * @throws IllegalArgumentException if {@code arrayType} is not an array type * or {@code arrayType} is not assignable to this method handle's trailing parameter type * @see #asCollector * @see #isVarargsCollector + * @see #asFixedArity */ public MethodHandle asVarargsCollector(Class<?> arrayType) { Class<?> arrayElement = arrayType.getComponentType(); - if (arrayElement == null) throw newIllegalArgumentException("not an array type"); - return MethodHandles.asVarargsCollector(this, arrayType); + boolean lastMatch = asCollectorChecks(arrayType, 0); + if (isVarargsCollector() && lastMatch) + return this; + return AdapterMethodHandle.makeVarargsCollector(this, arrayType); } /** @@ -982,12 +1072,61 @@ * </ul> * @return true if this method handle accepts more than one arity of plain, inexact {@code invoke} calls * @see #asVarargsCollector + * @see #asFixedArity */ public boolean isVarargsCollector() { return false; } /** + * Makes a <em>fixed arity</em> method handle which is otherwise + * equivalent to the the current method handle. + * <p> + * If the current method handle is not of + * {@linkplain #asVarargsCollector variable arity}, + * the current method handle is returned. + * This is true even if the current method handle + * could not be a valid input to {@code asVarargsCollector}. + * <p> + * Otherwise, the resulting fixed-arity method handle has the same + * type and behavior of the current method handle, + * except that {@link #isVarargsCollector isVarargsCollector} + * will be false. + * The fixed-arity method handle may (or may not) be the + * a previous argument to {@code asVarargsCollector}. + * <p> + * Here is an example, of a list-making variable arity method handle: + * <blockquote><pre> +MethodHandle asListVar = publicLookup() + .findStatic(Arrays.class, "asList", methodType(List.class, Object[].class)) + .asVarargsCollector(Object[].class); +MethodHandle asListFix = asListVar.asFixedArity(); +assertEquals("[1]", asListVar.invoke(1).toString()); +Exception caught = null; +try { asListFix.invoke((Object)1); } +catch (Exception ex) { caught = ex; } +assert(caught instanceof ClassCastException); +assertEquals("[two, too]", asListVar.invoke("two", "too").toString()); +try { asListFix.invoke("two", "too"); } +catch (Exception ex) { caught = ex; } +assert(caught instanceof WrongMethodTypeException); +Object[] argv = { "three", "thee", "tee" }; +assertEquals("[three, thee, tee]", asListVar.invoke(argv).toString()); +assertEquals("[three, thee, tee]", asListFix.invoke(argv).toString()); +assertEquals(1, ((List) asListVar.invoke((Object)argv)).size()); +assertEquals("[three, thee, tee]", asListFix.invoke((Object)argv).toString()); + * </pre></blockquote> + * + * @return a new method handle which accepts only a fixed number of arguments + * @see #asVarargsCollector + * @see #isVarargsCollector + */ + public MethodHandle asFixedArity() { + assert(!isVarargsCollector()); + return this; + } + + /** * Binds a value {@code x} to the first argument of a method handle, without invoking it. * The new method handle adapts, as its <i>target</i>, * the current method handle by binding it to the given argument. @@ -1043,6 +1182,12 @@ */ @Override public String toString() { + if (DEBUG_METHOD_HANDLE_NAMES) return debugString(); + return "MethodHandle"+type; + } + + /*non-public*/ + String debugString() { return getNameString(this); } }
--- a/src/share/classes/java/lang/invoke/MethodHandleImpl.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/java/lang/invoke/MethodHandleImpl.java Sat Jun 04 06:52:01 2011 -0700 @@ -82,20 +82,44 @@ } DirectMethodHandle mh = new DirectMethodHandle(mtype, method, doDispatch, lookupClass); if (!mh.isValid()) - throw method.makeAccessException("no access", lookupClass); + throw method.makeAccessException("no direct method handle", lookupClass); assert(mh.type() == mtype); if (!method.isVarargs()) return mh; - else - return mh.asVarargsCollector(mtype.parameterType(mtype.parameterCount()-1)); + int argc = mtype.parameterCount(); + if (argc != 0) { + Class<?> arrayType = mtype.parameterType(argc-1); + if (arrayType.isArray()) + return AdapterMethodHandle.makeVarargsCollector(mh, arrayType); + } + throw method.makeAccessException("cannot make variable arity", null); } static MethodHandle makeAllocator(MethodHandle rawConstructor) { MethodType rawConType = rawConstructor.type(); + Class<?> allocateClass = rawConType.parameterType(0); // Wrap the raw (unsafe) constructor with the allocation of a suitable object. + if (AdapterMethodHandle.canCollectArguments(rawConType, MethodType.methodType(allocateClass), 0, true)) { + // allocator(arg...) + // [fold]=> cookedConstructor(obj=allocate(C), arg...) + // [dup,collect]=> identity(obj, void=rawConstructor(obj, arg...)) + MethodHandle returner = MethodHandles.identity(allocateClass); + MethodType ctype = rawConType.insertParameterTypes(0, allocateClass).changeReturnType(allocateClass); + MethodHandle cookedConstructor = AdapterMethodHandle.makeCollectArguments(returner, rawConstructor, 1, false); + assert(cookedConstructor.type().equals(ctype)); + ctype = ctype.dropParameterTypes(0, 1); + cookedConstructor = AdapterMethodHandle.makeCollectArguments(cookedConstructor, returner, 0, true); + MethodHandle allocator = new AllocateObject(allocateClass); + // allocate() => new C(void) + assert(allocator.type().equals(MethodType.methodType(allocateClass))); + ctype = ctype.dropParameterTypes(0, 1); + MethodHandle fold = foldArguments(cookedConstructor, ctype, 0, allocator); + return fold; + } + assert(MethodHandleNatives.workaroundWithoutRicochetFrames()); // this code is deprecated MethodHandle allocator - = AllocateObject.make(rawConType.parameterType(0), rawConstructor); + = AllocateObject.make(allocateClass, rawConstructor); assert(allocator.type() .equals(rawConType.dropParameterTypes(0, 1).changeReturnType(rawConType.parameterType(0)))); return allocator; @@ -112,8 +136,16 @@ super(invoker); this.allocateClass = allocateClass; this.rawConstructor = rawConstructor; + assert(MethodHandleNatives.workaroundWithoutRicochetFrames()); // this code is deprecated + } + // for allocation only: + private AllocateObject(Class<C> allocateClass) { + super(ALLOCATE.asType(MethodType.methodType(allocateClass, AllocateObject.class))); + this.allocateClass = allocateClass; + this.rawConstructor = null; } static MethodHandle make(Class<?> allocateClass, MethodHandle rawConstructor) { + assert(MethodHandleNatives.workaroundWithoutRicochetFrames()); // this code is deprecated MethodType rawConType = rawConstructor.type(); assert(rawConType.parameterType(0) == allocateClass); MethodType newType = rawConType.dropParameterTypes(0, 1).changeReturnType(allocateClass); @@ -129,14 +161,14 @@ } else { MethodHandle invoke = VARARGS_INVOKE; MethodType conType = CON_TYPES[nargs]; - MethodHandle gcon = spreadArguments(rawConstructor, conType, 1); + MethodHandle gcon = spreadArgumentsFromPos(rawConstructor, conType, 1); if (gcon == null) return null; MethodHandle galloc = new AllocateObject(invoke, allocateClass, gcon); return collectArguments(galloc, newType, 1, null); } } @Override - public String toString() { + String debugString() { return addTypeString(allocateClass.getSimpleName(), this); } @SuppressWarnings("unchecked") @@ -214,9 +246,11 @@ // For testing use this: //static final MethodHandle[] INVOKES = Arrays.copyOf(makeInvokes(), 2); static final MethodHandle VARARGS_INVOKE; + static final MethodHandle ALLOCATE; static { try { VARARGS_INVOKE = IMPL_LOOKUP.findVirtual(AllocateObject.class, "invoke_V", MethodType.genericMethodType(0, true)); + ALLOCATE = IMPL_LOOKUP.findVirtual(AllocateObject.class, "allocate", MethodType.genericMethodType(0)); } catch (ReflectiveOperationException ex) { throw uncaughtException(ex); } @@ -278,7 +312,7 @@ this.base = staticBase(field); } @Override - public String toString() { return addTypeString(name, this); } + String debugString() { return addTypeString(name, this); } int getFieldI(C obj) { return unsafe.getInt(obj, offset); } void setFieldI(C obj, int x) { unsafe.putInt(obj, offset, x); } @@ -309,8 +343,9 @@ try { // FIXME: Should not have to create 'f' to get this value. f = c.getDeclaredField(field.getName()); + // Note: Previous line might invalidly throw SecurityException (7042829) return unsafe.staticFieldBase(f); - } catch (Exception ee) { + } catch (NoSuchFieldException ee) { throw uncaughtException(ee); } } @@ -455,14 +490,14 @@ */ static MethodHandle bindReceiver(MethodHandle target, Object receiver) { + if (receiver == null) return null; if (target instanceof AdapterMethodHandle && ((AdapterMethodHandle)target).conversionOp() == MethodHandleNatives.Constants.OP_RETYPE_ONLY ) { Object info = MethodHandleNatives.getTargetInfo(target); if (info instanceof DirectMethodHandle) { DirectMethodHandle dmh = (DirectMethodHandle) info; - if (receiver == null || - dmh.type().parameterType(0).isAssignableFrom(receiver.getClass())) { + if (dmh.type().parameterType(0).isAssignableFrom(receiver.getClass())) { MethodHandle bmh = new BoundMethodHandle(dmh, receiver, 0); MethodType newType = target.type().dropParameterTypes(0, 1); return convertArguments(bmh, newType, bmh.type(), 0); @@ -668,7 +703,9 @@ if (target == null) throw newIllegalArgumentException("cannot drop"); oldType = target.type(); } - return convertArguments(target, newType, oldType, 0); + target = convertArguments(target, newType, oldType, 0); + assert(target != null); + return target; } /*non-public*/ static @@ -747,7 +784,7 @@ .insertParameterTypes(keepPosArgs, arrayType); return spreadArguments(target, newType, keepPosArgs, arrayType, arrayLength); } - static MethodHandle spreadArguments(MethodHandle target, MethodType newType, int spreadArgPos) { + static MethodHandle spreadArgumentsFromPos(MethodHandle target, MethodType newType, int spreadArgPos) { int arrayLength = target.type().parameterCount() - spreadArgPos; return spreadArguments(target, newType, spreadArgPos, Object[].class, arrayLength); } @@ -761,9 +798,7 @@ // spread the last argument of newType to oldType assert(arrayLength == oldType.parameterCount() - spreadArgPos); assert(newType.parameterType(spreadArgPos) == arrayType); - MethodHandle res = AdapterMethodHandle.makeSpreadArguments(newType, target, arrayType, spreadArgPos, arrayLength); - if (res == null) throw new IllegalArgumentException("spread on "+target+" with "+arrayType.getSimpleName()); - return res; + return AdapterMethodHandle.makeSpreadArguments(newType, target, arrayType, spreadArgPos, arrayLength); } static MethodHandle collectArguments(MethodHandle target, @@ -771,6 +806,7 @@ MethodHandle collector) { MethodType type = target.type(); Class<?> collectType = collector.type().returnType(); + assert(collectType != void.class); // else use foldArguments if (collectType != type.parameterType(collectArg)) target = target.asType(type.changeParameterType(collectArg, collectType)); MethodType newType = type @@ -879,11 +915,15 @@ this.target = target; this.fallback = fallback; } - // FIXME: Build the control flow out of foldArguments. + static boolean preferRicochetFrame(MethodType type) { + return (type.parameterCount() >= INVOKES.length || type.hasPrimitives()); + } static MethodHandle make(MethodHandle test, MethodHandle target, MethodHandle fallback) { MethodType type = target.type(); int nargs = type.parameterCount(); if (nargs < INVOKES.length) { + if (preferRicochetFrame(type)) + assert(MethodHandleNatives.workaroundWithoutRicochetFrames()); // this code is deprecated MethodHandle invoke = INVOKES[nargs]; MethodType gtype = type.generic(); assert(invoke.type().dropParameterTypes(0,1) == gtype); @@ -894,19 +934,20 @@ MethodHandle gguard = new GuardWithTest(invoke, gtest, gtarget, gfallback); return convertArguments(gguard, type, gtype, 0); } else { + assert(MethodHandleNatives.workaroundWithoutRicochetFrames()); // this code is deprecated MethodHandle invoke = VARARGS_INVOKE; MethodType gtype = MethodType.genericMethodType(1); assert(invoke.type().dropParameterTypes(0,1) == gtype); - MethodHandle gtest = spreadArguments(test, gtype.changeReturnType(boolean.class), 0); - MethodHandle gtarget = spreadArguments(target, gtype, 0); - MethodHandle gfallback = spreadArguments(fallback, gtype, 0); + MethodHandle gtest = spreadArgumentsFromPos(test, gtype.changeReturnType(boolean.class), 0); + MethodHandle gtarget = spreadArgumentsFromPos(target, gtype, 0); + MethodHandle gfallback = spreadArgumentsFromPos(fallback, gtype, 0); MethodHandle gguard = new GuardWithTest(invoke, gtest, gtarget, gfallback); if (gtest == null || gtarget == null || gfallback == null) return null; return collectArguments(gguard, type, 0, null); } } @Override - public String toString() { + String debugString() { return addTypeString(target, this); } private Object invoke_V(Object... av) throws Throwable { @@ -990,9 +1031,49 @@ } static + MethodHandle selectAlternative(boolean testResult, MethodHandle target, MethodHandle fallback) { + return testResult ? target : fallback; + } + + static MethodHandle SELECT_ALTERNATIVE; + static MethodHandle selectAlternative() { + if (SELECT_ALTERNATIVE != null) return SELECT_ALTERNATIVE; + try { + SELECT_ALTERNATIVE + = IMPL_LOOKUP.findStatic(MethodHandleImpl.class, "selectAlternative", + MethodType.methodType(MethodHandle.class, boolean.class, MethodHandle.class, MethodHandle.class)); + } catch (ReflectiveOperationException ex) { + throw new RuntimeException(ex); + } + return SELECT_ALTERNATIVE; + } + + static MethodHandle makeGuardWithTest(MethodHandle test, MethodHandle target, MethodHandle fallback) { + // gwt(arg...) + // [fold]=> continueAfterTest(z=test(arg...), arg...) + // [filter]=> (tf=select(z))(arg...) + // where select(z) = select(z, t, f).bindTo(t, f) => z ? t f + // [tailcall]=> tf(arg...) + assert(test.type().returnType() == boolean.class); + MethodType targetType = target.type(); + MethodType foldTargetType = targetType.insertParameterTypes(0, boolean.class); + if (AdapterMethodHandle.canCollectArguments(foldTargetType, test.type(), 0, true) + && GuardWithTest.preferRicochetFrame(targetType)) { + // working backwards, as usual: + assert(target.type().equals(fallback.type())); + MethodHandle tailcall = MethodHandles.exactInvoker(target.type()); + MethodHandle select = selectAlternative(); + select = bindArgument(select, 2, fallback); + select = bindArgument(select, 1, target); + // select(z: boolean) => (z ? target : fallback) + MethodHandle filter = filterArgument(tailcall, 0, select); + assert(filter.type().parameterType(0) == boolean.class); + MethodHandle fold = foldArguments(filter, filter.type().dropParameterTypes(0, 1), 0, test); + return fold; + } return GuardWithTest.make(test, target, fallback); } @@ -1012,7 +1093,7 @@ this.catcher = catcher; } @Override - public String toString() { + String debugString() { return addTypeString(target, this); } private Object invoke_V(Object... av) throws Throwable { @@ -1144,11 +1225,12 @@ } else { MethodType gtype = MethodType.genericMethodType(0, true); MethodType gcatchType = gtype.insertParameterTypes(0, Throwable.class); - MethodHandle gtarget = spreadArguments(target, gtype, 0); - MethodHandle gcatcher = spreadArguments(catcher, gcatchType, 1); + MethodHandle gtarget = spreadArgumentsFromPos(target, gtype, 0); + catcher = catcher.asType(ctype.changeParameterType(0, Throwable.class)); + MethodHandle gcatcher = spreadArgumentsFromPos(catcher, gcatchType, 1); MethodHandle gguard = new GuardWithCatch(GuardWithCatch.VARARGS_INVOKE, gtarget, exType, gcatcher); if (gtarget == null || gcatcher == null || gguard == null) return null; - return collectArguments(gguard, type, 0, null); + return collectArguments(gguard, type, 0, ValueConversions.varargsArray(nargs)).asType(type); } } @@ -1178,8 +1260,4 @@ static MethodHandle getBootstrap(Class<?> callerClass) { return MethodHandleNatives.getBootstrap(callerClass); } - - static MethodHandle asVarargsCollector(MethodHandle target, Class<?> arrayType) { - return AdapterMethodHandle.makeVarargsCollector(target, arrayType); - } }
--- a/src/share/classes/java/lang/invoke/MethodHandleNatives.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/java/lang/invoke/MethodHandleNatives.java Sat Jun 04 06:52:01 2011 -0700 @@ -400,7 +400,7 @@ case REF_newInvokeSpecial: return lookup.findConstructor( defc, (MethodType) type ); case REF_invokeInterface: return lookup.findVirtual( defc, name, (MethodType) type ); } - throw new IllegalArgumentException("bad MethodHandle constant "+name+" : "+type); + throw new InternalError("bad MethodHandle constant "+name+" : "+type); } catch (ReflectiveOperationException ex) { Error err = new IncompatibleClassChangeError(); err.initCause(ex);
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/classes/java/lang/invoke/MethodHandleProxies.java Sat Jun 04 06:52:01 2011 -0700 @@ -0,0 +1,257 @@ +/* + * Copyright (c) 2008, 2011, 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 java.lang.invoke; + +import java.lang.reflect.*; +import sun.invoke.WrapperInstance; + +/** + * This class consists exclusively of static methods that help adapt + * method handles to other JVM types, such as interfaces. + */ +public class MethodHandleProxies { + + private MethodHandleProxies() { } // do not instantiate + + /** + * Produces an instance of the given single-method interface which redirects + * its calls to the given method handle. + * <p> + * A single-method interface is an interface which declares a uniquely named method. + * When determining the uniquely named method of a single-method interface, + * the public {@code Object} methods ({@code toString}, {@code equals}, {@code hashCode}) + * are disregarded. For example, {@link java.util.Comparator} is a single-method interface, + * even though it re-declares the {@code Object.equals} method. + * <p> + * The interface must be public. No additional access checks are performed. + * <p> + * The resulting instance of the required type will respond to + * invocation of the type's uniquely named method by calling + * the given target on the incoming arguments, + * and returning or throwing whatever the target + * returns or throws. The invocation will be as if by + * {@code target.invoke}. + * The target's type will be checked before the + * instance is created, as if by a call to {@code asType}, + * which may result in a {@code WrongMethodTypeException}. + * <p> + * The uniquely named method is allowed to be multiply declared, + * with distinct type descriptors. (E.g., it can be overloaded, + * or can possess bridge methods.) All such declarations are + * connected directly to the target method handle. + * Argument and return types are adjusted by {@code asType} + * for each individual declaration. + * <p> + * The wrapper instance will implement the requested interface + * and its super-types, but no other single-method interfaces. + * This means that the instance will not unexpectedly + * pass an {@code instanceof} test for any unrequested type. + * <p style="font-size:smaller;"> + * <em>Implementation Note:</em> + * Therefore, each instance must implement a unique single-method interface. + * Implementations may not bundle together + * multiple single-method interfaces onto single implementation classes + * in the style of {@link java.awt.AWTEventMulticaster}. + * <p> + * The method handle may throw an <em>undeclared exception</em>, + * which means any checked exception (or other checked throwable) + * not declared by the requested type's single abstract method. + * If this happens, the throwable will be wrapped in an instance of + * {@link java.lang.reflect.UndeclaredThrowableException UndeclaredThrowableException} + * and thrown in that wrapped form. + * <p> + * Like {@link java.lang.Integer#valueOf Integer.valueOf}, + * {@code asInterfaceInstance} is a factory method whose results are defined + * by their behavior. + * It is not guaranteed to return a new instance for every call. + * <p> + * Because of the possibility of {@linkplain java.lang.reflect.Method#isBridge bridge methods} + * and other corner cases, the interface may also have several abstract methods + * with the same name but having distinct descriptors (types of returns and parameters). + * In this case, all the methods are bound in common to the one given target. + * The type check and effective {@code asType} conversion is applied to each + * method type descriptor, and all abstract methods are bound to the target in common. + * Beyond this type check, no further checks are made to determine that the + * abstract methods are related in any way. + * <p> + * Future versions of this API may accept additional types, + * such as abstract classes with single abstract methods. + * Future versions of this API may also equip wrapper instances + * with one or more additional public "marker" interfaces. + * + * @param target the method handle to invoke from the wrapper + * @param intfc the desired type of the wrapper, a single-method interface + * @return a correctly-typed wrapper for the given target + * @throws NullPointerException if either argument is null + * @throws IllegalArgumentException if the {@code intfc} is not a + * valid argument to this method + * @throws WrongMethodTypeException if the target cannot + * be converted to the type required by the requested interface + */ + // Other notes to implementors: + // <p> + // No stable mapping is promised between the single-method interface and + // the implementation class C. Over time, several implementation + // classes might be used for the same type. + // <p> + // If the implementation is able + // to prove that a wrapper of the required type + // has already been created for a given + // method handle, or for another method handle with the + // same behavior, the implementation may return that wrapper in place of + // a new wrapper. + // <p> + // This method is designed to apply to common use cases + // where a single method handle must interoperate with + // an interface that implements a function-like + // API. Additional variations, such as single-abstract-method classes with + // private constructors, or interfaces with multiple but related + // entry points, must be covered by hand-written or automatically + // generated adapter classes. + // + public static + <T> T asInterfaceInstance(final Class<T> intfc, final MethodHandle target) { + // POC implementation only; violates the above contract several ways + final Method sm = getSingleMethod(intfc); + if (sm == null) + throw new IllegalArgumentException("not a single-method interface: "+intfc.getName()); + MethodType smMT = MethodType.methodType(sm.getReturnType(), sm.getParameterTypes()); + MethodHandle checkTarget = target.asType(smMT); // make throw WMT + checkTarget = checkTarget.asType(checkTarget.type().changeReturnType(Object.class)); + final MethodHandle vaTarget = checkTarget.asSpreader(Object[].class, smMT.parameterCount()); + return intfc.cast(Proxy.newProxyInstance( + intfc.getClassLoader(), + new Class[]{ intfc, WrapperInstance.class }, + new InvocationHandler() { + private Object getArg(String name) { + if ((Object)name == "getWrapperInstanceTarget") return target; + if ((Object)name == "getWrapperInstanceType") return intfc; + throw new AssertionError(); + } + public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { + if (method.getDeclaringClass() == WrapperInstance.class) + return getArg(method.getName()); + if (method.equals(sm)) + return vaTarget.invokeExact(args); + if (isObjectMethod(method)) + return callObjectMethod(this, method, args); + throw new InternalError(); + } + })); + } + + /** + * Determines if the given object was produced by a call to {@link #asInterfaceInstance asInterfaceInstance}. + * @param x any reference + * @return true if the reference is not null and points to an object produced by {@code asInterfaceInstance} + */ + public static + boolean isWrapperInstance(Object x) { + return x instanceof WrapperInstance; + } + + private static WrapperInstance asWrapperInstance(Object x) { + try { + if (x != null) + return (WrapperInstance) x; + } catch (ClassCastException ex) { + } + throw new IllegalArgumentException("not a wrapper instance"); + } + + /** + * Produces or recovers a target method handle which is behaviorally + * equivalent to the unique method of this wrapper instance. + * The object {@code x} must have been produced by a call to {@link #asInterfaceInstance asInterfaceInstance}. + * This requirement may be tested via {@link #isWrapperInstance isWrapperInstance}. + * @param x any reference + * @return a method handle implementing the unique method + * @throws IllegalArgumentException if the reference x is not to a wrapper instance + */ + public static + MethodHandle wrapperInstanceTarget(Object x) { + return asWrapperInstance(x).getWrapperInstanceTarget(); + } + + /** + * Recovers the unique single-method interface type for which this wrapper instance was created. + * The object {@code x} must have been produced by a call to {@link #asInterfaceInstance asInterfaceInstance}. + * This requirement may be tested via {@link #isWrapperInstance isWrapperInstance}. + * @param x any reference + * @return the single-method interface type for which the wrapper was created + * @throws IllegalArgumentException if the reference x is not to a wrapper instance + */ + public static + Class<?> wrapperInstanceType(Object x) { + return asWrapperInstance(x).getWrapperInstanceType(); + } + + private static + boolean isObjectMethod(Method m) { + switch (m.getName()) { + case "toString": + return (m.getReturnType() == String.class + && m.getParameterTypes().length == 0); + case "hashCode": + return (m.getReturnType() == int.class + && m.getParameterTypes().length == 0); + case "equals": + return (m.getReturnType() == boolean.class + && m.getParameterTypes().length == 1 + && m.getParameterTypes()[0] == Object.class); + } + return false; + } + + private static + Object callObjectMethod(Object self, Method m, Object[] args) { + assert(isObjectMethod(m)) : m; + switch (m.getName()) { + case "toString": + return self.getClass().getName() + "@" + Integer.toHexString(self.hashCode()); + case "hashCode": + return System.identityHashCode(self); + case "equals": + return (self == args[0]); + } + return null; + } + + private static + Method getSingleMethod(Class<?> intfc) { + if (!intfc.isInterface()) return null; + Method sm = null; + for (Method m : intfc.getMethods()) { + int mod = m.getModifiers(); + if (Modifier.isAbstract(mod)) { + if (sm != null && !isObjectMethod(sm)) + return null; // too many abstract methods + sm = m; + } + } + return sm; + } +}
--- a/src/share/classes/java/lang/invoke/MethodHandleStatics.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/java/lang/invoke/MethodHandleStatics.java Sat Jun 04 06:52:01 2011 -0700 @@ -35,6 +35,8 @@ private MethodHandleStatics() { } // do not instantiate + static final boolean DEBUG_METHOD_HANDLE_NAMES = Boolean.getBoolean("java.lang.invoke.MethodHandle.DEBUG_NAMES"); + /*non-public*/ static String getNameString(MethodHandle target, MethodType type) { if (type == null) type = target.type();
--- a/src/share/classes/java/lang/invoke/MethodHandles.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/java/lang/invoke/MethodHandles.java Sat Jun 04 06:52:01 2011 -0700 @@ -180,6 +180,10 @@ * The names {@code aMethod}, {@code aField}, and {@code aConstructor} stand * for reflective objects corresponding to the given members. * <p> + * In cases where the given member is of variable arity (i.e., a method or constructor) + * the returned method handle will also be of {@linkplain MethodHandle#asVarargsCollector variable arity}. + * In all other cases, the returned method handle will be of fixed arity. + * <p> * The equivalence between looked-up method handles and underlying * class members can break down in a few ways: * <ul> @@ -201,7 +205,7 @@ * Access checks are applied in the factory methods of {@code Lookup}, * when a method handle is created. * This is a key difference from the Core Reflection API, since - * {@link java.lang.reflect.Method#invoke Method.invoke} + * {@link java.lang.reflect.Method#invoke java.lang.reflect.Method.invoke} * performs access checking against every caller, on every call. * <p> * All access checks start from a {@code Lookup} object, which @@ -267,7 +271,7 @@ * Access checks only apply to named and reflected methods, * constructors, and fields. * Other method handle creation methods, such as - * {@link #convertArguments MethodHandles.convertArguments}, + * {@link MethodHandle#asType MethodHandle.asType}, * do not require any access checks, and are done * with static methods of {@link MethodHandles}, * independently of any {@code Lookup} object. @@ -296,6 +300,12 @@ * {@link SecurityManager#checkMemberAccess * smgr.checkMemberAccess(defc, Member.DECLARED)} is called. * (Note that {@code defc} might be the same as {@code refc}.) + * The default implementation of this security manager method + * inspects the stack to determine the original caller of + * the reflective request (such as {@code findStatic}), + * and performs additional permission checks if the + * class loader of {@code defc} differs from the class + * loader of the class from which the reflective request came. * <li>If the retrieved member is not public, * and if {@code defc} and {@code refc} are in different class loaders, * and if the class loader of the lookup class is not @@ -304,8 +314,6 @@ * smgr.checkPackageAccess(defcPkg)} is called, * where {@code defcPkg} is the package of {@code defc}. * </ul> - * In all cases, the requesting class presented to the security - * manager will be the lookup class from the current {@code Lookup} object. */ public static final class Lookup { @@ -559,7 +567,10 @@ * @param type the type of the method * @return the desired method handle * @throws NoSuchMethodException if the method does not exist - * @throws IllegalAccessException if access checking fails, or if the method is not {@code static} + * @throws IllegalAccessException if access checking fails, + * or if the method is not {@code static}, + * or if the method's variable arity modifier bit + * is set and {@code asVarargsCollector} fails * @exception SecurityException if a security manager is present and it * <a href="MethodHandles.Lookup.html#secmgr">refuses access</a> * @throws NullPointerException if any argument is null @@ -567,6 +578,7 @@ public MethodHandle findStatic(Class<?> refc, String name, MethodType type) throws NoSuchMethodException, IllegalAccessException { MemberName method = resolveOrFail(refc, name, type, true); + checkSecurityManager(refc, method); // stack walk magic: do not refactor checkMethod(refc, method, true); return MethodHandleImpl.findMethod(method, false, lookupClassOrNull()); } @@ -601,13 +613,17 @@ * @param type the type of the method, with the receiver argument omitted * @return the desired method handle * @throws NoSuchMethodException if the method does not exist - * @throws IllegalAccessException if access checking fails, or if the method is {@code static} + * @throws IllegalAccessException if access checking fails, + * or if the method is {@code static} + * or if the method's variable arity modifier bit + * is set and {@code asVarargsCollector} fails * @exception SecurityException if a security manager is present and it * <a href="MethodHandles.Lookup.html#secmgr">refuses access</a> * @throws NullPointerException if any argument is null */ public MethodHandle findVirtual(Class<?> refc, String name, MethodType type) throws NoSuchMethodException, IllegalAccessException { MemberName method = resolveOrFail(refc, name, type, false); + checkSecurityManager(refc, method); // stack walk magic: do not refactor checkMethod(refc, method, false); MethodHandle mh = MethodHandleImpl.findMethod(method, true, lookupClassOrNull()); return restrictProtectedReceiver(method, mh); @@ -633,6 +649,8 @@ * @return the desired method handle * @throws NoSuchMethodException if the constructor does not exist * @throws IllegalAccessException if access checking fails + * or if the method's variable arity modifier bit + * is set and {@code asVarargsCollector} fails * @exception SecurityException if a security manager is present and it * <a href="MethodHandles.Lookup.html#secmgr">refuses access</a> * @throws NullPointerException if any argument is null @@ -641,6 +659,7 @@ String name = "<init>"; MemberName ctor = resolveOrFail(refc, name, type, false, false, lookupClassOrNull()); assert(ctor.isConstructor()); + checkSecurityManager(refc, ctor); // stack walk magic: do not refactor checkAccess(refc, ctor); MethodHandle rawMH = MethodHandleImpl.findMethod(ctor, false, lookupClassOrNull()); MethodHandle allocMH = MethodHandleImpl.makeAllocator(rawMH); @@ -658,7 +677,7 @@ int arity = type.parameterCount(); return mh.asVarargsCollector(type.parameterType(arity-1)); } else { - throw new InternalError("already varargs, but template is not: "+mh); + return mh.asFixedArity(); } } @@ -690,6 +709,8 @@ * @return the desired method handle * @throws NoSuchMethodException if the method does not exist * @throws IllegalAccessException if access checking fails + * or if the method's variable arity modifier bit + * is set and {@code asVarargsCollector} fails * @exception SecurityException if a security manager is present and it * <a href="MethodHandles.Lookup.html#secmgr">refuses access</a> * @throws NullPointerException if any argument is null @@ -698,6 +719,7 @@ Class<?> specialCaller) throws NoSuchMethodException, IllegalAccessException { checkSpecialCaller(specialCaller); MemberName method = resolveOrFail(refc, name, type, false, false, specialCaller); + checkSecurityManager(refc, method); // stack walk magic: do not refactor checkMethod(refc, method, false); MethodHandle mh = MethodHandleImpl.findMethod(method, false, specialCaller); return restrictReceiver(method, mh, specialCaller); @@ -721,7 +743,9 @@ * @throws NullPointerException if any argument is null */ public MethodHandle findGetter(Class<?> refc, String name, Class<?> type) throws NoSuchFieldException, IllegalAccessException { - return makeAccessor(refc, name, type, false, false); + MemberName field = resolveOrFail(refc, name, type, false); + checkSecurityManager(refc, field); // stack walk magic: do not refactor + return makeAccessor(refc, field, false, false, 0); } /** @@ -742,7 +766,9 @@ * @throws NullPointerException if any argument is null */ public MethodHandle findSetter(Class<?> refc, String name, Class<?> type) throws NoSuchFieldException, IllegalAccessException { - return makeAccessor(refc, name, type, false, true); + MemberName field = resolveOrFail(refc, name, type, false); + checkSecurityManager(refc, field); // stack walk magic: do not refactor + return makeAccessor(refc, field, false, true, 0); } /** @@ -762,7 +788,9 @@ * @throws NullPointerException if any argument is null */ public MethodHandle findStaticGetter(Class<?> refc, String name, Class<?> type) throws NoSuchFieldException, IllegalAccessException { - return makeAccessor(refc, name, type, true, false); + MemberName field = resolveOrFail(refc, name, type, true); + checkSecurityManager(refc, field); // stack walk magic: do not refactor + return makeAccessor(refc, field, false, false, 1); } /** @@ -782,7 +810,9 @@ * @throws NullPointerException if any argument is null */ public MethodHandle findStaticSetter(Class<?> refc, String name, Class<?> type) throws NoSuchFieldException, IllegalAccessException { - return makeAccessor(refc, name, type, true, true); + MemberName field = resolveOrFail(refc, name, type, true); + checkSecurityManager(refc, field); // stack walk magic: do not refactor + return makeAccessor(refc, field, false, true, 1); } /** @@ -805,10 +835,13 @@ * <p> * This is equivalent to the following code: * <blockquote><pre> -MethodHandle mh0 = {@link #findVirtual findVirtual}(defc, name, type); +import static java.lang.invoke.MethodHandles.*; +import static java.lang.invoke.MethodType.*; +... +MethodHandle mh0 = lookup().{@link #findVirtual findVirtual}(defc, name, type); MethodHandle mh1 = mh0.{@link MethodHandle#bindTo bindTo}(receiver); MethodType mt1 = mh1.type(); -if (mh0.isVarargsCollector() && mt1.parameterCount() > 0) { +if (mh0.isVarargsCollector()) mh1 = mh1.asVarargsCollector(mt1.parameterType(mt1.parameterCount()-1)); return mh1; * </pre></blockquote> @@ -822,6 +855,8 @@ * @return the desired method handle * @throws NoSuchMethodException if the method does not exist * @throws IllegalAccessException if access checking fails + * or if the method's variable arity modifier bit + * is set and {@code asVarargsCollector} fails * @exception SecurityException if a security manager is present and it * <a href="MethodHandles.Lookup.html#secmgr">refuses access</a> * @throws NullPointerException if any argument is null @@ -829,13 +864,12 @@ public MethodHandle bind(Object receiver, String name, MethodType type) throws NoSuchMethodException, IllegalAccessException { Class<? extends Object> refc = receiver.getClass(); // may get NPE MemberName method = resolveOrFail(refc, name, type, false); + checkSecurityManager(refc, method); // stack walk magic: do not refactor checkMethod(refc, method, false); MethodHandle dmh = MethodHandleImpl.findMethod(method, true, lookupClassOrNull()); MethodHandle bmh = MethodHandleImpl.bindReceiver(dmh, receiver); if (bmh == null) throw method.makeAccessException("no access", this); - if (dmh.type().parameterCount() == 0) - return dmh; // bound the trailing parameter; no varargs possible return fixVarargs(bmh, dmh); } @@ -856,6 +890,8 @@ * @param m the reflected method * @return a method handle which can invoke the reflected method * @throws IllegalAccessException if access checking fails + * or if the method's variable arity modifier bit + * is set and {@code asVarargsCollector} fails * @throws NullPointerException if the argument is null */ public MethodHandle unreflect(Method m) throws IllegalAccessException { @@ -884,6 +920,8 @@ * @param specialCaller the class nominally calling the method * @return a method handle which can invoke the reflected method * @throws IllegalAccessException if access checking fails + * or if the method's variable arity modifier bit + * is set and {@code asVarargsCollector} fails * @throws NullPointerException if any argument is null */ public MethodHandle unreflectSpecial(Method m, Class<?> specialCaller) throws IllegalAccessException { @@ -913,6 +951,8 @@ * @param c the reflected constructor * @return a method handle which can invoke the reflected constructor * @throws IllegalAccessException if access checking fails + * or if the method's variable arity modifier bit + * is set and {@code asVarargsCollector} fails * @throws NullPointerException if the argument is null */ public MethodHandle unreflectConstructor(Constructor c) throws IllegalAccessException { @@ -939,7 +979,7 @@ * @throws NullPointerException if the argument is null */ public MethodHandle unreflectGetter(Field f) throws IllegalAccessException { - return makeAccessor(f.getDeclaringClass(), new MemberName(f), f.isAccessible(), false); + return makeAccessor(f.getDeclaringClass(), new MemberName(f), f.isAccessible(), false, -1); } /** @@ -957,7 +997,7 @@ * @throws NullPointerException if the argument is null */ public MethodHandle unreflectSetter(Field f) throws IllegalAccessException { - return makeAccessor(f.getDeclaringClass(), new MemberName(f), f.isAccessible(), true); + return makeAccessor(f.getDeclaringClass(), new MemberName(f), f.isAccessible(), true, -1); } /// Helper methods, all package-private. @@ -993,6 +1033,46 @@ throw new MemberName(refc).makeAccessException("symbolic reference class is not public", this); } + /** + * Perform necessary <a href="MethodHandles.Lookup.html#secmgr">access checks</a>. + * This function performs stack walk magic: do not refactor it. + */ + void checkSecurityManager(Class<?> refc, MemberName m) { + SecurityManager smgr = System.getSecurityManager(); + if (smgr == null) return; + if (allowedModes == TRUSTED) return; + // Step 1: + smgr.checkMemberAccess(refc, Member.PUBLIC); + // Step 2: + if (!VerifyAccess.classLoaderIsAncestor(lookupClass, refc)) + smgr.checkPackageAccess(VerifyAccess.getPackageName(refc)); + // Step 3: + if (m.isPublic()) return; + Class<?> defc = m.getDeclaringClass(); + smgr.checkMemberAccess(defc, Member.DECLARED); // STACK WALK HERE + // Step 4: + if (defc != refc) + smgr.checkPackageAccess(VerifyAccess.getPackageName(defc)); + + // Comment from SM.checkMemberAccess, where which=DECLARED: + /* + * stack depth of 4 should be the caller of one of the + * methods in java.lang.Class that invoke checkMember + * access. The stack should look like: + * + * someCaller [3] + * java.lang.Class.someReflectionAPI [2] + * java.lang.Class.checkMemberAccess [1] + * SecurityManager.checkMemberAccess [0] + * + */ + // For us it is this stack: + // someCaller [3] + // Lookup.findSomeMember [2] + // Lookup.checkSecurityManager [1] + // SecurityManager.checkMemberAccess [0] + } + void checkMethod(Class<?> refc, MemberName m, boolean wantStatic) throws IllegalAccessException { String message; if (m.isConstructor()) @@ -1065,6 +1145,7 @@ if (!method.isProtected() || method.isStatic() || allowedModes == TRUSTED || method.getDeclaringClass() == lookupClass() + || VerifyAccess.isSamePackage(method.getDeclaringClass(), lookupClass()) || (ALLOW_NESTMATE_ACCESS && VerifyAccess.isSamePackageMember(method.getDeclaringClass(), lookupClass()))) return mh; @@ -1084,19 +1165,14 @@ return fixVarargs(narrowMH, mh); } - MethodHandle makeAccessor(Class<?> refc, String name, Class<?> type, - boolean isStatic, boolean isSetter) throws NoSuchFieldException, IllegalAccessException { - MemberName field = resolveOrFail(refc, name, type, isStatic); - if (isStatic != field.isStatic()) - throw field.makeAccessException(isStatic + MethodHandle makeAccessor(Class<?> refc, MemberName field, + boolean trusted, boolean isSetter, + int checkStatic) throws IllegalAccessException { + assert(field.isField()); + if (checkStatic >= 0 && (checkStatic != 0) != field.isStatic()) + throw field.makeAccessException((checkStatic != 0) ? "expected a static field" : "expected a non-static field", this); - return makeAccessor(refc, field, false, isSetter); - } - - MethodHandle makeAccessor(Class<?> refc, MemberName field, - boolean trusted, boolean isSetter) throws IllegalAccessException { - assert(field.isField()); if (trusted) return MethodHandleImpl.accessField(field, isSetter, lookupClassOrNull()); checkAccess(refc, field); @@ -1138,50 +1214,51 @@ /** * Produces a method handle which will invoke any method handle of the - * given {@code type} on a standard set of {@code Object} type arguments - * and a single trailing {@code Object[]} array. + * given {@code type}, with a given number of trailing arguments replaced by + * a single trailing {@code Object[]} array. * The resulting invoker will be a method handle with the following * arguments: * <ul> * <li>a single {@code MethodHandle} target - * <li>zero or more {@code Object} values (counted by {@code objectArgCount}) - * <li>an {@code Object[]} array containing more arguments + * <li>zero or more leading values (counted by {@code leadingArgCount}) + * <li>an {@code Object[]} array containing trailing arguments * </ul> * <p> - * The invoker will behave like a call to {@link MethodHandle#invoke invoke} with + * The invoker will invoke its target like a call to {@link MethodHandle#invoke invoke} with * the indicated {@code type}. * That is, if the target is exactly of the given {@code type}, it will behave * like {@code invokeExact}; otherwise it behave as if {@link MethodHandle#asType asType} * is used to convert the target to the required {@code type}. * <p> * The type of the returned invoker will not be the given {@code type}, but rather - * will have all parameter and return types replaced by {@code Object}, except for - * the last parameter type, which will be the array type {@code Object[]}. + * will have all parameters except the first {@code leadingArgCount} + * replaced by a single array of type {@code Object[]}, which will be + * the final parameter. * <p> - * Before invoking its target, the invoker will spread the varargs array, apply + * Before invoking its target, the invoker will spread the final array, apply * reference casts as necessary, and unbox and widen primitive arguments. - * The return value of the invoker will be an {@code Object} reference, - * boxing a primitive value if the original type returns a primitive, - * and always null if the original type returns void. * <p> * This method is equivalent to the following code (though it may be more efficient): * <p><blockquote><pre> MethodHandle invoker = MethodHandles.invoker(type); -int spreadArgCount = type.parameterCount - objectArgCount; +int spreadArgCount = type.parameterCount() - leadingArgCount; invoker = invoker.asSpreader(Object[].class, spreadArgCount); return invoker; * </pre></blockquote> * <p> * This method throws no reflective or security exceptions. * @param type the desired target type - * @param objectArgCount number of fixed (non-varargs) {@code Object} arguments + * @param leadingArgCount number of fixed arguments, to be passed unchanged to the target * @return a method handle suitable for invoking any method handle of the given type + * @throws NullPointerException if {@code type} is null + * @throws IllegalArgumentException if {@code leadingArgCount} is not in + * the range from 0 to {@code type.parameterCount()} inclusive */ static public - MethodHandle spreadInvoker(MethodType type, int objectArgCount) { - if (objectArgCount < 0 || objectArgCount > type.parameterCount()) - throw new IllegalArgumentException("bad argument count "+objectArgCount); - return type.invokers().spreadInvoker(objectArgCount); + MethodHandle spreadInvoker(MethodType type, int leadingArgCount) { + if (leadingArgCount < 0 || leadingArgCount > type.parameterCount()) + throw new IllegalArgumentException("bad argument count "+leadingArgCount); + return type.invokers().spreadInvoker(leadingArgCount); } /** @@ -1211,7 +1288,7 @@ * method handle values, as long as they are compatible with the type of {@code X}. * <p> * <em>(Note: The invoker method is not available via the Core Reflection API. - * An attempt to call {@linkplain java.lang.reflect.Method#invoke Method.invoke} + * An attempt to call {@linkplain java.lang.reflect.Method#invoke java.lang.reflect.Method.invoke} * on the declared {@code invokeExact} or {@code invoke} method will raise an * {@link java.lang.UnsupportedOperationException UnsupportedOperationException}.)</em> * <p> @@ -1231,12 +1308,18 @@ * exactly equal to the desired type, except that it will accept * an additional leading argument of type {@code MethodHandle}. * <p> - * Before invoking its target, the invoker will apply reference casts as + * Before invoking its target, if the target differs from the expected type, + * the invoker will apply reference casts as * necessary and box, unbox, or widen primitive values, as if by {@link MethodHandle#asType asType}. * Similarly, the return value will be converted as necessary. * If the target is a {@linkplain MethodHandle#asVarargsCollector variable arity method handle}, * the required arity conversion will be made, again as if by {@link MethodHandle#asType asType}. * <p> + * A {@linkplain MethodType#genericMethodType general method type}, + * mentions only {@code Object} arguments and return values. + * An invoker for such a type is capable of calling any method handle + * of the same arity as the general type. + * <p> * This method is equivalent to the following code (though it may be more efficient): * <p><blockquote><pre> publicLookup().findVirtual(MethodHandle.class, "invoke", type) @@ -1252,18 +1335,9 @@ } /** - * <em>Temporary alias</em> for {@link #invoker}, for backward compatibility with some versions of JSR 292. - * @deprecated Will be removed for JSR 292 Proposed Final Draft. - */ - public static - MethodHandle genericInvoker(MethodType type) { - return invoker(type); - } - - /** * Perform value checking, exactly as if for an adapted method handle. * It is assumed that the given value is either null, of type T0, - * or (if T0 is primitive) of the wrapper type corresponding to T0. + * or (if T0 is primitive) of the wrapper class corresponding to T0. * The following checks and conversions are made: * <ul> * <li>If T0 and T1 are references, then a cast to T1 is applied. @@ -1271,11 +1345,11 @@ * <li>If T0 and T1 are primitives, then a widening or narrowing * conversion is applied, if one exists. * <li>If T0 is a primitive and T1 a reference, and - * T0 has a wrapper type TW, a boxing conversion to TW is applied, + * T0 has a wrapper class TW, a boxing conversion to TW is applied, * possibly followed by a reference conversion. * T1 must be TW or a supertype. * <li>If T0 is a reference and T1 a primitive, and - * T1 has a wrapper type TW, an unboxing conversion is applied, + * T1 has a wrapper class TW, an unboxing conversion is applied, * possibly preceded by a reference conversion. * T0 must be TW or a supertype. * <li>If T1 is void, the return value is discarded @@ -1288,6 +1362,7 @@ * @return the value, converted if necessary * @throws java.lang.ClassCastException if a cast fails */ + // FIXME: This is used in just one place. Refactor away. static <T0, T1> T1 checkValue(Class<T0> t0, Class<T1> t1, Object value) throws ClassCastException @@ -1316,6 +1391,8 @@ return w1.convert(value, t1); } + // FIXME: Delete this. It is used only for insertArguments & bindTo. + // Replace by a more standard check. static Object checkValue(Class<?> T1, Object value) throws ClassCastException @@ -1332,134 +1409,53 @@ /** * Produces a method handle which adapts the type of the - * given method handle to a new type by pairwise argument conversion. - * The original type and new type must have the same number of arguments. - * The resulting method handle is guaranteed to report a type - * which is equal to the desired new type. - * <p> - * If the original type and new type are equal, returns target. - * <p> - * The following conversions are applied as needed both to - * arguments and return types. Let T0 and T1 be the differing - * new and old parameter types (or old and new return types) - * for corresponding values passed by the new and old method types. - * Given those types T0, T1, one of the following conversions is applied - * if possible: - * <ul> - * <li>If T0 and T1 are references, then a cast to T1 is applied. - * (The types do not need to be related in any particular way.) - * <li>If T0 and T1 are primitives, then a Java method invocation - * conversion (JLS 5.3) is applied, if one exists. - * <li>If T0 is a primitive and T1 a reference, a boxing - * conversion is applied if one exists, possibly followed by - * a reference conversion to a superclass. - * T1 must be a wrapper class or a supertype of one. - * <li>If T0 is a reference and T1 a primitive, an unboxing - * conversion will be applied at runtime, possibly followed - * by a Java method invocation conversion (JLS 5.3) - * on the primitive value. (These are the widening conversions.) - * T0 must be a wrapper class or a supertype of one. - * (In the case where T0 is Object, these are the conversions - * allowed by java.lang.reflect.Method.invoke.) - * <li>If the return type T1 is void, any returned value is discarded - * <li>If the return type T0 is void and T1 a reference, a null value is introduced. - * <li>If the return type T0 is void and T1 a primitive, a zero value is introduced. - * </ul> - * @param target the method handle to invoke after arguments are retyped - * @param newType the expected type of the new method handle - * @return a method handle which delegates to {@code target} after performing - * any necessary argument conversions, and arranges for any - * necessary return value conversions - * @throws NullPointerException if either argument is null - * @throws WrongMethodTypeException if the conversion cannot be made - * @see MethodHandle#asType - * @see MethodHandles#explicitCastArguments - */ - public static - MethodHandle convertArguments(MethodHandle target, MethodType newType) { - return MethodHandleImpl.convertArguments(target, newType, 1); - } - - /** - * Produces a method handle which adapts the type of the - * given method handle to a new type by pairwise argument conversion. + * given method handle to a new type by pairwise argument and return type conversion. * The original type and new type must have the same number of arguments. * The resulting method handle is guaranteed to report a type * which is equal to the desired new type. * <p> * If the original type and new type are equal, returns target. * <p> - * The same conversions are allowed as for {@link #convertArguments convertArguments}, + * The same conversions are allowed as for {@link MethodHandle#asType MethodHandle.asType}, * and some additional conversions are also applied if those conversions fail. - * Given types T0, T1, one of the following conversions is applied - * in addition, if the conversions specified for {@code convertArguments} - * would be insufficient: + * Given types <em>T0</em>, <em>T1</em>, one of the following conversions is applied + * if possible, before or instead of any conversions done by {@code asType}: * <ul> - * <li>If T0 and T1 are references, and T1 is an interface type, - * then the value of type T0 is passed as a T1 without a cast. + * <li>If <em>T0</em> and <em>T1</em> are references, and <em>T1</em> is an interface type, + * then the value of type <em>T0</em> is passed as a <em>T1</em> without a cast. * (This treatment of interfaces follows the usage of the bytecode verifier.) - * <li>If T0 and T1 are primitives and one is boolean, - * the boolean is treated as a one-bit unsigned integer. + * <li>If <em>T0</em> is boolean and <em>T1</em> is another primitive, + * the boolean is converted to a byte value, 1 for true, 0 for false. * (This treatment follows the usage of the bytecode verifier.) - * A conversion from another primitive type behaves as if - * it first converts to byte, and then masks all but the low bit. - * <li>If a primitive value would be converted by {@code convertArguments} - * using Java method invocation conversion (JLS 5.3), - * Java casting conversion (JLS 5.5) may be used also. - * This allows primitives to be narrowed as well as widened. + * <li>If <em>T1</em> is boolean and <em>T0</em> is another primitive, + * <em>T0</em> is converted to byte via Java casting conversion (JLS 5.5), + * and the low order bit of the result is tested, as if by {@code (x & 1) != 0}. + * <li>If <em>T0</em> and <em>T1</em> are primitives other than boolean, + * then a Java casting conversion (JLS 5.5) is applied. + * (Specifically, <em>T0</em> will convert to <em>T1</em> by + * widening and/or narrowing.) + * <li>If <em>T0</em> is a reference and <em>T1</em> a primitive, an unboxing + * conversion will be applied at runtime, possibly followed + * by a Java casting conversion (JLS 5.5) on the primitive value, + * possibly followed by a conversion from byte to boolean by testing + * the low-order bit. + * <li>If <em>T0</em> is a reference and <em>T1</em> a primitive, + * and if the reference is null at runtime, a zero value is introduced. * </ul> * @param target the method handle to invoke after arguments are retyped * @param newType the expected type of the new method handle - * @return a method handle which delegates to {@code target} after performing + * @return a method handle which delegates to the target after performing * any necessary argument conversions, and arranges for any * necessary return value conversions * @throws NullPointerException if either argument is null * @throws WrongMethodTypeException if the conversion cannot be made * @see MethodHandle#asType - * @see MethodHandles#convertArguments */ public static MethodHandle explicitCastArguments(MethodHandle target, MethodType newType) { return MethodHandleImpl.convertArguments(target, newType, 2); } - /* - FIXME: Reconcile javadoc with 10/22/2010 EG notes on conversion: - - Both converters arrange for their method handles to convert arguments - and return values. The conversion rules are the same for arguments - and return values, and depend only on source and target types, S and - T. The conversions allowed by castConvertArguments are a strict - superset of those performed by convertArguments. - - In all cases, if S and T are references, a simple checkcast is done. - If neither S nor T is a primitive, no attempt is made to unbox and - box. A failed conversion throws ClassCastException. - - If T is void, the value is dropped. - - For compatibility with reflection, if S is void and T is a reference, - a null value is produced. - - For compatibility with reflection, if S is a reference and T is a - primitive, S is first unboxed and then undergoes primitive conversion. - In the case of 'convertArguments', only assignment conversion is - performed (no narrowing primitive conversion). - - If S is a primitive, S is boxed, and then the above rules are applied. - If S and T are both primitives, the boxing will be undetectable; only - the primitive conversions will be apparent to the user. The key point - is that if S is a primitive type, the implementation may box it and - treat is as Object, without loss of information, or it may use a "fast - path" which does not use boxing. - - Notwithstanding the rules above, for compatibility with the verifier, - if T is an interface, it is treated as if it were Object. [KEEP THIS?] - - Also, for compatibility with the verifier, a boolean may be undergo - widening or narrowing conversion to any other primitive type. [KEEP THIS?] - */ - /** * Produces a method handle which adapts the calling sequence of the * given method handle to a new type, by reordering the arguments. @@ -1478,8 +1474,8 @@ * <p> * No argument or return value conversions are applied. * The type of each incoming argument, as determined by {@code newType}, - * must be identical to the type of the corresponding outgoing argument - * or arguments in the target method handle. + * must be identical to the type of the corresponding outgoing parameter + * or parameters in the target method handle. * The return type of {@code newType} must be identical to the return * type of the original target. * <p> @@ -1491,25 +1487,33 @@ * incoming arguments which are not mentioned in the reordering array * are may be any type, as determined only by {@code newType}. * <blockquote><pre> -MethodType intfn1 = MethodType.methodType(int.class, int.class); -MethodType intfn2 = MethodType.methodType(int.class, int.class, int.class); +import static java.lang.invoke.MethodHandles.*; +import static java.lang.invoke.MethodType.*; +... +MethodType intfn1 = methodType(int.class, int.class); +MethodType intfn2 = methodType(int.class, int.class, int.class); MethodHandle sub = ... {int x, int y => x-y} ...; assert(sub.type().equals(intfn2)); -MethodHandle sub1 = MethodHandles.permuteArguments(sub, intfn2, 0, 1); -MethodHandle rsub = MethodHandles.permuteArguments(sub, intfn2, 1, 0); +MethodHandle sub1 = permuteArguments(sub, intfn2, 0, 1); +MethodHandle rsub = permuteArguments(sub, intfn2, 1, 0); assert((int)rsub.invokeExact(1, 100) == 99); MethodHandle add = ... {int x, int y => x+y} ...; assert(add.type().equals(intfn2)); -MethodHandle twice = MethodHandles.permuteArguments(add, intfn1, 0, 0); +MethodHandle twice = permuteArguments(add, intfn1, 0, 0); assert(twice.type().equals(intfn1)); assert((int)twice.invokeExact(21) == 42); * </pre></blockquote> * @param target the method handle to invoke after arguments are reordered * @param newType the expected type of the new method handle - * @param reorder a string which controls the reordering - * @return a method handle which delegates to {@code target} after it + * @param reorder an index array which controls the reordering + * @return a method handle which delegates to the target after it * drops unused arguments and moves and/or duplicates the other arguments * @throws NullPointerException if any argument is null + * @throws IllegalArgumentException if the index array length is not equal to + * the arity of the target, or if any index array element + * not a valid index for a parameter of {@code newType}, + * or if two corresponding parameter types in + * {@code target.type()} and {@code newType} are not identical, */ public static MethodHandle permuteArguments(MethodHandle target, MethodType newType, int... reorder) { @@ -1544,78 +1548,13 @@ } /** - * Equivalent to the following code: - * <p><blockquote><pre> - * int spreadPos = newType.parameterCount() - 1; - * Class<?> spreadType = newType.parameterType(spreadPos); - * int spreadCount = target.type().parameterCount() - spreadPos; - * MethodHandle adapter = target.asSpreader(spreadType, spreadCount); - * adapter = adapter.asType(newType); - * return adapter; - * </pre></blockquote> - * @param target the method handle to invoke after argument spreading - * @param newType the expected type of the new method handle - * @return a method handle which spreads its final argument, - * before calling the original method handle - */ - /*non-public*/ static - MethodHandle spreadArguments(MethodHandle target, MethodType newType) { - MethodType oldType = target.type(); - int inargs = newType.parameterCount(); - int outargs = oldType.parameterCount(); - int spreadPos = inargs - 1; - int numSpread = (outargs - spreadPos); - MethodHandle res = null; - if (spreadPos >= 0 && numSpread >= 0) { - res = MethodHandleImpl.spreadArguments(target, newType, spreadPos); - } - if (res == null) { - throw newIllegalArgumentException("cannot spread "+newType+" to " +oldType); - } - return res; - } - - /** - * Equivalent to the following code: - * <p><blockquote><pre> - * int collectPos = target.type().parameterCount() - 1; - * Class<?> collectType = target.type().parameterType(collectPos); - * if (!collectType.isArray()) collectType = Object[].class; - * int collectCount = newType.parameterCount() - collectPos; - * MethodHandle adapter = target.asCollector(collectType, collectCount); - * adapter = adapter.asType(newType); - * return adapter; - * </pre></blockquote> - * @param target the method handle to invoke after argument collection - * @param newType the expected type of the new method handle - * @return a method handle which collects some trailing argument - * into an array, before calling the original method handle - */ - /*non-public*/ static - MethodHandle collectArguments(MethodHandle target, MethodType newType) { - MethodType oldType = target.type(); - int inargs = newType.parameterCount(); - int outargs = oldType.parameterCount(); - int collectPos = outargs - 1; - int numCollect = (inargs - collectPos); - if (collectPos < 0 || numCollect < 0) - throw newIllegalArgumentException("wrong number of arguments"); - MethodHandle res = MethodHandleImpl.collectArguments(target, newType, collectPos, null); - if (res == null) { - throw newIllegalArgumentException("cannot collect from "+newType+" to " +oldType); - } - return res; - } - - /** * Produces a method handle of the requested return type which returns the given * constant value every time it is invoked. * <p> * Before the method handle is returned, the passed-in value is converted to the requested type. * If the requested type is primitive, widening primitive conversions are attempted, * else reference conversions are attempted. - * <p>The returned method handle is equivalent to {@code identity(type).bindTo(value)}, - * unless the type is {@code void}, in which case it is {@code identity(type)}. + * <p>The returned method handle is equivalent to {@code identity(type).bindTo(value)}. * @param type the return type of the desired method handle * @param value the value to return * @return a method handle of the given return type and no arguments, which always returns the given value @@ -1637,7 +1576,6 @@ /** * Produces a method handle which returns its sole argument when invoked. - * <p>The identity function for {@code void} takes no arguments and returns no values. * @param type the type of the sole parameter and return value of the desired method handle * @return a unary method handle which accepts and returns the given type * @throws NullPointerException if the argument is null @@ -1657,11 +1595,15 @@ } /** - * Produces a method handle which calls the original method handle {@code target}, - * after inserting the given argument(s) at the given position. - * The formal parameters to {@code target} which will be supplied by those - * arguments are called <em>bound parameters</em>, because the new method - * will contain bindings for those parameters take from {@code values}. + * Provides a target method handle with one or more <em>bound arguments</em> + * in advance of the method handle's invocation. + * The formal parameters to the target corresponding to the bound + * arguments are called <em>bound parameters</em>. + * Returns a new method handle which saves away the bound arguments. + * When it is invoked, it receives arguments for any non-bound parameters, + * binds the saved arguments to their corresponding parameters, + * and calls the original target. + * <p> * The type of the new method handle will drop the types for the bound * parameters from the original target type, since the new method handle * will no longer require those arguments to be supplied by its callers. @@ -1670,15 +1612,16 @@ * If a bound parameter type is a primitive, the argument object * must be a wrapper, and will be unboxed to produce the primitive value. * <p> - * The <i>pos</i> may range between zero and <i>N</i> (inclusively), - * where <i>N</i> is the number of argument types in resulting method handle - * (after bound parameter types are dropped). + * The {@code pos} argument selects which parameters are to be bound. + * It may range between zero and <i>N-L</i> (inclusively), + * where <i>N</i> is the arity of the target method handle + * and <i>L</i> is the length of the values array. * @param target the method handle to invoke after the argument is inserted * @param pos where to insert the argument (zero for the first) * @param values the series of arguments to insert * @return a method handle which inserts an additional argument, * before calling the original method handle - * @throws NullPointerException if the {@code target} argument or the {@code values} array is null + * @throws NullPointerException if the target or the {@code values} array is null * @see MethodHandle#bindTo */ public static @@ -1711,15 +1654,17 @@ } /** - * Produces a method handle which calls the original method handle, - * after dropping the given argument(s) at the given position. - * The type of the new method handle will insert the given argument - * type(s), at that position, into the original handle's type. + * Produces a method handle which will discard some dummy arguments + * before calling some other specified <i>target</i> method handle. + * The type of the new method handle will be the same as the target's type, + * except it will also include the dummy argument types, + * at some given position. * <p> - * The <i>pos</i> may range between zero and <i>N</i>, - * where <i>N</i> is the number of argument types in <i>target</i>, - * meaning to drop the first or last argument (respectively), - * or an argument somewhere in between. + * The {@code pos} argument may range between zero and <i>N</i>, + * where <i>N</i> is the arity of the target. + * If {@code pos} is zero, the dummy arguments will precede + * the target's real arguments; if {@code pos} is <i>N</i> + * they will come after. * <p> * <b>Example:</b> * <p><blockquote><pre> @@ -1744,14 +1689,16 @@ * @param pos position of first argument to drop (zero for the leftmost) * @return a method handle which drops arguments of the given types, * before calling the original method handle - * @throws NullPointerException if the {@code target} argument is null, + * @throws NullPointerException if the target is null, * or if the {@code valueTypes} list or any of its elements is null - * @throws IllegalArgumentException if any of the {@code valueTypes} is {@code void.class} + * @throws IllegalArgumentException if any element of {@code valueTypes} is {@code void.class}, + * or if {@code pos} is negative or greater than the arity of the target, + * or if the new method handle's type would have too many parameters */ public static MethodHandle dropArguments(MethodHandle target, int pos, List<Class<?>> valueTypes) { + MethodType oldType = target.type(); // get NPE if (valueTypes.size() == 0) return target; - MethodType oldType = target.type(); int outargs = oldType.parameterCount(); int inargs = outargs + valueTypes.size(); if (pos < 0 || pos >= inargs) @@ -1764,15 +1711,17 @@ } /** - * Produces a method handle which calls the original method handle, - * after dropping the given argument(s) at the given position. - * The type of the new method handle will insert the given argument - * type(s), at that position, into the original handle's type. + * Produces a method handle which will discard some dummy arguments + * before calling some other specified <i>target</i> method handle. + * The type of the new method handle will be the same as the target's type, + * except it will also include the dummy argument types, + * at some given position. * <p> - * The <i>pos</i> may range between zero and <i>N</i>, - * where <i>N</i> is the number of argument types in <i>target</i>, - * meaning to drop the first or last argument (respectively), - * or an argument somewhere in between. + * The {@code pos} argument may range between zero and <i>N</i>, + * where <i>N</i> is the arity of the target. + * If {@code pos} is zero, the dummy arguments will precede + * the target's real arguments; if {@code pos} is <i>N</i> + * they will come after. * <p> * <b>Example:</b> * <p><blockquote><pre> @@ -1801,9 +1750,11 @@ * @param pos position of first argument to drop (zero for the leftmost) * @return a method handle which drops arguments of the given types, * before calling the original method handle - * @throws NullPointerException if the {@code target} argument is null, + * @throws NullPointerException if the target is null, * or if the {@code valueTypes} array or any of its elements is null - * @throws IllegalArgumentException if any of the {@code valueTypes} is {@code void.class} + * @throws IllegalArgumentException if any element of {@code valueTypes} is {@code void.class}, + * or if {@code pos} is negative or greater than the arity of the target, + * or if the new method handle's type would have too many parameters */ public static MethodHandle dropArguments(MethodHandle target, int pos, Class<?>... valueTypes) { @@ -1811,19 +1762,23 @@ } /** - * Adapts a target method handle {@code target} by pre-processing + * Adapts a target method handle by pre-processing * one or more of its arguments, each with its own unary filter function, * and then calling the target with each pre-processed argument * replaced by the result of its corresponding filter function. * <p> * The pre-processing is performed by one or more method handles, * specified in the elements of the {@code filters} array. - * Null arguments in the array are ignored, and the corresponding arguments left unchanged. + * The first element of the filter array corresponds to the {@code pos} + * argument of the target, and so on in sequence. + * <p> + * Null arguments in the array are treated as identity functions, + * and the corresponding arguments left unchanged. * (If there are no non-null elements in the array, the original target is returned.) * Each filter is applied to the corresponding argument of the adapter. * <p> * If a filter {@code F} applies to the {@code N}th argument of - * the method handle, then {@code F} must be a method handle which + * the target, then {@code F} must be a method handle which * takes exactly one argument. The type of {@code F}'s sole argument * replaces the corresponding argument type of the target * in the resulting adapted method handle. @@ -1831,6 +1786,7 @@ * parameter type of the target. * <p> * It is an error if there are elements of {@code filters} + * (null or not) * which do not correspond to argument positions in the target. * <b>Example:</b> * <p><blockquote><pre> @@ -1849,15 +1805,23 @@ MethodHandle f2 = filterArguments(cat, 0, upcase, upcase); assertEquals("XY", (String) f2.invokeExact("x", "y")); // XY * </pre></blockquote> + * <p> Here is pseudocode for the resulting adapter: + * <blockquote><pre> + * V target(P... p, A[i]... a[i], B... b); + * A[i] filter[i](V[i]); + * T adapter(P... p, V[i]... v[i], B... b) { + * return target(p..., f[i](v[i])..., b...); + * } + * </pre></blockquote> * * @param target the method handle to invoke after arguments are filtered * @param pos the position of the first argument to filter * @param filters method handles to call initially on filtered arguments * @return method handle which incorporates the specified argument filtering logic - * @throws NullPointerException if the {@code target} argument is null + * @throws NullPointerException if the target is null * or if the {@code filters} array is null * @throws IllegalArgumentException if a non-null element of {@code filters} - * does not match a corresponding argument type of {@code target} as described above, + * does not match a corresponding argument type of target as described above, * or if the {@code pos+filters.length} is greater than {@code target.type().parameterCount()} */ public static @@ -1891,15 +1855,18 @@ } /** - * Adapts a target method handle {@code target} by post-processing - * its return value with a unary filter function. + * Adapts a target method handle by post-processing + * its return value (if any) with a filter (another method handle). + * The result of the filter is returned from the adapter. * <p> - * If a filter {@code F} applies to the return value of - * the target method handle, then {@code F} must be a method handle which - * takes exactly one argument. The return type of {@code F} + * If the target returns a value, the filter must accept that value as + * its only argument. + * If the target returns void, the filter must accept no arguments. + * <p> + * The return type of the filter * replaces the return type of the target * in the resulting adapted method handle. - * The argument type of {@code F} must be identical to the + * The argument type of the filter (if any) must be identical to the * return type of the target. * <b>Example:</b> * <p><blockquote><pre> @@ -1914,12 +1881,35 @@ MethodHandle f0 = filterReturnValue(cat, length); System.out.println((int) f0.invokeExact("x", "y")); // 2 * </pre></blockquote> + * <p> Here is pseudocode for the resulting adapter: + * <blockquote><pre> + * V target(A...); + * T filter(V); + * T adapter(A... a) { + * V v = target(a...); + * return filter(v); + * } + * // and if the target has a void return: + * void target2(A...); + * T filter2(); + * T adapter2(A... a) { + * target2(a...); + * return filter2(); + * } + * // and if the filter has a void return: + * V target3(A...); + * void filter3(V); + * void adapter3(A... a) { + * V v = target3(a...); + * filter3(v); + * } + * </pre></blockquote> * @param target the method handle to invoke before filtering the return value * @param filter method handle to call on the return value * @return method handle which incorporates the specified return value filtering logic * @throws NullPointerException if either argument is null - * @throws IllegalArgumentException if {@code filter} - * does not match the return type of {@code target} as described above + * @throws IllegalArgumentException if the argument list of {@code filter} + * does not match the return type of target as described above */ public static MethodHandle filterReturnValue(MethodHandle target, MethodHandle filter) { @@ -1948,55 +1938,87 @@ } /** - * Adapts a target method handle {@code target} by pre-processing + * Adapts a target method handle by pre-processing * some of its arguments, and then calling the target with - * the result of the pre-processing, plus all original arguments. + * the result of the pre-processing, inserted into the original + * sequence of arguments. + * <p> + * The pre-processing is performed by {@code combiner}, a second method handle. + * Of the arguments passed to the adapter, the first {@code N} arguments + * are copied to the combiner, which is then called. + * (Here, {@code N} is defined as the parameter count of the combiner.) + * After this, control passes to the target, with any result + * from the combiner inserted before the original {@code N} incoming + * arguments. * <p> - * The pre-processing is performed by a second method handle, the {@code combiner}. - * The first {@code N} arguments passed to the adapter, - * are copied to the combiner, which then produces a result. - * (Here, {@code N} is defined as the parameter count of the adapter.) - * After this, control passes to the {@code target}, with both the result - * of the combiner, and all the original incoming arguments. + * If the combiner returns a value, the first parameter type of the target + * must be identical with the return type of the combiner, and the next + * {@code N} parameter types of the target must exactly match the parameters + * of the combiner. * <p> - * The first argument type of the target must be identical with the - * return type of the combiner. + * If the combiner has a void return, no result will be inserted, + * and the first {@code N} parameter types of the target + * must exactly match the parameters of the combiner. + * <p> * The resulting adapter is the same type as the target, except that the - * initial argument type of the target is dropped. + * first parameter type is dropped, + * if it corresponds to the result of the combiner. * <p> * (Note that {@link #dropArguments(MethodHandle,int,List) dropArguments} can be used to remove any arguments - * that either the {@code combiner} or {@code target} does not wish to receive. + * that either the combiner or the target does not wish to receive. * If some of the incoming arguments are destined only for the combiner, * consider using {@link MethodHandle#asCollector asCollector} instead, since those * arguments will not need to be live on the stack on entry to the * target.) - * <p> - * The first argument of the target must be identical with the - * return value of the combiner. + * <b>Example:</b> + * <p><blockquote><pre> +import static java.lang.invoke.MethodHandles.*; +import static java.lang.invoke.MethodType.*; +... +MethodHandle trace = publicLookup().findVirtual(java.io.PrintStream.class, + "println", methodType(void.class, String.class)) + .bindTo(System.out); +MethodHandle cat = lookup().findVirtual(String.class, + "concat", methodType(String.class, String.class)); +assertEquals("boojum", (String) cat.invokeExact("boo", "jum")); +MethodHandle catTrace = foldArguments(cat, trace); +// also prints "boo": +assertEquals("boojum", (String) catTrace.invokeExact("boo", "jum")); + * </pre></blockquote> * <p> Here is pseudocode for the resulting adapter: * <blockquote><pre> - * // there are N arguments in the A sequence + * // there are N arguments in A... * T target(V, A[N]..., B...); * V combiner(A...); * T adapter(A... a, B... b) { * V v = combiner(a...); * return target(v, a..., b...); * } + * // and if the combiner has a void return: + * T target2(A[N]..., B...); + * void combiner2(A...); + * T adapter2(A... a, B... b) { + * combiner2(a...); + * return target2(a..., b...); + * } * </pre></blockquote> * @param target the method handle to invoke after arguments are combined * @param combiner method handle to call initially on the incoming arguments * @return method handle which incorporates the specified argument folding logic * @throws NullPointerException if either argument is null - * @throws IllegalArgumentException if the first argument type of - * {@code target} is not the same as {@code combiner}'s return type, - * or if the following argument types of {@code target} + * @throws IllegalArgumentException if {@code combiner}'s return type + * is non-void and not the same as the first argument type of + * the target, or if the initial {@code N} argument types + * of the target + * (skipping one matching the {@code combiner}'s return type) * are not identical with the argument types of {@code combiner} */ public static MethodHandle foldArguments(MethodHandle target, MethodHandle combiner) { + int pos = 0; MethodType targetType = target.type(); MethodType combinerType = combiner.type(); - int foldPos = 0; // always at the head, at present + int foldPos = pos; int foldArgs = combinerType.parameterCount(); int foldVals = combinerType.returnType() == void.class ? 0 : 1; int afterInsertPos = foldPos + foldVals; @@ -2045,7 +2067,7 @@ * @throws NullPointerException if any argument is null * @throws IllegalArgumentException if {@code test} does not return boolean, * or if all three method types do not match (with the return - * type of {@code test} changed to match that of {@code target}). + * type of {@code test} changed to match that of the target). */ public static MethodHandle guardWithTest(MethodHandle test, @@ -2135,7 +2157,7 @@ int hpc = hargs.size(), tpc = targs.size(); if (hpc >= tpc || !targs.subList(0, hpc).equals(hargs)) throw misMatchedTypes("target and handler types", ttype, htype); - handler = dropArguments(handler, hpc, hargs.subList(hpc, tpc)); + handler = dropArguments(handler, 1+hpc, targs.subList(hpc, tpc)); htype = handler.type(); } return MethodHandleImpl.makeGuardWithCatch(target, exType, handler); @@ -2155,234 +2177,4 @@ MethodHandle throwException(Class<?> returnType, Class<? extends Throwable> exType) { return MethodHandleImpl.throwException(MethodType.methodType(returnType, exType)); } - - /** - * Produces an instance of the given single-method interface which redirects - * its calls to the given method handle. - * <p> - * A single-method interface is an interface which declares a unique method. - * When determining the unique method of a single-method interface, - * the public {@code Object} methods ({@code toString}, {@code equals}, {@code hashCode}) - * are disregarded. For example, {@link java.util.Comparator} is a single-method interface, - * even though it re-declares the {@code Object.equals} method. - * <p> - * The type must be public. No additional access checks are performed. - * <p> - * The resulting instance of the required type will respond to - * invocation of the type's single abstract method by calling - * the given {@code target} on the incoming arguments, - * and returning or throwing whatever the {@code target} - * returns or throws. The invocation will be as if by - * {@code target.invoke}. - * The target's type will be checked before the - * instance is created, as if by a call to {@code asType}, - * which may result in a {@code WrongMethodTypeException}. - * <p> - * The wrapper instance will implement the requested interface - * and its super-types, but no other single-method interfaces. - * This means that the instance will not unexpectedly - * pass an {@code instanceof} test for any unrequested type. - * <p style="font-size:smaller;"> - * <em>Implementation Note:</em> - * Therefore, each instance must implement a unique single-method interface. - * Implementations may not bundle together - * multiple single-method interfaces onto single implementation classes - * in the style of {@link java.awt.AWTEventMulticaster}. - * <p> - * The method handle may throw an <em>undeclared exception</em>, - * which means any checked exception (or other checked throwable) - * not declared by the requested type's single abstract method. - * If this happens, the throwable will be wrapped in an instance of - * {@link java.lang.reflect.UndeclaredThrowableException UndeclaredThrowableException} - * and thrown in that wrapped form. - * <p> - * Like {@link java.lang.Integer#valueOf Integer.valueOf}, - * {@code asInstance} is a factory method whose results are defined - * by their behavior. - * It is not guaranteed to return a new instance for every call. - * <p> - * Because of the possibility of {@linkplain java.lang.reflect.Method#isBridge bridge methods} - * and other corner cases, the interface may also have several abstract methods - * with the same name but having distinct descriptors (types of returns and parameters). - * In this case, all the methods are bound in common to the one given {@code target}. - * The type check and effective {@code asType} conversion is applied to each - * method type descriptor, and all abstract methods are bound to the {@code target} in common. - * Beyond this type check, no further checks are made to determine that the - * abstract methods are related in any way. - * <p> - * Future versions of this API may accept additional types, - * such as abstract classes with single abstract methods. - * Future versions of this API may also equip wrapper instances - * with one or more additional public "marker" interfaces. - * - * @param target the method handle to invoke from the wrapper - * @param smType the desired type of the wrapper, a single-method interface - * @return a correctly-typed wrapper for the given {@code target} - * @throws NullPointerException if either argument is null - * @throws IllegalArgumentException if the {@code smType} is not a - * valid argument to this method - * @throws WrongMethodTypeException if the {@code target} cannot - * be converted to the type required by the requested interface - */ - // Other notes to implementors: - // <p> - // No stable mapping is promised between the single-method interface and - // the implementation class C. Over time, several implementation - // classes might be used for the same type. - // <p> - // If the implementation is able - // to prove that a wrapper of the required type - // has already been created for a given - // method handle, or for another method handle with the - // same behavior, the implementation may return that wrapper in place of - // a new wrapper. - // <p> - // This method is designed to apply to common use cases - // where a single method handle must interoperate with - // an interface that implements a function-like - // API. Additional variations, such as single-abstract-method classes with - // private constructors, or interfaces with multiple but related - // entry points, must be covered by hand-written or automatically - // generated adapter classes. - // - public static - <T> T asInstance(final MethodHandle target, final Class<T> smType) { - // POC implementation only; violates the above contract several ways - final Method sm = getSingleMethod(smType); - if (sm == null) - throw new IllegalArgumentException("not a single-method interface: "+smType.getName()); - MethodType smMT = MethodType.methodType(sm.getReturnType(), sm.getParameterTypes()); - MethodHandle checkTarget = target.asType(smMT); // make throw WMT - checkTarget = checkTarget.asType(checkTarget.type().changeReturnType(Object.class)); - final MethodHandle vaTarget = checkTarget.asSpreader(Object[].class, smMT.parameterCount()); - return smType.cast(Proxy.newProxyInstance( - smType.getClassLoader(), - new Class[]{ smType, WrapperInstance.class }, - new InvocationHandler() { - private Object getArg(String name) { - if ((Object)name == "getWrapperInstanceTarget") return target; - if ((Object)name == "getWrapperInstanceType") return smType; - throw new AssertionError(); - } - public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { - if (method.getDeclaringClass() == WrapperInstance.class) - return getArg(method.getName()); - if (method.equals(sm)) - return vaTarget.invokeExact(args); - if (isObjectMethod(method)) - return callObjectMethod(this, method, args); - throw new InternalError(); - } - })); - } - - /** - * Determines if the given object was produced by a call to {@link #asInstance asInstance}. - * @param x any reference - * @return true if the reference is not null and points to an object produced by {@code asInstance} - */ - public static - boolean isWrapperInstance(Object x) { - return x instanceof WrapperInstance; - } - - private static WrapperInstance asWrapperInstance(Object x) { - try { - if (x != null) - return (WrapperInstance) x; - } catch (ClassCastException ex) { - } - throw new IllegalArgumentException("not a wrapper instance"); - } - - /** - * Produces or recovers a target method handle which is behaviorally - * equivalent to the unique method of this wrapper instance. - * The object {@code x} must have been produced by a call to {@link #asInstance asInstance}. - * This requirement may be tested via {@link #isWrapperInstance isWrapperInstance}. - * @param x any reference - * @return a method handle implementing the unique method - * @throws IllegalArgumentException if the reference x is not to a wrapper instance - */ - public static - MethodHandle wrapperInstanceTarget(Object x) { - return asWrapperInstance(x).getWrapperInstanceTarget(); - } - - /** - * Recovers the unique single-method interface type for which this wrapper instance was created. - * The object {@code x} must have been produced by a call to {@link #asInstance asInstance}. - * This requirement may be tested via {@link #isWrapperInstance isWrapperInstance}. - * @param x any reference - * @return the single-method interface type for which the wrapper was created - * @throws IllegalArgumentException if the reference x is not to a wrapper instance - */ - public static - Class<?> wrapperInstanceType(Object x) { - return asWrapperInstance(x).getWrapperInstanceType(); - } - - private static - boolean isObjectMethod(Method m) { - switch (m.getName()) { - case "toString": - return (m.getReturnType() == String.class - && m.getParameterTypes().length == 0); - case "hashCode": - return (m.getReturnType() == int.class - && m.getParameterTypes().length == 0); - case "equals": - return (m.getReturnType() == boolean.class - && m.getParameterTypes().length == 1 - && m.getParameterTypes()[0] == Object.class); - } - return false; - } - - private static - Object callObjectMethod(Object self, Method m, Object[] args) { - assert(isObjectMethod(m)) : m; - switch (m.getName()) { - case "toString": - return self.getClass().getName() + "@" + Integer.toHexString(self.hashCode()); - case "hashCode": - return System.identityHashCode(self); - case "equals": - return (self == args[0]); - } - return null; - } - - private static - Method getSingleMethod(Class<?> smType) { - Method sm = null; - for (Method m : smType.getMethods()) { - int mod = m.getModifiers(); - if (Modifier.isAbstract(mod)) { - if (sm != null && !isObjectMethod(sm)) - return null; // too many abstract methods - sm = m; - } - } - if (!smType.isInterface() && getSingleConstructor(smType) == null) - return null; // wrong kind of constructor - return sm; - } - - private static - Constructor getSingleConstructor(Class<?> smType) { - for (Constructor c : smType.getDeclaredConstructors()) { - if (c.getParameterTypes().length == 0) { - int mod = c.getModifiers(); - if (Modifier.isPublic(mod) || Modifier.isProtected(mod)) - return c; - } - } - return null; - } - - /*non-public*/ - static MethodHandle asVarargsCollector(MethodHandle target, Class<?> arrayType) { - return MethodHandleImpl.asVarargsCollector(target, arrayType); - } }
--- a/src/share/classes/java/lang/invoke/MethodType.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/java/lang/invoke/MethodType.java Sat Jun 04 06:52:01 2011 -0700 @@ -163,7 +163,13 @@ public static MethodType methodType(Class<?> rtype, List<Class<?>> ptypes) { boolean notrust = false; // random List impl. could return evil ptypes array - return makeImpl(rtype, ptypes.toArray(NO_PTYPES), notrust); + return makeImpl(rtype, listToArray(ptypes), notrust); + } + + private static Class<?>[] listToArray(List<Class<?>> ptypes) { + // sanity check the size before the toArray call, since size might be huge + checkSlotCount(ptypes.size()); + return ptypes.toArray(NO_PTYPES); } /** @@ -228,7 +234,7 @@ */ /*trusted*/ static MethodType makeImpl(Class<?> rtype, Class<?>[] ptypes, boolean trusted) { - if (ptypes == null || ptypes.length == 0) { + if (ptypes.length == 0) { ptypes = NO_PTYPES; trusted = true; } MethodType mt1 = new MethodType(rtype, ptypes); @@ -267,7 +273,7 @@ * @param objectArgCount number of parameters (excluding the final array parameter if any) * @param finalArray whether there will be a trailing array parameter, of type {@code Object[]} * @return a generally applicable method type, for all calls of the given fixed argument count and a collected array of further arguments - * @throws IllegalArgumentException if {@code objectArgCount} is negative or greater than 255 (or 254, if {@code finalArray}) + * @throws IllegalArgumentException if {@code objectArgCount} is negative or greater than 255 (or 254, if {@code finalArray} is true) * @see #genericMethodType(int) */ public static @@ -372,7 +378,7 @@ * @throws NullPointerException if {@code ptypesToInsert} or any of its elements is null */ public MethodType insertParameterTypes(int num, List<Class<?>> ptypesToInsert) { - return insertParameterTypes(num, ptypesToInsert.toArray(NO_PTYPES)); + return insertParameterTypes(num, listToArray(ptypesToInsert)); } /** @@ -449,7 +455,8 @@ /** * Reports if this type contains a wrapper argument or return value. * Wrappers are types which box primitive values, such as {@link Integer}. - * The reference type {@code java.lang.Void} counts as a wrapper. + * The reference type {@code java.lang.Void} counts as a wrapper, + * if it occurs as a return type. * @return true if any of the types are wrappers */ public boolean hasWrappers() { @@ -641,14 +648,57 @@ } return true; } - private static boolean canConvert(Class<?> src, Class<?> dst) { - if (src == dst || dst == void.class) return true; - if (src.isPrimitive() && dst.isPrimitive()) { - if (!Wrapper.forPrimitiveType(dst) - .isConvertibleFrom(Wrapper.forPrimitiveType(src))) + /*non-public*/ + static boolean canConvert(Class<?> src, Class<?> dst) { + // short-circuit a few cases: + if (src == dst || dst == Object.class) return true; + // the remainder of this logic is documented in MethodHandle.asType + if (src.isPrimitive()) { + // can force void to an explicit null, a la reflect.Method.invoke + // can also force void to a primitive zero, by analogy + if (src == void.class) return true; //or !dst.isPrimitive()? + Wrapper sw = Wrapper.forPrimitiveType(src); + if (dst.isPrimitive()) { + // P->P must widen + return Wrapper.forPrimitiveType(dst).isConvertibleFrom(sw); + } else { + // P->R must box and widen + return dst.isAssignableFrom(sw.wrapperType()); + } + } else if (dst.isPrimitive()) { + // any value can be dropped + if (dst == void.class) return true; + Wrapper dw = Wrapper.forPrimitiveType(dst); + // R->P must be able to unbox (from a dynamically chosen type) and widen + // For example: + // Byte/Number/Comparable/Object -> dw:Byte -> byte. + // Character/Comparable/Object -> dw:Character -> char + // Boolean/Comparable/Object -> dw:Boolean -> boolean + // This means that dw must be cast-compatible with src. + if (src.isAssignableFrom(dw.wrapperType())) { + return true; + } + // The above does not work if the source reference is strongly typed + // to a wrapper whose primitive must be widened. For example: + // Byte -> unbox:byte -> short/int/long/float/double + // Character -> unbox:char -> int/long/float/double + if (Wrapper.isWrapperType(src) && + dw.isConvertibleFrom(Wrapper.forWrapperType(src))) { + // can unbox from src and then widen to dst + return true; + } + // We have already covered cases which arise due to runtime unboxing + // of a reference type which covers several wrapper types: + // Object -> cast:Integer -> unbox:int -> long/float/double + // Serializable -> cast:Byte -> unbox:byte -> byte/short/int/long/float/double + // An marginal case is Number -> dw:Character -> char, which would be OK if there were a + // subclass of Number which wraps a value that can convert to char. + // Since there is none, we don't need an extra check here to cover char or boolean. return false; + } else { + // R->R always works, since null is always valid dynamically + return true; } - return true; } /// Queries which have to do with the bytecode architecture @@ -733,15 +783,21 @@ * @param descriptor a bytecode-level type descriptor string "(T...)T" * @param loader the class loader in which to look up the types * @return a method type matching the bytecode-level type descriptor + * @throws NullPointerException if the string is null * @throws IllegalArgumentException if the string is not well-formed * @throws TypeNotPresentException if a named type cannot be found */ public static MethodType fromMethodDescriptorString(String descriptor, ClassLoader loader) throws IllegalArgumentException, TypeNotPresentException { + if (!descriptor.startsWith("(") || // also generates NPE if needed + descriptor.indexOf(')') < 0 || + descriptor.indexOf('.') >= 0) + throw new IllegalArgumentException("not a method descriptor: "+descriptor); List<Class<?>> types = BytecodeDescriptor.parseMethod(descriptor, loader); Class<?> rtype = types.remove(types.size() - 1); - Class<?>[] ptypes = types.toArray(NO_PTYPES); + checkSlotCount(types.size()); + Class<?>[] ptypes = listToArray(types); return makeImpl(rtype, ptypes, true); }
--- a/src/share/classes/java/lang/invoke/MethodTypeForm.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/java/lang/invoke/MethodTypeForm.java Sat Jun 04 06:52:01 2011 -0700 @@ -448,6 +448,8 @@ Class<?>[] cs = null; for (int imax = ts.length, i = 0; i < imax; i++) { Class<?> c = canonicalize(ts[i], how); + if (c == void.class) + c = null; // a Void parameter was unwrapped to void; ignore if (c != null) { if (cs == null) cs = ts.clone();
--- a/src/share/classes/java/lang/invoke/MutableCallSite.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/java/lang/invoke/MutableCallSite.java Sat Jun 04 06:52:01 2011 -0700 @@ -37,12 +37,13 @@ * <p> * Here is an example of a mutable call site which introduces a * state variable into a method handle chain. + * <!-- JavaDocExamplesTest.testMutableCallSite --> * <blockquote><pre> MutableCallSite name = new MutableCallSite(MethodType.methodType(String.class)); MethodHandle MH_name = name.dynamicInvoker(); -MethodType MT_str2 = MethodType.methodType(String.class, String.class); +MethodType MT_str1 = MethodType.methodType(String.class); MethodHandle MH_upcase = MethodHandles.lookup() - .findVirtual(String.class, "toUpperCase", MT_str2); + .findVirtual(String.class, "toUpperCase", MT_str1); MethodHandle worker1 = MethodHandles.filterReturnValue(MH_name, MH_upcase); name.setTarget(MethodHandles.constant(String.class, "Rocky")); assertEquals("ROCKY", (String) worker1.invokeExact()); @@ -53,8 +54,10 @@ * <p> * The same call site may be used in several places at once. * <blockquote><pre> -MethodHandle MH_dear = MethodHandles.lookup() - .findVirtual(String.class, "concat", MT_str2).bindTo(", dear?"); +MethodType MT_str2 = MethodType.methodType(String.class, String.class); +MethodHandle MH_cat = lookup().findVirtual(String.class, + "concat", methodType(String.class, String.class)); +MethodHandle MH_dear = MethodHandles.insertArguments(MH_cat, 1, ", dear?"); MethodHandle worker2 = MethodHandles.filterReturnValue(MH_name, MH_dear); assertEquals("Fred, dear?", (String) worker2.invokeExact()); name.setTarget(MethodHandles.constant(String.class, "Wilma"));
--- a/src/share/classes/java/lang/invoke/SpreadGeneric.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/java/lang/invoke/SpreadGeneric.java Sat Jun 04 06:52:01 2011 -0700 @@ -126,7 +126,7 @@ return spreadGen; } - public String toString() { + String debugString() { return getClass().getSimpleName()+targetType+"["+spreadCount+"]"; } @@ -224,7 +224,7 @@ protected final MethodHandle target; // (any**N) => R @Override - public String toString() { + String debugString() { return addTypeString(target, this); }
--- a/src/share/classes/java/lang/invoke/SwitchPoint.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/java/lang/invoke/SwitchPoint.java Sat Jun 04 06:52:01 2011 -0700 @@ -56,16 +56,17 @@ * <p> * Here is an example of a switch point in action: * <blockquote><pre> -MethodType MT_str2 = MethodType.methodType(String.class, String.class); MethodHandle MH_strcat = MethodHandles.lookup() - .findVirtual(String.class, "concat", MT_str2); + .findVirtual(String.class, "concat", MethodType.methodType(String.class, String.class)); SwitchPoint spt = new SwitchPoint(); +assert(spt.isValid()); // the following steps may be repeated to re-use the same switch point: -MethodHandle worker1 = strcat; -MethodHandle worker2 = MethodHandles.permuteArguments(strcat, MT_str2, 1, 0); +MethodHandle worker1 = MH_strcat; +MethodHandle worker2 = MethodHandles.permuteArguments(MH_strcat, MH_strcat.type(), 1, 0); MethodHandle worker = spt.guardWithTest(worker1, worker2); assertEquals("method", (String) worker.invokeExact("met", "hod")); SwitchPoint.invalidateAll(new SwitchPoint[]{ spt }); +assert(!spt.isValid()); assertEquals("hodmet", (String) worker.invokeExact("met", "hod")); * </pre></blockquote> * <p style="font-size:smaller;"> @@ -125,6 +126,19 @@ } /** + * Determines if this switch point is still valid. + * <p> + * Since invalidation is a global and immediate operation, + * this query must be sequenced with any + * other threads that could invalidate this switch point. + * It may therefore be expensive. + * @return true if this switch point has never been invalidated + */ + public boolean isValid() { + return (mcs.getTarget() == K_true); + } + + /** * Returns a method handle which always delegates either to the target or the fallback. * The method handle will delegate to the target exactly as long as the switch point is valid. * After that, it will permanently delegate to the fallback. @@ -136,6 +150,7 @@ * @param fallback the method handle selected by the switch point after it is invalidated * @return a combined method handle which always calls either the target or fallback * @throws NullPointerException if either argument is null + * @throws IllegalArgumentException if the two method types do not match * @see MethodHandles#guardWithTest */ public MethodHandle guardWithTest(MethodHandle target, MethodHandle fallback) {
--- a/src/share/classes/java/lang/invoke/ToGeneric.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/java/lang/invoke/ToGeneric.java Sat Jun 04 06:52:01 2011 -0700 @@ -258,7 +258,7 @@ return toGen; } - public String toString() { + String debugString() { return "ToGeneric"+entryType +(primsAtEndOrder!=null?"[reorder]":""); } @@ -340,7 +340,7 @@ protected final MethodHandle convert; // Object -> R @Override - public String toString() { + String debugString() { return target == null ? "prototype:"+convert : addTypeString(target, this); }
--- a/src/share/classes/java/lang/invoke/package-info.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/java/lang/invoke/package-info.java Sat Jun 04 06:52:01 2011 -0700 @@ -28,7 +28,8 @@ * the Java core class libraries and virtual machine. * * <p> - * Certain types in this package have special relations to dynamic + * As described in the Java Virtual Machine Specification, + * certain types in this package have special relations to dynamic * language support in the virtual machine: * <ul> * <li>The class {@link java.lang.invoke.MethodHandle MethodHandle} contains @@ -42,177 +43,16 @@ * </li> * </ul> * - * <h2><a name="jvm_mods"></a>Corresponding JVM bytecode format changes</h2> - * <em>The following low-level information is presented here as a preview of - * changes being made to the Java Virtual Machine specification for JSR 292. - * This information will be incorporated in a future version of the JVM specification.</em> + * <h2><a name="jvm_mods"></a>Summary of relevant Java Virtual Machine changes</h2> + * The following low-level information summarizes relevant parts of the + * Java Virtual Machine specification. For full details, please see the + * current version of that specification. * - * <h3><a name="indyinsn"></a>{@code invokedynamic} instruction format</h3> - * In bytecode, an {@code invokedynamic} instruction is formatted as five bytes. - * The first byte is the opcode 186 (hexadecimal {@code BA}). - * The next two bytes are a constant pool index (in the same format as for the other {@code invoke} instructions). - * The final two bytes are reserved for future use and required to be zero. - * The constant pool reference of an {@code invokedynamic} instruction is to a entry - * with tag {@code CONSTANT_InvokeDynamic} (decimal 18). See below for its format. - * The entry specifies the following information: - * <ul> - * <li>a bootstrap method (a {@link java.lang.invoke.MethodHandle MethodHandle} constant)</li> - * <li>the dynamic invocation name (a UTF8 string)</li> - * <li>the argument and return types of the call (encoded as a type descriptor in a UTF8 string)</li> - * <li>optionally, a sequence of additional <em>static arguments</em> to the bootstrap method ({@code ldc}-type constants)</li> - * </ul> - * <p> - * Each instance of an {@code invokedynamic} instruction is called a <em>dynamic call site</em>. - * Multiple instances of an {@code invokedynamic} instruction can share a single - * {@code CONSTANT_InvokeDynamic} entry. - * In any case, distinct call sites always have distinct linkage state. - * <p> + * Each occurrence of an {@code invokedynamic} instruction is called a <em>dynamic call site</em>. + * <h3><a name="indyinsn"></a>{@code invokedynamic} instructions</h3> * A dynamic call site is originally in an unlinked state. In this state, there is * no target method for the call site to invoke. - * A dynamic call site is linked by means of a bootstrap method, - * as <a href="#bsm">described below</a>. - * - * <h3><a name="indycon"></a>constant pool entries for {@code invokedynamic} instructions</h3> - * If a constant pool entry has the tag {@code CONSTANT_InvokeDynamic} (decimal 18), - * it must contain exactly four more bytes after the tag. - * These bytes are interpreted as two 16-bit indexes, in the usual {@code u2} format. - * The first pair of bytes after the tag must be an index into a side table called the - * <em>bootstrap method table</em>, which is stored in the {@code BootstrapMethods} - * attribute as <a href="#bsmattr">described below</a>. - * The second pair of bytes must be an index to a {@code CONSTANT_NameAndType}. * <p> - * The first index specifies a bootstrap method used by the associated dynamic call sites. - * The second index specifies the method name, argument types, and return type of the dynamic call site. - * The structure of such an entry is therefore analogous to a {@code CONSTANT_Methodref}, - * except that the bootstrap method specifier reference replaces - * the {@code CONSTANT_Class} reference of a {@code CONSTANT_Methodref} entry. - * - * <h3><a name="mtcon"></a>constant pool entries for {@linkplain java.lang.invoke.MethodType method types}</h3> - * If a constant pool entry has the tag {@code CONSTANT_MethodType} (decimal 16), - * it must contain exactly two more bytes, which must be an index to a {@code CONSTANT_Utf8} - * entry which represents a method type descriptor. - * <p> - * The JVM will ensure that on first - * execution of an {@code ldc} instruction for this entry, a {@link java.lang.invoke.MethodType MethodType} - * will be created which represents the type descriptor. - * Any classes mentioned in the {@code MethodType} will be loaded if necessary, - * but not initialized. - * Access checking and error reporting is performed exactly as it is for - * references by {@code ldc} instructions to {@code CONSTANT_Class} constants. - * - * <h3><a name="mhcon"></a>constant pool entries for {@linkplain java.lang.invoke.MethodHandle method handles}</h3> - * If a constant pool entry has the tag {@code CONSTANT_MethodHandle} (decimal 15), - * it must contain exactly three more bytes. The first byte after the tag is a subtag - * value which must be in the range 1 through 9, and the last two must be an index to a - * {@code CONSTANT_Fieldref}, {@code CONSTANT_Methodref}, or - * {@code CONSTANT_InterfaceMethodref} entry which represents a field or method - * for which a method handle is to be created. - * Furthermore, the subtag value and the type of the constant index value - * must agree according to the table below. - * <p> - * The JVM will ensure that on first execution of an {@code ldc} instruction - * for this entry, a {@link java.lang.invoke.MethodHandle MethodHandle} will be created which represents - * the field or method reference, according to the specific mode implied by the subtag. - * <p> - * As with {@code CONSTANT_Class} and {@code CONSTANT_MethodType} constants, - * the {@code Class} or {@code MethodType} object which reifies the field or method's - * type is created. Any classes mentioned in this reification will be loaded if necessary, - * but not initialized, and access checking and error reporting performed as usual. - * <p> - * Unlike the reflective {@code Lookup} API, there are no security manager calls made - * when these constants are resolved. - * <p> - * The method handle itself will have a type and behavior determined by the subtag as follows: - * <code> - * <table border=1 cellpadding=5 summary="CONSTANT_MethodHandle subtypes"> - * <tr><th>N</th><th>subtag name</th><th>member</th><th>MH type</th><th>bytecode behavior</th><th>lookup expression</th></tr> - * <tr><td>1</td><td>REF_getField</td><td>C.f:T</td><td>(C)T</td><td>getfield C.f:T</td> - * <td>{@linkplain java.lang.invoke.MethodHandles.Lookup#findGetter findGetter(C.class,"f",T.class)}</td></tr> - * <tr><td>2</td><td>REF_getStatic</td><td>C.f:T</td><td>( )T</td><td>getstatic C.f:T</td> - * <td>{@linkplain java.lang.invoke.MethodHandles.Lookup#findStaticGetter findStaticGetter(C.class,"f",T.class)}</td></tr> - * <tr><td>3</td><td>REF_putField</td><td>C.f:T</td><td>(C,T)void</td><td>putfield C.f:T</td> - * <td>{@linkplain java.lang.invoke.MethodHandles.Lookup#findSetter findSetter(C.class,"f",T.class)}</td></tr> - * <tr><td>4</td><td>REF_putStatic</td><td>C.f:T</td><td>(T)void</td><td>putstatic C.f:T</td> - * <td>{@linkplain java.lang.invoke.MethodHandles.Lookup#findStaticSetter findStaticSetter(C.class,"f",T.class)}</td></tr> - * <tr><td>5</td><td>REF_invokeVirtual</td><td>C.m(A*)T</td><td>(C,A*)T</td><td>invokevirtual C.m(A*)T</td> - * <td>{@linkplain java.lang.invoke.MethodHandles.Lookup#findVirtual findVirtual(C.class,"m",MT)}</td></tr> - * <tr><td>6</td><td>REF_invokeStatic</td><td>C.m(A*)T</td><td>(C,A*)T</td><td>invokestatic C.m(A*)T</td> - * <td>{@linkplain java.lang.invoke.MethodHandles.Lookup#findStatic findStatic(C.class,"m",MT)}</td></tr> - * <tr><td>7</td><td>REF_invokeSpecial</td><td>C.m(A*)T</td><td>(C,A*)T</td><td>invokespecial C.m(A*)T</td> - * <td>{@linkplain java.lang.invoke.MethodHandles.Lookup#findSpecial findSpecial(C.class,"m",MT,this.class)}</td></tr> - * <tr><td>8</td><td>REF_newInvokeSpecial</td><td>C.<init>(A*)void</td><td>(A*)C</td><td>new C; dup; invokespecial C.<init>(A*)void</td> - * <td>{@linkplain java.lang.invoke.MethodHandles.Lookup#findConstructor findConstructor(C.class,MT)}</td></tr> - * <tr><td>9</td><td>REF_invokeInterface</td><td>C.m(A*)T</td><td>(C,A*)T</td><td>invokeinterface C.m(A*)T</td> - * <td>{@linkplain java.lang.invoke.MethodHandles.Lookup#findVirtual findVirtual(C.class,"m",MT)}</td></tr> - * </table> - * </code> - * Here, the type {@code C} is taken from the {@code CONSTANT_Class} reference associated - * with the {@code CONSTANT_NameAndType} descriptor. - * The field name {@code f} or method name {@code m} is taken from the {@code CONSTANT_NameAndType} - * as is the result type {@code T} and (in the case of a method or constructor) the argument type sequence - * {@code A*}. - * <p> - * Each method handle constant has an equivalent instruction sequence called its <em>bytecode behavior</em>. - * In general, creating a method handle constant can be done in exactly the same circumstances that - * the JVM would successfully resolve the symbolic references in the bytecode behavior. - * Also, the type of a method handle constant is such that a valid {@code invokeExact} call - * on the method handle has exactly the same JVM stack effects as the <em>bytecode behavior</em>. - * Finally, calling a method handle constant on a valid set of arguments has exactly the same effect - * and returns the same result (if any) as the corresponding <em>bytecode behavior</em>. - * <p> - * Each method handle constant also has an equivalent reflective <em>lookup expression</em>, - * which is a query to a method in {@link java.lang.invoke.MethodHandles.Lookup}. - * In the example lookup method expression given in the table above, the name {@code MT} - * stands for a {@code MethodType} built from {@code T} and the sequence of argument types {@code A*}. - * (Note that the type {@code C} is not prepended to the query type {@code MT} even if the member is non-static.) - * In the case of {@code findSpecial}, the name {@code this.class} refers to the class containing - * the bytecodes. - * <p> - * The special name {@code <clinit>} is not allowed. - * The special name {@code <init>} is not allowed except for subtag 8 as shown. - * <p> - * The JVM verifier and linker apply the same access checks and restrictions for these references as for the hypothetical - * bytecode instructions specified in the last column of the table. - * A method handle constant will successfully resolve to a method handle if the symbolic references - * of the corresponding bytecode instruction(s) would also resolve successfully. - * Otherwise, an attempt to resolve the constant will throw equivalent linkage errors. - * In particular, method handles to - * private and protected members can be created in exactly those classes for which the corresponding - * normal accesses are legal. - * <p> - * A constant may refer to a method or constructor with the {@code varargs} - * bit (hexadecimal {@code 0x0080}) set in its modifier bitmask. - * The method handle constant produced for such a method behaves as if - * it were created by {@link java.lang.invoke.MethodHandle#asVarargsCollector asVarargsCollector}. - * In other words, the constant method handle will exhibit variable arity, - * when invoked via {@code MethodHandle.invoke}. - * On the other hand, its behavior with respect to {@code invokeExact} will be the same - * as if the {@code varargs} bit were not set. - * <p> - * Although the {@code CONSTANT_MethodHandle} and {@code CONSTANT_MethodType} constant types - * resolve class names, they do not force class initialization. - * Method handle constants for subtags {@code REF_getStatic}, {@code REF_putStatic}, and {@code REF_invokeStatic} - * may force class initialization on their first invocation, just like the corresponding bytecodes. - * <p> - * The rules of section 5.4.3 of - * <cite>The Java™ Virtual Machine Specification</cite> - * apply to the resolution of {@code CONSTANT_MethodType}, {@code CONSTANT_MethodHandle}, - * and {@code CONSTANT_InvokeDynamic} constants, - * by the execution of {@code invokedynamic} and {@code ldc} instructions. - * (Roughly speaking, this means that every use of a constant pool entry - * must lead to the same outcome. - * If the resolution succeeds, the same object reference is produced - * by every subsequent execution of the same instruction. - * If the resolution of the constant causes an error to occur, - * the same error will be re-thrown on every subsequent attempt - * to use this particular constant.) - * <p> - * Constants created by the resolution of these constant pool types are not necessarily - * interned. Except for {@code CONSTANT_Class} and {@code CONSTANT_String} entries, - * two distinct constant pool entries might not resolve to the same reference - * even if they contain the same symbolic reference. - * - * <h2><a name="bsm"></a>Bootstrap Methods</h2> * Before the JVM can execute a dynamic call site (an {@code invokedynamic} instruction), * the call site must first be <em>linked</em>. * Linking is accomplished by calling a <em>bootstrap method</em> @@ -234,15 +74,14 @@ * call site execution. * Linkage does not trigger class initialization. * <p> - * Next, the bootstrap method call is started, with at least four values being stacked: + * The bootstrap method is invoked on at least three values: * <ul> - * <li>a {@code MethodHandle}, the resolved bootstrap method itself </li> * <li>a {@code MethodHandles.Lookup}, a lookup object on the <em>caller class</em> in which dynamic call site occurs </li> * <li>a {@code String}, the method name mentioned in the call site </li> * <li>a {@code MethodType}, the resolved type descriptor of the call </li> - * <li>optionally, one or more <a href="#args">additional static arguments</a> </li> + * <li>optionally, between 1 and 251 additional static arguments taken from the constant pool </li> * </ul> - * The method handle is then applied to the other values as if by + * Invocation is as if by * {@link java.lang.invoke.MethodHandle#invoke MethodHandle.invoke}. * The returned result must be a {@link java.lang.invoke.CallSite CallSite} (or a subclass). * The type of the call site's target must be exactly equal to the type @@ -250,38 +89,15 @@ * the bootstrap method. * The call site then becomes permanently linked to the dynamic call site. * <p> - * As long as each bootstrap method can be correctly invoked - * by <code>MethodHandle.invoke</code>, its detailed type is arbitrary. - * For example, the first argument could be {@code Object} - * instead of {@code MethodHandles.Lookup}, and the return type - * could also be {@code Object} instead of {@code CallSite}. - * (Note that the types and number of the stacked arguments limit - * the legal kinds of bootstrap methods to appropriately typed - * static methods and constructors of {@code CallSite} subclasses.) - * <p> - * After resolution, the linkage process may fail in a variety of ways. - * All failures are reported by a {@link java.lang.BootstrapMethodError BootstrapMethodError}, + * As documented in the JVM specification, all failures arising from + * the linkage of a dynamic call site are reported + * by a {@link java.lang.BootstrapMethodError BootstrapMethodError}, * which is thrown as the abnormal termination of the dynamic call * site execution. - * The following circumstances will cause this: - * <ul> - * <li>the index to the bootstrap method specifier is out of range </li> - * <li>the bootstrap method cannot be resolved </li> - * <li>the {@code MethodType} to pass to the bootstrap method cannot be resolved </li> - * <li>a static argument to the bootstrap method cannot be resolved - * (i.e., a {@code CONSTANT_Class}, {@code CONSTANT_MethodType}, - * or {@code CONSTANT_MethodHandle} argument cannot be linked) </li> - * <li>the bootstrap method has the wrong arity, - * causing {@code MethodHandle.invoke} to throw {@code WrongMethodTypeException} </li> - * <li>the bootstrap method has a wrong argument or return type </li> - * <li>the bootstrap method invocation completes abnormally </li> - * <li>the result from the bootstrap invocation is not a reference to - * an object of type {@link java.lang.invoke.CallSite CallSite} </li> - * <li>the target of the {@code CallSite} does not have a target of - * the expected {@code MethodType} </li> - * </ul> + * If this happens, the same error will the thrown for all subsequent + * attempts to execute the dynamic call site. * - * <h3><a name="linktime"></a>timing of linkage</h3> + * <h3>timing of linkage</h3> * A dynamic call site is linked just before its first execution. * The bootstrap method call implementing the linkage occurs within * a thread that is attempting a first execution. @@ -306,7 +122,7 @@ * all threads. Any other bootstrap method calls are allowed to complete, but their * results are ignored, and their dynamic call site invocations proceed with the originally * chosen target object. - * + * <p style="font-size:smaller;"> * <em>Discussion:</em> * These rules do not enable the JVM to duplicate dynamic call sites, @@ -315,64 +131,15 @@ * just before its first invocation. * There is no way to undo the effect of a completed bootstrap method call. * - * <h3><a name="bsmattr">the {@code BootstrapMethods} attribute </h3> - * Each {@code CONSTANT_InvokeDynamic} entry contains an index which references - * a bootstrap method specifier; all such specifiers are contained in a separate array. - * This array is defined by a class attribute named {@code BootstrapMethods}. - * The body of this attribute consists of a sequence of byte pairs, all interpreted as - * as 16-bit counts or constant pool indexes, in the {@code u2} format. - * The attribute body starts with a count of bootstrap method specifiers, - * which is immediately followed by the sequence of specifiers. - * <p> - * Each bootstrap method specifier contains an index to a - * {@code CONSTANT_MethodHandle} constant, which is the bootstrap - * method itself. - * This is followed by a count, and then a sequence (perhaps empty) of - * indexes to <a href="#args">additional static arguments</a> - * for the bootstrap method. - * <p> - * During class loading, the verifier must check the structure of the - * {@code BootstrapMethods} attribute. In particular, each constant - * pool index must be of the correct type. A bootstrap method index - * must refer to a {@code CONSTANT_MethodHandle} (tag 15). - * Every other index must refer to a valid operand of an - * {@code ldc_w} or {@code ldc2_w} instruction (tag 3..8 or 15..16). - * - * <h3><a name="args">static arguments to the bootstrap method</h3> - * An {@code invokedynamic} instruction specifies at least three arguments - * to pass to its bootstrap method: - * The caller class (expressed as a {@link java.lang.invoke.MethodHandles.Lookup Lookup object}, - * the name (extracted from the {@code CONSTANT_NameAndType} entry), - * and the type (also extracted from the {@code CONSTANT_NameAndType} entry). - * The {@code invokedynamic} instruction may specify additional metadata values - * to pass to its bootstrap method. - * Collectively, these values are called <em>static arguments</em> to the - * {@code invokedynamic} instruction, because they are used once at link - * time to determine the instruction's behavior on subsequent sets of - * <em>dynamic arguments</em>. - * <p> - * Static arguments are used to communicate application-specific meta-data - * to the bootstrap method. - * Drawn from the constant pool, they may include references to classes, method handles, - * strings, or numeric data that may be relevant to the task of linking that particular call site. - * <p> - * Static arguments are specified constant pool indexes stored in the {@code BootstrapMethods} attribute. - * Before the bootstrap method is invoked, each index is used to compute an {@code Object} - * reference to the indexed value in the constant pool. - * The valid constant pool entries are listed in this table: - * <code> - * <table border=1 cellpadding=5 summary="Static argument types"> - * <tr><th>entry type</th><th>argument type</th><th>argument value</th></tr> - * <tr><td>CONSTANT_String</td><td><code>java.lang.String</code></td><td>the indexed string literal</td></tr> - * <tr><td>CONSTANT_Class</td><td><code>java.lang.Class</code></td><td>the indexed class, resolved</td></tr> - * <tr><td>CONSTANT_Integer</td><td><code>java.lang.Integer</code></td><td>the indexed int value</td></tr> - * <tr><td>CONSTANT_Long</td><td><code>java.lang.Long</code></td><td>the indexed long value</td></tr> - * <tr><td>CONSTANT_Float</td><td><code>java.lang.Float</code></td><td>the indexed float value</td></tr> - * <tr><td>CONSTANT_Double</td><td><code>java.lang.Double</code></td><td>the indexed double value</td></tr> - * <tr><td>CONSTANT_MethodHandle</td><td><code>java.lang.invoke.MethodHandle</code></td><td>the indexed method handle constant</td></tr> - * <tr><td>CONSTANT_MethodType</td><td><code>java.lang.invoke.MethodType</code></td><td>the indexed method type constant</td></tr> - * </table> - * </code> + * <h3>types of bootstrap methods</h3> + * As long as each bootstrap method can be correctly invoked + * by {@code MethodHandle.invoke}, its detailed type is arbitrary. + * For example, the first argument could be {@code Object} + * instead of {@code MethodHandles.Lookup}, and the return type + * could also be {@code Object} instead of {@code CallSite}. + * (Note that the types and number of the stacked arguments limit + * the legal kinds of bootstrap methods to appropriately typed + * static methods and constructors of {@code CallSite} subclasses.) * <p> * If a given {@code invokedynamic} instruction specifies no static arguments, * the instruction's bootstrap method will be invoked on three arguments, @@ -380,7 +147,8 @@ * If the {@code invokedynamic} instruction specifies one or more static arguments, * those values will be passed as additional arguments to the method handle. * (Note that because there is a limit of 255 arguments to any method, - * at most 252 extra arguments can be supplied.) + * at most 251 extra arguments can be supplied, since the bootstrap method + * handle itself and its first three arguments must also be stacked.) * The bootstrap method will be invoked as if by either {@code MethodHandle.invoke} * or {@code invokeWithArguments}. (There is no way to tell the difference.) * <p> @@ -390,12 +158,11 @@ * then some or all of the arguments specified here may be collected into a trailing array parameter. * (This is not a special rule, but rather a useful consequence of the interaction * between {@code CONSTANT_MethodHandle} constants, the modifier bit for variable arity methods, - * and the {@code java.lang.invoke.MethodHandle#asVarargsCollector asVarargsCollector} transformation.) + * and the {@link java.lang.invoke.MethodHandle#asVarargsCollector asVarargsCollector} transformation.) * <p> * Given these rules, here are examples of legal bootstrap method declarations, * given various numbers {@code N} of extra arguments. * The first rows (marked {@code *}) will work for any number of extra arguments. - * <code> * <table border=1 cellpadding=5 summary="Static argument types"> * <tr><th>N</th><th>sample bootstrap method</th></tr> * <tr><td>*</td><td><code>CallSite bootstrap(Lookup caller, String name, MethodType type, Object... args)</code></td></tr> @@ -408,7 +175,6 @@ * <tr><td>2</td><td><code>CallSite bootstrap(Lookup caller, String name, MethodType type, String... args)</code></td></tr> * <tr><td>2</td><td><code>CallSite bootstrap(Lookup caller, String name, MethodType type, String x, int y)</code></td></tr> * </table> - * </code> * The last example assumes that the extra arguments are of type * {@code CONSTANT_String} and {@code CONSTANT_Integer}, respectively. * The second-to-last example assumes that all extra arguments are of type @@ -431,34 +197,6 @@ * since each call site could be given its own unique bootstrap method. * Such a practice is likely to produce large class files and constant pools. * - * <h2><a name="structs"></a>Structure Summary</h2> - * <blockquote><pre>// summary of constant and attribute structures -struct CONSTANT_MethodHandle_info { - u1 tag = 15; - u1 reference_kind; // 1..8 (one of REF_invokeVirtual, etc.) - u2 reference_index; // index to CONSTANT_Fieldref or *Methodref -} -struct CONSTANT_MethodType_info { - u1 tag = 16; - u2 descriptor_index; // index to CONSTANT_Utf8, as in NameAndType -} -struct CONSTANT_InvokeDynamic_info { - u1 tag = 18; - u2 bootstrap_method_attr_index; // index into BootstrapMethods_attr - u2 name_and_type_index; // index to CONSTANT_NameAndType, as in Methodref -} -struct BootstrapMethods_attr { - u2 name; // CONSTANT_Utf8 = "BootstrapMethods" - u4 size; - u2 bootstrap_method_count; - struct bootstrap_method_specifier { - u2 bootstrap_method_ref; // index to CONSTANT_MethodHandle - u2 bootstrap_argument_count; - u2 bootstrap_arguments[bootstrap_argument_count]; // constant pool indexes - } bootstrap_methods[bootstrap_method_count]; -} - * </pre></blockquote> - * * @author John Rose, JSR 292 EG * @since 1.7 */
--- a/src/share/classes/java/nio/file/Path.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/java/nio/file/Path.java Sat Jun 04 06:52:01 2011 -0700 @@ -460,15 +460,13 @@ /** * Returns a URI to represent this path. * - * <p> This method constructs a hierarchical {@link URI} that is absolute - * with a non-empty path component. Its {@link URI#getScheme() scheme} is - * equal to the URI scheme that identifies the provider. The exact form of - * the other URI components is highly provider dependent. In particular, it - * is implementation dependent if its query, fragment, and authority - * components are defined or undefined. + * <p> This method constructs an absolute {@link URI} with a {@link + * URI#getScheme() scheme} equal to the URI scheme that identifies the + * provider. The exact form of the scheme specific part is highly provider + * dependent. * - * <p> For the default provider the {@link URI#getPath() path} component - * will represent the {@link #toAbsolutePath absolute} path; the query, + * <p> In the case of the default provider, the URI is hierarchical with + * a {@link URI#getPath() path} component that is absolute. The query and * fragment components are undefined. Whether the authority component is * defined or not is implementation dependent. There is no guarantee that * the {@code URI} may be used to construct a {@link java.io.File java.io.File}. @@ -497,7 +495,7 @@ * A format for compound URIs is not defined in this release; such a scheme * may be added in a future release. * - * @return an absolute, hierarchical URI with a non-empty path component + * @return the URI representing this path * * @throws java.io.IOError * if an I/O error occurs obtaining the absolute path, or where a
--- a/src/share/classes/javax/swing/plaf/nimbus/NimbusLookAndFeel.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/javax/swing/plaf/nimbus/NimbusLookAndFeel.java Sat Jun 04 06:52:01 2011 -0700 @@ -588,6 +588,10 @@ } private void addDefault(String key, Object value) { + if (compiledDefaults == null) { + return; + } + String prefix = parsePrefix(key); if (prefix != null) { Map<String, Object> keys = compiledDefaults.get(prefix);
--- a/src/share/classes/javax/swing/text/Utilities.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/javax/swing/text/Utilities.java Sat Jun 04 06:52:01 2011 -0700 @@ -337,8 +337,7 @@ // x before x0, return. return 0; } - int currX = x0; - int nextX = currX; + int nextX = x0; // s may be a shared segment, so it is copied prior to calling // the tab expander char[] txt = s.array; @@ -388,19 +387,45 @@ } else { nextX += metrics.charWidth(txt[i]); } - if ((x >= currX) && (x < nextX)) { + if (x < nextX) { // found the hit position... return the appropriate side - int offset = ((round == false) || ((x - currX) < (nextX - x))) ? - (i - txtOffset) : (i + 1 - txtOffset); + int offset; + // the length of the string measured as a whole may differ from // the sum of individual character lengths, for example if // fractional metrics are enabled; and we must guard from this. - while (offset > 0 && metrics.charsWidth(txt, txtOffset, offset) > (x - x0)) { - offset--; + if (round) { + offset = i + 1 - txtOffset; + + int width = metrics.charsWidth(txt, txtOffset, offset); + int span = x - x0; + + if (span < width) { + while (offset > 0) { + int nextWidth = offset > 1 ? metrics.charsWidth(txt, txtOffset, offset - 1) : 0; + + if (span >= nextWidth) { + if (span - nextWidth < width - span) { + offset--; + } + + break; + } + + width = nextWidth; + offset--; + } + } + } else { + offset = i - txtOffset; + + while (offset > 0 && metrics.charsWidth(txt, txtOffset, offset) > (x - x0)) { + offset--; + } } + return offset; } - currX = nextX; } // didn't find, return end offset
--- a/src/share/classes/sun/font/FileFontStrike.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/sun/font/FileFontStrike.java Sat Jun 04 06:52:01 2011 -0700 @@ -180,7 +180,6 @@ pScalerContext = NullFontScaler.getNullScalerContext(); } else { pScalerContext = fileFont.getScaler().createScalerContext(matrix, - fileFont instanceof TrueTypeFont, desc.aaHint, desc.fmHint, boldness, italic, disableHinting); }
--- a/src/share/classes/sun/font/FontScaler.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/sun/font/FontScaler.java Sat Jun 04 06:52:01 2011 -0700 @@ -242,7 +242,6 @@ freed when corresponding strike is being released. */ abstract long createScalerContext(double[] matrix, - boolean fontType, int aa, int fm, float boldness, float italic, boolean disableHinting);
--- a/src/share/classes/sun/font/FreetypeFontScaler.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/sun/font/FreetypeFontScaler.java Sat Jun 04 06:52:01 2011 -0700 @@ -210,12 +210,12 @@ return getUnitsPerEMNative(nativeScaler); } - long createScalerContext(double[] matrix, boolean fontType, + long createScalerContext(double[] matrix, int aa, int fm, float boldness, float italic, boolean disableHinting) { if (nativeScaler != 0L) { return createScalerContextNative(nativeScaler, matrix, - fontType, aa, fm, boldness, italic); + aa, fm, boldness, italic); } return NullFontScaler.getNullScalerContext(); } @@ -254,7 +254,7 @@ private native long getUnitsPerEMNative(long pScaler); native long createScalerContextNative(long pScaler, double[] matrix, - boolean fontType, int aa, int fm, float boldness, float italic); + int aa, int fm, float boldness, float italic); /* Freetype scaler context does not contain any pointers that has to be invalidated if native scaler is bad */
--- a/src/share/classes/sun/font/NullFontScaler.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/sun/font/NullFontScaler.java Sat Jun 04 06:52:01 2011 -0700 @@ -66,7 +66,7 @@ long getLayoutTableCache() {return 0L;} - long createScalerContext(double[] matrix, boolean fontType, int aa, + long createScalerContext(double[] matrix, int aa, int fm, float boldness, float italic, boolean disableHinting) { return getNullScalerContext(); }
--- a/src/share/classes/sun/invoke/util/ValueConversions.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/sun/invoke/util/ValueConversions.java Sat Jun 04 06:52:01 2011 -0700 @@ -198,27 +198,30 @@ return unbox(Wrapper.forPrimitiveType(type), true, false); } + static private final Integer ZERO_INT = 0, ONE_INT = 1; + /// Primitive conversions public static Number primitiveConversion(Wrapper wrap, Object x, boolean cast) { // Maybe merge this code with Wrapper.convert/cast. Number res = null; if (x == null) { if (!cast) return null; - x = wrap.zero(); + return ZERO_INT; } if (x instanceof Number) { res = (Number) x; } else if (x instanceof Boolean) { - res = ((boolean)x ? 1 : 0); + 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; } - if (!cast && !wrap.isConvertibleFrom(Wrapper.forWrapperType(x.getClass()))) + Wrapper xwrap = Wrapper.findWrapperType(x.getClass()); + if (xwrap == null || !cast && !wrap.isConvertibleFrom(xwrap)) // this will fail with the required ClassCastException: - res = (Number) wrap.wrapperType().cast(x); + return (Number) wrap.wrapperType().cast(x); return res; }
--- a/src/share/classes/sun/invoke/util/VerifyAccess.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/sun/invoke/util/VerifyAccess.java Sat Jun 04 06:52:01 2011 -0700 @@ -154,9 +154,10 @@ * @return whether they are in the same package */ public static boolean isSamePackage(Class<?> class1, Class<?> class2) { + assert(!class1.isArray() && !class2.isArray()); if (class1 == class2) return true; - if (!loadersAreRelated(class1.getClassLoader(), class2.getClassLoader())) + if (!loadersAreRelated(class1.getClassLoader(), class2.getClassLoader(), false)) return false; String name1 = class1.getName(), name2 = class2.getName(); int dot = name1.lastIndexOf('.'); @@ -169,6 +170,16 @@ return true; } + /** Return the package name for this class. + */ + public static String getPackageName(Class<?> cls) { + assert(!cls.isArray()); + String name = cls.getName(); + int dot = name.lastIndexOf('.'); + if (dot < 0) return ""; + return name.substring(0, dot); + } + /** * Test if two classes are defined as part of the same package member (top-level class). * If this is true, they can share private access with each other. @@ -193,18 +204,33 @@ return pkgmem; } - private static boolean loadersAreRelated(ClassLoader loader1, ClassLoader loader2) { - if (loader1 == loader2 || loader1 == null || loader2 == null) { + private static boolean loadersAreRelated(ClassLoader loader1, ClassLoader loader2, + boolean loader1MustBeParent) { + if (loader1 == loader2 || loader1 == null + || (loader2 == null && !loader1MustBeParent)) { return true; } - for (ClassLoader scan1 = loader1; - scan1 != null; scan1 = scan1.getParent()) { - if (scan1 == loader2) return true; - } for (ClassLoader scan2 = loader2; scan2 != null; scan2 = scan2.getParent()) { if (scan2 == loader1) return true; } + if (loader1MustBeParent) return false; + // see if loader2 is a parent of loader1: + for (ClassLoader scan1 = loader1; + scan1 != null; scan1 = scan1.getParent()) { + if (scan1 == loader2) return true; + } return false; } + + /** + * Is the class loader of parentClass identical to, or an ancestor of, + * the class loader of childClass? + * @param parentClass + * @param childClass + * @return whether parentClass precedes or equals childClass in class loader order + */ + public static boolean classLoaderIsAncestor(Class<?> parentClass, Class<?> childClass) { + return loadersAreRelated(parentClass.getClassLoader(), childClass.getClassLoader(), true); + } }
--- a/src/share/classes/sun/invoke/util/Wrapper.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/sun/invoke/util/Wrapper.java Sat Jun 04 06:52:01 2011 -0700 @@ -135,7 +135,7 @@ * <li>any type converted to {@code void} (i.e., dropping a method call's value) * <li>boxing conversion followed by widening reference conversion to {@code Object} * </ul> - * These are the cases allowed by MethodHandle.asType and convertArguments. + * These are the cases allowed by MethodHandle.asType. */ public boolean isConvertibleFrom(Wrapper source) { if (this == source) return true; @@ -258,7 +258,7 @@ } /** Return the wrapper that wraps values into the given wrapper type. - * If it is {@code Object} or an interface, return {@code OBJECT}. + * If it is {@code Object}, return {@code OBJECT}. * Otherwise, it must be a wrapper type. * The type must not be a primitive type. * @throws IllegalArgumentException for unexpected types @@ -277,8 +277,6 @@ if (w != null && w.wrapperType == type) { return w; } - if (type.isInterface()) - return OBJECT; return null; }
--- a/src/share/classes/sun/io/ByteToCharCp833.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/sun/io/ByteToCharCp833.java Sat Jun 04 06:52:01 2011 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2010 Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2010, 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
--- a/src/share/classes/sun/io/CharToByteCp833.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/sun/io/CharToByteCp833.java Sat Jun 04 06:52:01 2011 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2010 Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2010, 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
--- a/src/share/classes/sun/misc/FpUtils.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/sun/misc/FpUtils.java Sat Jun 04 06:52:01 2011 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, 2010 Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 2010, 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
--- a/src/share/classes/sun/security/provider/certpath/URICertStore.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/classes/sun/security/provider/certpath/URICertStore.java Sat Jun 04 06:52:01 2011 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2006, 2010 Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2006, 2010, 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
--- a/src/share/native/sun/font/freetypeScaler.c Sat Jun 04 06:45:17 2011 -0700 +++ b/src/share/native/sun/font/freetypeScaler.c Sat Jun 04 06:52:01 2011 -0700 @@ -367,7 +367,7 @@ JNIEXPORT jlong JNICALL Java_sun_font_FreetypeFontScaler_createScalerContextNative( JNIEnv *env, jobject scaler, jlong pScaler, jdoubleArray matrix, - jboolean ttFont, jint aa, jint fm, jfloat boldness, jfloat italic) { + jint aa, jint fm, jfloat boldness, jfloat italic) { double dmat[4], ptsz; FTScalerContext *context = (FTScalerContext*) calloc(1, sizeof(FTScalerContext));
--- a/src/solaris/classes/sun/awt/X11/GtkFileDialogPeer.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/solaris/classes/sun/awt/X11/GtkFileDialogPeer.java Sat Jun 04 06:52:01 2011 -0700 @@ -29,8 +29,6 @@ import java.awt.peer.FileDialogPeer; import java.io.File; import java.io.FilenameFilter; -import javax.swing.SwingUtilities; -import javax.swing.SwingWorker; import sun.awt.AWTAccessor; /** @@ -107,9 +105,7 @@ if (b) { Thread t = new Thread() { public void run() { - GtkFileDialogPeer.this.run(fd.getTitle(), fd.getMode(), - fd.getDirectory(), fd.getFile(), fd.getFilenameFilter(), fd.isMultipleMode(), - fd.getX(), fd.getY()); + showNativeDialog(); fd.setVisible(false); } }; @@ -146,4 +142,30 @@ // We do not implement this method because we // have delegated to FileDialog#setFilenameFilter } + + private void showNativeDialog() { + String dirname = fd.getDirectory(); + // File path has a priority against directory path. + String filename = fd.getFile(); + if (filename != null) { + final File file = new File(filename); + if (fd.getMode() == FileDialog.LOAD + && dirname != null + && file.getParent() == null) { + // File path for gtk_file_chooser_set_filename. + filename = dirname + (dirname.endsWith(File.separator) ? "" : + File.separator) + filename; + } + if (fd.getMode() == FileDialog.SAVE && file.getParent() != null) { + // Filename for gtk_file_chooser_set_current_name. + filename = file.getName(); + // Directory path for gtk_file_chooser_set_current_folder. + dirname = file.getParent(); + } + } + GtkFileDialogPeer.this.run(fd.getTitle(), fd.getMode(), dirname, + filename, fd.getFilenameFilter(), + fd.isMultipleMode(), fd.getX(), fd.getY()); + } + }
--- a/src/solaris/classes/sun/awt/X11GraphicsEnvironment.java Sat Jun 04 06:45:17 2011 -0700 +++ b/src/solaris/classes/sun/awt/X11GraphicsEnvironment.java Sat Jun 04 06:52:01 2011 -0700 @@ -121,7 +121,7 @@ // only attempt to initialize Xrender if it was requested if (xRenderRequested) { - xRenderAvailable = initXRender(); + xRenderAvailable = initXRender(xRenderVerbose); if (xRenderVerbose && !xRenderAvailable) { System.out.println( "Could not enable XRender pipeline"); @@ -159,7 +159,7 @@ private static boolean xRenderVerbose; private static boolean xRenderAvailable; - private static native boolean initXRender(); + private static native boolean initXRender(boolean verbose); public static boolean isXRenderAvailable() { return xRenderAvailable; }
--- a/src/solaris/doc/sun/man/man1/ja/keytool.1 Sat Jun 04 06:45:17 2011 -0700 +++ b/src/solaris/doc/sun/man/man1/ja/keytool.1 Sat Jun 04 06:52:01 2011 -0700 @@ -1,4 +1,4 @@ -." Copyright (c) 1998-2011 keytool tool, Oracle and/or its affiliates. All rights reserved. +." Copyright (c) 1998, 2011, 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
--- a/src/solaris/doc/sun/man/man1/keytool.1 Sat Jun 04 06:45:17 2011 -0700 +++ b/src/solaris/doc/sun/man/man1/keytool.1 Sat Jun 04 06:52:01 2011 -0700 @@ -1,4 +1,4 @@ -." Copyright (c) 1998-2011 keytool tool, Oracle and/or its affiliates. All rights reserved. +." Copyright (c) 1998, 2011, 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
--- a/src/solaris/native/sun/java2d/x11/XRBackendNative.c Sat Jun 04 06:45:17 2011 -0700 +++ b/src/solaris/native/sun/java2d/x11/XRBackendNative.c Sat Jun 04 06:52:01 2011 -0700 @@ -66,9 +66,10 @@ } XRadialGradient; #endif +#include <dlfcn.h> + #ifdef __solaris__ /* Solaris 10 will not have these symbols at runtime */ -#include <dlfcn.h> #include <link.h> typedef Picture (*XRenderCreateLinearGradientFuncType) @@ -104,12 +105,20 @@ TRANSFORM.matrix[2][2] = 1<<16; \ } +/* The xrender pipleine requires libXrender.so version 0.9.3 or later. */ +#define REQUIRED_XRENDER_VER1 0 +#define REQUIRED_XRENDER_VER2 9 +#define REQUIRED_XRENDER_VER3 3 -static jboolean IsXRenderAvailable() { +#define PKGINFO_LINE_LEN_MAX 256 +#define PKGINFO_LINE_CNT_MAX 50 + +static jboolean IsXRenderAvailable(jboolean verbose) { void *xrenderlib; int major_opcode, first_event, first_error; + jboolean available = JNI_TRUE; if (!XQueryExtension(awt_display, "RENDER", &major_opcode, &first_event, &first_error)) { @@ -120,23 +129,113 @@ xrenderlib = dlopen("libXrender.so",RTLD_GLOBAL|RTLD_LAZY); if (xrenderlib != NULL) { - XRenderCreateLinearGradientFunc = - (XRenderCreateLinearGradientFuncType) - dlsym(xrenderlib, "XRenderCreateLinearGradient"); + XRenderCreateLinearGradientFunc = + (XRenderCreateLinearGradientFuncType) + dlsym(xrenderlib, "XRenderCreateLinearGradient"); + + XRenderCreateRadialGradientFunc = + (XRenderCreateRadialGradientFuncType) + dlsym(xrenderlib, "XRenderCreateRadialGradient"); + + if (XRenderCreateLinearGradientFunc == NULL || + XRenderCreateRadialGradientFunc == NULL) + { + available = JNI_FALSE; + } + dlclose(xrenderlib); + } else { + available = JNI_FALSE; + } +#else + Dl_info info; + jboolean versionInfoIsFound = JNI_FALSE; + + memset(&info, 0, sizeof(Dl_info)); + if (dladdr(&XRenderChangePicture, &info) && info.dli_fname != NULL) { + char pkgInfoPath[FILENAME_MAX]; + char *pkgFileName = "/pkgconfig/xrender.pc"; + size_t pkgFileNameLen = strlen(pkgFileName); + size_t pos, len = strlen(info.dli_fname); + + pos = len; + while (pos > 0 && info.dli_fname[pos] != '/') { + pos -= 1; + } + + if (pos > 0 && pos < (FILENAME_MAX - pkgFileNameLen - 1)) { + struct stat stat_info; + + // compose absolute filename to package config + strncpy(pkgInfoPath, info.dli_fname, pos); + + strcpy(pkgInfoPath + pos, pkgFileName); + pkgInfoPath[pos + pkgFileNameLen] = '\0'; - XRenderCreateRadialGradientFunc = - (XRenderCreateRadialGradientFuncType) - dlsym(xrenderlib, "XRenderCreateRadialGradient"); + // check whether the config file exist and is a regular file + if ((stat(pkgInfoPath, &stat_info)== 0) && + S_ISREG(stat_info.st_mode)) + { + FILE *fp = fopen(pkgInfoPath, "r"); + if (fp != NULL) { + char line[PKGINFO_LINE_LEN_MAX]; + int lineCount = PKGINFO_LINE_CNT_MAX; + char *versionPrefix = "Version: "; + size_t versionPrefixLen = strlen(versionPrefix); + + // look for version + while(fgets(line,sizeof(line),fp) != NULL && --lineCount > 0) { + size_t lineLen = strlen(line); + + if (lineLen > versionPrefixLen && + strncmp(versionPrefix, line, versionPrefixLen) == 0) + { + int v1 = 0, v2 = 0, v3 = 0; + int numNeeded = 3,numProcessed; + char* version = line + versionPrefixLen; + numProcessed = sscanf(version, "%d.%d.%d", &v1, &v2, &v3); + + if (numProcessed == numNeeded) { + // we successfuly read the library version + versionInfoIsFound = JNI_TRUE; - if (XRenderCreateLinearGradientFunc == NULL || - XRenderCreateRadialGradientFunc == NULL) - { - dlclose(xrenderlib); - return JNI_FALSE; + if (REQUIRED_XRENDER_VER1 == v1 && + ((REQUIRED_XRENDER_VER2 > v2) || + ((REQUIRED_XRENDER_VER2 == v2) && (REQUIRED_XRENDER_VER3 > v3)))) + { + available = JNI_FALSE; + + if (verbose) { + printf("INFO: the version %d.%d.%d of libXrender.so is " + "not supported.\n\tSee release notes for more details.\n", + v1, v2, v3); + fflush(stdout); + } + } else { + if (verbose) { + printf("INFO: The version of libXrender.so " + "is detected as %d.%d%d\n", v1, v2, v3); + fflush(stdout); + } + } + } + break; + } + } + fclose(fp); + } } + } + } + if (verbose && !versionInfoIsFound) { + printf("WARNING: The version of libXrender.so cannot be detected.\n," + "The pipe line will be enabled, but note that versions less than 0.9.3\n" + "may cause hangs and crashes\n" + "\tSee the release notes for more details.\n"); + fflush(stdout); } #endif - return JNI_TRUE; + + return available; } /* * Class: sun_awt_X11GraphicsEnvironment @@ -145,7 +244,7 @@ */ JNIEXPORT jboolean JNICALL Java_sun_awt_X11GraphicsEnvironment_initXRender - (JNIEnv *env, jclass x11ge) +(JNIEnv *env, jclass x11ge, jboolean verbose) { #ifndef HEADLESS static jboolean xrenderAvailable = JNI_FALSE; @@ -153,7 +252,7 @@ if (firstTime) { AWT_LOCK(); - xrenderAvailable = IsXRenderAvailable(); + xrenderAvailable = IsXRenderAvailable(verbose); AWT_UNLOCK(); firstTime = JNI_FALSE; }
--- a/src/windows/native/sun/windows/awt_Component.cpp Sat Jun 04 06:45:17 2011 -0700 +++ b/src/windows/native/sun/windows/awt_Component.cpp Sat Jun 04 06:52:01 2011 -0700 @@ -3715,7 +3715,10 @@ SetCandidateWindow(iCandType, x-rc.left, y-rc.top); } if (m_bitsCandType != 0) { - ::DefWindowProc(GetHWnd(), WM_IME_NOTIFY, IMN_OPENCANDIDATE, m_bitsCandType); + HWND proxy = GetProxyFocusOwner(); + // REMIND: is there any chance GetProxyFocusOwner() returns NULL here? + ::DefWindowProc((proxy != NULL) ? proxy : GetHWnd(), + WM_IME_NOTIFY, IMN_OPENCANDIDATE, m_bitsCandType); } }
--- a/src/windows/native/sun/windows/awt_Object.cpp Sat Jun 04 06:45:17 2011 -0700 +++ b/src/windows/native/sun/windows/awt_Object.cpp Sat Jun 04 06:52:01 2011 -0700 @@ -69,9 +69,12 @@ CriticalSection::Lock l(AwtToolkit::GetInstance().GetSyncCS()); + JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2); + jobject selfGlobalRef = env->NewGlobalRef(self); + // value 0 of lParam means that we should not attempt to enter the // SyncCall critical section, as it was entered someshere earlier - AwtToolkit::GetInstance().SendMessage(WM_AWT_DISPOSE, (WPARAM)self, (LPARAM)0); + AwtToolkit::GetInstance().SendMessage(WM_AWT_DISPOSE, (WPARAM)selfGlobalRef, (LPARAM)0); CATCH_BAD_ALLOC; }
--- a/src/windows/native/sun/windows/awt_Toolkit.cpp Sat Jun 04 06:45:17 2011 -0700 +++ b/src/windows/native/sun/windows/awt_Toolkit.cpp Sat Jun 04 06:52:01 2011 -0700 @@ -741,7 +741,9 @@ } if (canDispose) { if(wParam != NULL) { - AwtObject *o = (AwtObject *) JNI_GET_PDATA((jobject)wParam); + jobject self = (jobject)wParam; + AwtObject *o = (AwtObject *) JNI_GET_PDATA(self); + env->DeleteGlobalRef(self); if(o != NULL && theAwtObjectList.Remove(o)) { o->Dispose(); }
--- a/test/com/sun/net/httpserver/Test10.java Sat Jun 04 06:45:17 2011 -0700 +++ b/test/com/sun/net/httpserver/Test10.java Sat Jun 04 06:52:01 2011 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2010 Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2010, 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
--- a/test/java/awt/List/ScrollOutside/ScrollOut.java Sat Jun 04 06:45:17 2011 -0700 +++ b/test/java/awt/List/ScrollOutside/ScrollOut.java Sat Jun 04 06:52:01 2011 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011 Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2011, 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
--- a/test/java/awt/event/MouseWheelEvent/InfiniteRecursion/InfiniteRecursion.java Sat Jun 04 06:45:17 2011 -0700 +++ b/test/java/awt/event/MouseWheelEvent/InfiniteRecursion/InfiniteRecursion.java Sat Jun 04 06:52:01 2011 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2007, 2011 Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2007, 2011, 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
--- a/test/java/awt/event/MouseWheelEvent/InfiniteRecursion/InfiniteRecursion_1.java Sat Jun 04 06:45:17 2011 -0700 +++ b/test/java/awt/event/MouseWheelEvent/InfiniteRecursion/InfiniteRecursion_1.java Sat Jun 04 06:52:01 2011 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2007, 2011 Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2007, 2011, 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
--- a/test/java/awt/event/MouseWheelEvent/InfiniteRecursion/InfiniteRecursion_2.java Sat Jun 04 06:45:17 2011 -0700 +++ b/test/java/awt/event/MouseWheelEvent/InfiniteRecursion/InfiniteRecursion_2.java Sat Jun 04 06:52:01 2011 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2007, 2011 Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2007, 2011, 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
--- a/test/java/awt/event/MouseWheelEvent/InfiniteRecursion/InfiniteRecursion_3.java Sat Jun 04 06:45:17 2011 -0700 +++ b/test/java/awt/event/MouseWheelEvent/InfiniteRecursion/InfiniteRecursion_3.java Sat Jun 04 06:52:01 2011 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2007, 2011 Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2007, 2011, 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
--- a/test/java/awt/event/MouseWheelEvent/InfiniteRecursion/InfiniteRecursion_4.java Sat Jun 04 06:45:17 2011 -0700 +++ b/test/java/awt/event/MouseWheelEvent/InfiniteRecursion/InfiniteRecursion_4.java Sat Jun 04 06:52:01 2011 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2007, 2011 Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2007, 2011, 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
--- a/test/java/awt/image/IncorrectSampleMaskTest.java Sat Jun 04 06:45:17 2011 -0700 +++ b/test/java/awt/image/IncorrectSampleMaskTest.java Sat Jun 04 06:52:01 2011 -0700 @@ -1,5 +1,5 @@ /* - * Copyright 2009 Sun Microsystems, Inc. All Rights Reserved. + * Copyright (c) 2009, 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 @@ -16,10 +16,10 @@ * 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, - * CA 95054 USA or visit www.sun.com if you need additional information or - * have any questions. - */ + * 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. +*/ /* * @test
--- a/test/java/lang/invoke/6991596/Test6991596.java Sat Jun 04 06:45:17 2011 -0700 +++ b/test/java/lang/invoke/6991596/Test6991596.java Sat Jun 04 06:52:01 2011 -0700 @@ -51,10 +51,10 @@ return MethodHandles.lookup().findStatic(CLASS, NAME, MethodType.methodType(ret, arg)); } static MethodHandle getmh2(MethodHandle mh1, Class ret, Class arg) { - return MethodHandles.convertArguments(mh1, MethodType.methodType(ret, arg)); + return MethodHandles.explicitCastArguments(mh1, MethodType.methodType(ret, arg)); } static MethodHandle getmh3(MethodHandle mh1, Class ret, Class arg) { - return MethodHandles.convertArguments(mh1, MethodType.methodType(ret, arg)); + return MethodHandles.explicitCastArguments(mh1, MethodType.methodType(ret, arg)); } // test adapter_opt_i2i
--- a/test/java/lang/invoke/6998541/Test6998541.java Sat Jun 04 06:45:17 2011 -0700 +++ b/test/java/lang/invoke/6998541/Test6998541.java Sat Jun 04 06:52:01 2011 -0700 @@ -164,6 +164,7 @@ private static boolean canDoAsType(Class<?> src, Class<?> dst) { if (src == dst) return true; if (dst == void.class) return true; + if (src == void.class) return true; // allow void->zero if (!src.isPrimitive() || !dst.isPrimitive()) return true; // primitive conversion works for asType only when it's widening if (src == boolean.class || dst == boolean.class) return false; @@ -451,7 +452,6 @@ private final static MethodHandle mh_dv = mh(double.class ); private static void void2prim(int i) throws Throwable { - if (!DO_CASTS) return; assertEquals( false, (boolean) mh_zv.invokeExact()); // void -> boolean assertEquals((byte) 0, (byte) mh_bv.invokeExact()); // void -> byte assertEquals((char) 0, (char) mh_cv.invokeExact()); // void -> char @@ -463,15 +463,7 @@ } private static void void2prim_invalid(double x) throws Throwable { - if (DO_CASTS) return; - try { assertEquals( false, (boolean) mh_zv.invokeExact()); fail(); } catch (NullPointerException _) {} // void -> boolean - try { assertEquals((byte) 0, (byte) mh_bv.invokeExact()); fail(); } catch (NullPointerException _) {} // void -> byte - try { assertEquals((char) 0, (char) mh_cv.invokeExact()); fail(); } catch (NullPointerException _) {} // void -> char - try { assertEquals((short) 0, (short) mh_sv.invokeExact()); fail(); } catch (NullPointerException _) {} // void -> short - try { assertEquals( 0, (int) mh_iv.invokeExact()); fail(); } catch (NullPointerException _) {} // void -> int - try { assertEquals( 0L, (long) mh_jv.invokeExact()); fail(); } catch (NullPointerException _) {} // void -> long - try { assertEquals( 0.0f, (float) mh_fv.invokeExact()); fail(); } catch (NullPointerException _) {} // void -> float - try { assertEquals( 0.0d, (double) mh_dv.invokeExact()); fail(); } catch (NullPointerException _) {} // void -> double + // no cases } private static MethodHandle mh_v(Class arg) { return mh(void.class, arg); }
--- a/test/java/lang/invoke/InvokeDynamicPrintArgs.java Sat Jun 04 06:45:17 2011 -0700 +++ b/test/java/lang/invoke/InvokeDynamicPrintArgs.java Sat Jun 04 06:52:01 2011 -0700 @@ -106,8 +106,10 @@ "Done printing argument lists." }; + private static boolean doPrint = true; private static void printArgs(Object bsmInfo, Object... args) { - System.out.println(bsmInfo+Arrays.deepToString(args)); + String message = bsmInfo+Arrays.deepToString(args); + if (doPrint) System.out.println(message); } private static MethodHandle MH_printArgs() throws ReflectiveOperationException { shouldNotCallThis(); @@ -129,11 +131,48 @@ return lookup().findStatic(lookup().lookupClass(), "bsm", MT_bsm()); } - private static CallSite bsm2(Lookup caller, String name, MethodType type, Object... arg) throws ReflectiveOperationException { + /* Example of a constant call site with user-data. + * In this case, the user data is exactly the BSM data. + * Note that a CCS with user data must use the "hooked" constructor + * to bind the CCS itself into the resulting target. + * A normal constructor would not allow a circular relation + * between the CCS and its target. + */ + public static class PrintingCallSite extends ConstantCallSite { + final Lookup caller; + final String name; + final Object[] staticArgs; + + PrintingCallSite(Lookup caller, String name, MethodType type, Object... staticArgs) throws Throwable { + super(type, MH_createTarget()); + this.caller = caller; + this.name = name; + this.staticArgs = staticArgs; + } + + public MethodHandle createTarget() { + try { + return lookup().bind(this, "runTarget", genericMethodType(0, true)).asType(type()); + } catch (ReflectiveOperationException ex) { + throw new RuntimeException(ex); + } + } + + public Object runTarget(Object... dynamicArgs) { + List<Object> bsmInfo = new ArrayList<>(Arrays.asList(caller, name, type())); + bsmInfo.addAll(Arrays.asList(staticArgs)); + printArgs(bsmInfo, dynamicArgs); + return null; + } + + private static MethodHandle MH_createTarget() throws ReflectiveOperationException { + shouldNotCallThis(); + return lookup().findVirtual(lookup().lookupClass(), "createTarget", methodType(MethodHandle.class)); + } + } + private static CallSite bsm2(Lookup caller, String name, MethodType type, Object... arg) throws Throwable { // ignore caller and name, but match the type: - List<Object> bsmInfo = new ArrayList<>(Arrays.asList(caller, name, type)); - bsmInfo.addAll(Arrays.asList((Object[])arg)); - return new ConstantCallSite(MH_printArgs().bindTo(bsmInfo).asCollector(Object[].class, type.parameterCount()).asType(type)); + return new PrintingCallSite(caller, name, type, arg); } private static MethodType MT_bsm2() { shouldNotCallThis(); @@ -146,33 +185,33 @@ private static MethodHandle INDY_nothing() throws Throwable { shouldNotCallThis(); - return ((CallSite) MH_bsm().invokeGeneric(lookup(), + return ((CallSite) MH_bsm().invoke(lookup(), "nothing", methodType(void.class) )).dynamicInvoker(); } private static MethodHandle INDY_foo() throws Throwable { shouldNotCallThis(); - return ((CallSite) MH_bsm().invokeGeneric(lookup(), + return ((CallSite) MH_bsm().invoke(lookup(), "foo", methodType(void.class, String.class) )).dynamicInvoker(); } private static MethodHandle INDY_bar() throws Throwable { shouldNotCallThis(); - return ((CallSite) MH_bsm2().invokeGeneric(lookup(), + return ((CallSite) MH_bsm2().invoke(lookup(), "bar", methodType(void.class, String.class, int.class) , Void.class, "void type!", 1, 234.5F, 67.5, (long)89 )).dynamicInvoker(); } private static MethodHandle INDY_bar2() throws Throwable { shouldNotCallThis(); - return ((CallSite) MH_bsm2().invokeGeneric(lookup(), + return ((CallSite) MH_bsm2().invoke(lookup(), "bar2", methodType(void.class, String.class, int.class) , Void.class, "void type!", 1, 234.5F, 67.5, (long)89 )).dynamicInvoker(); } private static MethodHandle INDY_baz() throws Throwable { shouldNotCallThis(); - return ((CallSite) MH_bsm2().invokeGeneric(lookup(), + return ((CallSite) MH_bsm2().invoke(lookup(), "baz", methodType(void.class, String.class, int.class, double.class) , 1234.5 )).dynamicInvoker();
--- a/test/java/lang/invoke/InvokeGenericTest.java Sat Jun 04 06:45:17 2011 -0700 +++ b/test/java/lang/invoke/InvokeGenericTest.java Sat Jun 04 06:52:01 2011 -0700 @@ -53,9 +53,9 @@ if (vstr != null) verbosity = Integer.parseInt(vstr); } - public static void main(String... av) throws Throwable { - new InvokeGenericTest().testFirst(); - } +// public static void main(String... av) throws Throwable { +// new InvokeGenericTest().testFirst(); +// } @Test public void testFirst() throws Throwable { @@ -314,7 +314,7 @@ ArrayList<Class<?>> argTypes = new ArrayList<Class<?>>(targetType.parameterList()); Collections.fill(argTypes.subList(beg, end), argType); MethodType ttype2 = MethodType.methodType(targetType.returnType(), argTypes); - return MethodHandles.convertArguments(target, ttype2); + return target.asType(ttype2); } // This lookup is good for all members in and under InvokeGenericTest. @@ -378,7 +378,7 @@ String[] args = { "one", "two" }; MethodHandle mh = callable(Object.class, String.class); Object res; List resl; - res = resl = (List) mh.invokeGeneric((String)args[0], (Object)args[1]); + res = resl = (List) mh.invoke((String)args[0], (Object)args[1]); //System.out.println(res); assertEquals(Arrays.asList(args), res); } @@ -470,8 +470,6 @@ return allMethodTypes(argc, argc, types); } - interface RandomInterface { } - MethodHandle toString_MH; @Test @@ -480,33 +478,62 @@ toString_MH = LOOKUP. findVirtual(Object.class, "toString", MethodType.methodType(String.class)); Object[] args = { "one", "two" }; - for (MethodType type : allMethodTypes(2, Object.class, String.class, RandomInterface.class)) { + for (MethodType type : allMethodTypes(2, Object.class, String.class, CharSequence.class)) { testReferenceConversions(type, args); } } public void testReferenceConversions(MethodType type, Object... args) throws Throwable { countTest(); - if (verbosity > 3) System.out.println("target type: "+type); + int nargs = args.length; + List<Object> argList = Arrays.asList(args); + String expectString = argList.toString(); + if (verbosity > 3) System.out.println("target type: "+type+expectString); MethodHandle mh = callable(type.parameterList()); - MethodHandle tsdrop = MethodHandles.dropArguments(toString_MH, 1, type.parameterList()); - mh = MethodHandles.foldArguments(tsdrop, mh); + mh = MethodHandles.filterReturnValue(mh, toString_MH); mh = mh.asType(type); - Object res = mh.invoke((String)args[0], (Object)args[1]); + Object res = null; + if (nargs == 2) { + res = mh.invoke((Object)args[0], (Object)args[1]); + assertEquals(expectString, res); + res = mh.invoke((String)args[0], (Object)args[1]); + assertEquals(expectString, res); + res = mh.invoke((Object)args[0], (String)args[1]); + assertEquals(expectString, res); + res = mh.invoke((String)args[0], (String)args[1]); + assertEquals(expectString, res); + res = mh.invoke((String)args[0], (CharSequence)args[1]); + assertEquals(expectString, res); + res = mh.invoke((CharSequence)args[0], (Object)args[1]); + assertEquals(expectString, res); + res = (String) mh.invoke((Object)args[0], (Object)args[1]); + assertEquals(expectString, res); + res = (String) mh.invoke((String)args[0], (Object)args[1]); + assertEquals(expectString, res); + res = (CharSequence) mh.invoke((String)args[0], (Object)args[1]); + assertEquals(expectString, res); + } else { + assert(false); // write this code + } //System.out.println(res); - assertEquals(Arrays.asList(args).toString(), res); } - @Test @Ignore("known failure pending 6939861") + @Test public void testBoxConversions() throws Throwable { startTest("testBoxConversions"); countTest(); Object[] args = { 1, 2 }; MethodHandle mh = callable(Object.class, int.class); - Object res; List resl; + Object res; List resl; int resi; res = resl = (List) mh.invoke((int)args[0], (Object)args[1]); //System.out.println(res); assertEquals(Arrays.asList(args), res); + mh = MethodHandles.identity(int.class); + mh = MethodHandles.dropArguments(mh, 1, int.class); + res = resi = (int) mh.invoke((Object) args[0], (Object) args[1]); + assertEquals(args[0], res); + res = resi = (int) mh.invoke((int) args[0], (Object) args[1]); + assertEquals(args[0], res); } }
--- a/test/java/lang/invoke/JavaDocExamplesTest.java Sat Jun 04 06:45:17 2011 -0700 +++ b/test/java/lang/invoke/JavaDocExamplesTest.java Sat Jun 04 06:52:01 2011 -0700 @@ -34,7 +34,7 @@ $ $JAVA7X_HOME/bin/javac -cp $JUNIT4_JAR -d /tmp/Classes \ $DAVINCI/sources/jdk/test/java/lang/invoke/JavaDocExamplesTest.java $ $JAVA7X_HOME/bin/java -cp $JUNIT4_JAR:/tmp/Classes \ - -Dtest.java.lang.invoke.JavaDocExamplesTest.verbosity=1 \ + -DJavaDocExamplesTest.verbosity=1 \ test.java.lang.invoke.JavaDocExamplesTest ---- */ @@ -45,12 +45,10 @@ import static java.lang.invoke.MethodHandles.*; import static java.lang.invoke.MethodType.*; -import java.lang.reflect.*; import java.util.*; import org.junit.*; import static org.junit.Assert.*; -import static org.junit.Assume.*; /** @@ -60,11 +58,29 @@ /** Wrapper for running the JUnit tests in this module. * Put JUnit on the classpath! */ - public static void main(String... ignore) { - org.junit.runner.JUnitCore.runClasses(JavaDocExamplesTest.class); + public static void main(String... ignore) throws Throwable { + System.out.println("can run this as:"); + System.out.println("$ java org.junit.runner.JUnitCore "+JavaDocExamplesTest.class.getName()); + new JavaDocExamplesTest().run(); + } + public void run() throws Throwable { + testFindVirtual(); + testPermuteArguments(); + testDropArguments(); + testFilterArguments(); + testFoldArguments(); + testMethodHandlesSummary(); + testAsSpreader(); + testAsCollector(); + testAsVarargsCollector(); + testAsFixedArity(); + testAsTypeCornerCases(); + testMutableCallSite(); } // How much output? - static int verbosity = Integer.getInteger("test.java.lang.invoke.JavaDocExamplesTest.verbosity", 0); + static final Class<?> THIS_CLASS = JavaDocExamplesTest.class; + static int verbosity = Integer.getInteger(THIS_CLASS.getSimpleName()+".verbosity", 0); + {} static final private Lookup LOOKUP = lookup(); @@ -74,17 +90,23 @@ // "hashCode", methodType(int.class)); // form required if ReflectiveOperationException is intercepted: -static final private MethodHandle CONCAT_2, HASHCODE_2; + static final private MethodHandle CONCAT_2, HASHCODE_2, ADD_2, SUB_2; static { try { + Class<?> THIS_CLASS = LOOKUP.lookupClass(); CONCAT_2 = LOOKUP.findVirtual(String.class, "concat", methodType(String.class, String.class)); HASHCODE_2 = LOOKUP.findVirtual(Object.class, "hashCode", methodType(int.class)); + ADD_2 = LOOKUP.findStatic(THIS_CLASS, "add", methodType(int.class, int.class, int.class)); + SUB_2 = LOOKUP.findStatic(THIS_CLASS, "sub", methodType(int.class, int.class, int.class)); } catch (ReflectiveOperationException ex) { throw new RuntimeException(ex); } } + static int add(int x, int y) { return x + y; } + static int sub(int x, int y) { return x - y; } + {} @Test public void testFindVirtual() throws Throwable { @@ -101,6 +123,39 @@ assertEquals("xy".hashCode(), (int) HASHCODE_3.invokeExact((Object)"xy")); {} } + + @Test public void testPermuteArguments() throws Throwable { + {{ +{} /// JAVADOC +MethodType intfn1 = methodType(int.class, int.class); +MethodType intfn2 = methodType(int.class, int.class, int.class); +MethodHandle sub = SUB_2;// ... {int x, int y => x-y} ...; +assert(sub.type().equals(intfn2)); +MethodHandle sub1 = permuteArguments(sub, intfn2, 0, 1); +MethodHandle rsub = permuteArguments(sub, intfn2, 1, 0); +assert((int)rsub.invokeExact(1, 100) == 99); +MethodHandle add = ADD_2;// ... {int x, int y => x+y} ...; +assert(add.type().equals(intfn2)); +MethodHandle twice = permuteArguments(add, intfn1, 0, 0); +assert(twice.type().equals(intfn1)); +assert((int)twice.invokeExact(21) == 42); + }} + {{ +{} /// JAVADOC +MethodHandle cat = lookup().findVirtual(String.class, + "concat", methodType(String.class, String.class)); +assertEquals("xy", (String) cat.invokeExact("x", "y")); +MethodHandle d0 = dropArguments(cat, 0, String.class); +assertEquals("yz", (String) d0.invokeExact("x", "y", "z")); +MethodHandle d1 = dropArguments(cat, 1, String.class); +assertEquals("xz", (String) d1.invokeExact("x", "y", "z")); +MethodHandle d2 = dropArguments(cat, 2, String.class); +assertEquals("xy", (String) d2.invokeExact("x", "y", "z")); +MethodHandle d12 = dropArguments(cat, 1, int.class, boolean.class); +assertEquals("xz", (String) d12.invokeExact("x", 12, true, "z")); + }} + } + @Test public void testDropArguments() throws Throwable { {{ {} /// JAVADOC @@ -145,6 +200,21 @@ }} } + @Test public void testFoldArguments() throws Throwable { + {{ +{} /// JAVADOC +MethodHandle trace = publicLookup().findVirtual(java.io.PrintStream.class, + "println", methodType(void.class, String.class)) + .bindTo(System.out); +MethodHandle cat = lookup().findVirtual(String.class, + "concat", methodType(String.class, String.class)); +assertEquals("boojum", (String) cat.invokeExact("boo", "jum")); +MethodHandle catTrace = foldArguments(cat, trace); +// also prints "boo": +assertEquals("boojum", (String) catTrace.invokeExact("boo", "jum")); + }} + } + static void assertEquals(Object exp, Object act) { if (verbosity > 0) System.out.println("result: "+act); @@ -162,24 +232,24 @@ mh = lookup.findVirtual(String.class, "replace", mt); s = (String) mh.invokeExact("daddy",'d','n'); // invokeExact(Ljava/lang/String;CC)Ljava/lang/String; -assert(s.equals("nanny")); +assertEquals(s, "nanny"); // weakly typed invocation (using MHs.invoke) s = (String) mh.invokeWithArguments("sappy", 'p', 'v'); -assert(s.equals("savvy")); +assertEquals(s, "savvy"); // mt is (Object[])List mt = MethodType.methodType(java.util.List.class, Object[].class); mh = lookup.findStatic(java.util.Arrays.class, "asList", mt); assert(mh.isVarargsCollector()); x = mh.invoke("one", "two"); // invoke(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Object; -assert(x.equals(java.util.Arrays.asList("one","two"))); +assertEquals(x, java.util.Arrays.asList("one","two")); // mt is (Object,Object,Object)Object mt = MethodType.genericMethodType(3); mh = mh.asType(mt); x = mh.invokeExact((Object)1, (Object)2, (Object)3); // invokeExact(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object; -assert(x.equals(java.util.Arrays.asList(1,2,3))); -// mt is { => int} +assertEquals(x, java.util.Arrays.asList(1,2,3)); +// mt is ()int mt = MethodType.methodType(int.class); mh = lookup.findVirtual(java.util.List.class, "size", mt); i = (int) mh.invokeExact(java.util.Arrays.asList(1,2,3)); @@ -193,37 +263,239 @@ }} } + @Test public void testAsSpreader() throws Throwable { + {{ +{} /// JAVADOC +MethodHandle equals = publicLookup() + .findVirtual(String.class, "equals", methodType(boolean.class, Object.class)); +assert( (boolean) equals.invokeExact("me", (Object)"me")); +assert(!(boolean) equals.invokeExact("me", (Object)"thee")); +// spread both arguments from a 2-array: +MethodHandle eq2 = equals.asSpreader(Object[].class, 2); +assert( (boolean) eq2.invokeExact(new Object[]{ "me", "me" })); +assert(!(boolean) eq2.invokeExact(new Object[]{ "me", "thee" })); +// spread both arguments from a String array: +MethodHandle eq2s = equals.asSpreader(String[].class, 2); +assert( (boolean) eq2s.invokeExact(new String[]{ "me", "me" })); +assert(!(boolean) eq2s.invokeExact(new String[]{ "me", "thee" })); +// spread second arguments from a 1-array: +MethodHandle eq1 = equals.asSpreader(Object[].class, 1); +assert( (boolean) eq1.invokeExact("me", new Object[]{ "me" })); +assert(!(boolean) eq1.invokeExact("me", new Object[]{ "thee" })); +// spread no arguments from a 0-array or null: +MethodHandle eq0 = equals.asSpreader(Object[].class, 0); +assert( (boolean) eq0.invokeExact("me", (Object)"me", new Object[0])); +assert(!(boolean) eq0.invokeExact("me", (Object)"thee", (Object[])null)); +// asSpreader and asCollector are approximate inverses: +for (int n = 0; n <= 2; n++) { + for (Class<?> a : new Class<?>[]{Object[].class, String[].class, CharSequence[].class}) { + MethodHandle equals2 = equals.asSpreader(a, n).asCollector(a, n); + assert( (boolean) equals2.invokeWithArguments("me", "me")); + assert(!(boolean) equals2.invokeWithArguments("me", "thee")); + } +} +MethodHandle caToString = publicLookup() + .findStatic(Arrays.class, "toString", methodType(String.class, char[].class)); +assertEquals("[A, B, C]", (String) caToString.invokeExact("ABC".toCharArray())); +MethodHandle caString3 = caToString.asCollector(char[].class, 3); +assertEquals("[A, B, C]", (String) caString3.invokeExact('A', 'B', 'C')); +MethodHandle caToString2 = caString3.asSpreader(char[].class, 2); +assertEquals("[A, B, C]", (String) caToString2.invokeExact('A', "BC".toCharArray())); + }} + } + + @Test public void testAsCollector() throws Throwable { + {{ +{} /// JAVADOC +MethodHandle deepToString = publicLookup() + .findStatic(Arrays.class, "deepToString", methodType(String.class, Object[].class)); +assertEquals("[won]", (String) deepToString.invokeExact(new Object[]{"won"})); +MethodHandle ts1 = deepToString.asCollector(Object[].class, 1); +assertEquals(methodType(String.class, Object.class), ts1.type()); +//assertEquals("[won]", (String) ts1.invokeExact( new Object[]{"won"})); //FAIL +assertEquals("[[won]]", (String) ts1.invokeExact((Object) new Object[]{"won"})); +// arrayType can be a subtype of Object[] +MethodHandle ts2 = deepToString.asCollector(String[].class, 2); +assertEquals(methodType(String.class, String.class, String.class), ts2.type()); +assertEquals("[two, too]", (String) ts2.invokeExact("two", "too")); +MethodHandle ts0 = deepToString.asCollector(Object[].class, 0); +assertEquals("[]", (String) ts0.invokeExact()); +// collectors can be nested, Lisp-style +MethodHandle ts22 = deepToString.asCollector(Object[].class, 3).asCollector(String[].class, 2); +assertEquals("[A, B, [C, D]]", ((String) ts22.invokeExact((Object)'A', (Object)"B", "C", "D"))); +// arrayType can be any primitive array type +MethodHandle bytesToString = publicLookup() + .findStatic(Arrays.class, "toString", methodType(String.class, byte[].class)) + .asCollector(byte[].class, 3); +assertEquals("[1, 2, 3]", (String) bytesToString.invokeExact((byte)1, (byte)2, (byte)3)); +MethodHandle longsToString = publicLookup() + .findStatic(Arrays.class, "toString", methodType(String.class, long[].class)) + .asCollector(long[].class, 1); +assertEquals("[123]", (String) longsToString.invokeExact((long)123)); + }} + } + @Test public void testAsVarargsCollector() throws Throwable { {{ {} /// JAVADOC +MethodHandle deepToString = publicLookup() + .findStatic(Arrays.class, "deepToString", methodType(String.class, Object[].class)); +MethodHandle ts1 = deepToString.asVarargsCollector(Object[].class); +assertEquals("[won]", (String) ts1.invokeExact( new Object[]{"won"})); +assertEquals("[won]", (String) ts1.invoke( new Object[]{"won"})); +assertEquals("[won]", (String) ts1.invoke( "won" )); +assertEquals("[[won]]", (String) ts1.invoke((Object) new Object[]{"won"})); +// findStatic of Arrays.asList(...) produces a variable arity method handle: MethodHandle asList = publicLookup() - .findStatic(Arrays.class, "asList", methodType(List.class, Object[].class)) - .asVarargsCollector(Object[].class); + .findStatic(Arrays.class, "asList", methodType(List.class, Object[].class)); +assertEquals(methodType(List.class, Object[].class), asList.type()); +assert(asList.isVarargsCollector()); assertEquals("[]", asList.invoke().toString()); assertEquals("[1]", asList.invoke(1).toString()); assertEquals("[two, too]", asList.invoke("two", "too").toString()); -Object[] argv = { "three", "thee", "tee" }; +String[] argv = { "three", "thee", "tee" }; assertEquals("[three, thee, tee]", asList.invoke(argv).toString()); +assertEquals("[three, thee, tee]", asList.invoke((Object[])argv).toString()); List ls = (List) asList.invoke((Object)argv); assertEquals(1, ls.size()); assertEquals("[three, thee, tee]", Arrays.toString((Object[])ls.get(0))); }} } - @Test public void testVarargsCollectorSuppression() throws Throwable { + @Test public void testAsFixedArity() throws Throwable { {{ {} /// JAVADOC -MethodHandle vamh = publicLookup() +MethodHandle asListVar = publicLookup() .findStatic(Arrays.class, "asList", methodType(List.class, Object[].class)) .asVarargsCollector(Object[].class); -MethodHandle mh = MethodHandles.exactInvoker(vamh.type()).bindTo(vamh); -assert(vamh.type().equals(mh.type())); -assertEquals("[1, 2, 3]", vamh.invoke(1,2,3).toString()); -boolean failed = false; -try { mh.invoke(1,2,3); } -catch (WrongMethodTypeException ex) { failed = true; } -assert(failed); +MethodHandle asListFix = asListVar.asFixedArity(); +assertEquals("[1]", asListVar.invoke(1).toString()); +Exception caught = null; +try { asListFix.invoke((Object)1); } +catch (Exception ex) { caught = ex; } +assert(caught instanceof ClassCastException); +assertEquals("[two, too]", asListVar.invoke("two", "too").toString()); +try { asListFix.invoke("two", "too"); } +catch (Exception ex) { caught = ex; } +assert(caught instanceof WrongMethodTypeException); +Object[] argv = { "three", "thee", "tee" }; +assertEquals("[three, thee, tee]", asListVar.invoke(argv).toString()); +assertEquals("[three, thee, tee]", asListFix.invoke(argv).toString()); +assertEquals(1, ((List) asListVar.invoke((Object)argv)).size()); +assertEquals("[three, thee, tee]", asListFix.invoke((Object)argv).toString()); + }} + } + + @Test public void testAsTypeCornerCases() throws Throwable { + {{ +{} /// JAVADOC +MethodHandle i2s = publicLookup() + .findVirtual(Integer.class, "toString", methodType(String.class)); +i2s = i2s.asType(i2s.type().unwrap()); +MethodHandle l2s = publicLookup() + .findVirtual(Long.class, "toString", methodType(String.class)); +l2s = l2s.asType(l2s.type().unwrap()); + +Exception caught = null; +try { i2s.asType(methodType(String.class, String.class)); } +catch (Exception ex) { caught = ex; } +assert(caught instanceof WrongMethodTypeException); + +i2s.asType(methodType(String.class, byte.class)); +i2s.asType(methodType(String.class, Byte.class)); +i2s.asType(methodType(String.class, Character.class)); +i2s.asType(methodType(String.class, Integer.class)); +l2s.asType(methodType(String.class, byte.class)); +l2s.asType(methodType(String.class, Byte.class)); +l2s.asType(methodType(String.class, Character.class)); +l2s.asType(methodType(String.class, Integer.class)); +l2s.asType(methodType(String.class, Long.class)); + +caught = null; +try { i2s.asType(methodType(String.class, Long.class)); } +catch (Exception ex) { caught = ex; } +assert(caught instanceof WrongMethodTypeException); + +MethodHandle i2sGen = i2s.asType(methodType(String.class, Object.class)); +MethodHandle l2sGen = l2s.asType(methodType(String.class, Object.class)); + +i2sGen.invoke(42); // int -> Integer -> Object -> Integer -> int +i2sGen.invoke((byte)4); // byte -> Byte -> Object -> Byte -> byte -> int +l2sGen.invoke(42); // int -> Integer -> Object -> Integer -> int +l2sGen.invoke((byte)4); // byte -> Byte -> Object -> Byte -> byte -> int +l2sGen.invoke(0x420000000L); + +caught = null; +try { i2sGen.invoke(0x420000000L); } // long -> Long -> Object -> Integer CCE +catch (Exception ex) { caught = ex; } +assert(caught instanceof ClassCastException); + +caught = null; +try { i2sGen.invoke("asdf"); } // String -> Object -> Integer CCE +catch (Exception ex) { caught = ex; } +assert(caught instanceof ClassCastException); {} }} } + + @Test public void testMutableCallSite() throws Throwable { + {{ +{} /// JAVADOC +MutableCallSite name = new MutableCallSite(MethodType.methodType(String.class)); +MethodHandle MH_name = name.dynamicInvoker(); +MethodType MT_str1 = MethodType.methodType(String.class); +MethodHandle MH_upcase = MethodHandles.lookup() + .findVirtual(String.class, "toUpperCase", MT_str1); +MethodHandle worker1 = MethodHandles.filterReturnValue(MH_name, MH_upcase); +name.setTarget(MethodHandles.constant(String.class, "Rocky")); +assertEquals("ROCKY", (String) worker1.invokeExact()); +name.setTarget(MethodHandles.constant(String.class, "Fred")); +assertEquals("FRED", (String) worker1.invokeExact()); +// (mutation can be continued indefinitely) +/* + * </pre></blockquote> + * <p> + * The same call site may be used in several places at once. + * <blockquote><pre> + */ +MethodType MT_str2 = MethodType.methodType(String.class, String.class); +MethodHandle MH_cat = lookup().findVirtual(String.class, + "concat", methodType(String.class, String.class)); +MethodHandle MH_dear = MethodHandles.insertArguments(MH_cat, 1, ", dear?"); +MethodHandle worker2 = MethodHandles.filterReturnValue(MH_name, MH_dear); +assertEquals("Fred, dear?", (String) worker2.invokeExact()); +name.setTarget(MethodHandles.constant(String.class, "Wilma")); +assertEquals("WILMA", (String) worker1.invokeExact()); +assertEquals("Wilma, dear?", (String) worker2.invokeExact()); +{} + }} + } + + @Test public void testSwitchPoint() throws Throwable { + {{ +{} /// JAVADOC +MethodHandle MH_strcat = MethodHandles.lookup() + .findVirtual(String.class, "concat", MethodType.methodType(String.class, String.class)); +SwitchPoint spt = new SwitchPoint(); +assert(spt.isValid()); +// the following steps may be repeated to re-use the same switch point: +MethodHandle worker1 = MH_strcat; +MethodHandle worker2 = MethodHandles.permuteArguments(MH_strcat, MH_strcat.type(), 1, 0); +MethodHandle worker = spt.guardWithTest(worker1, worker2); +assertEquals("method", (String) worker.invokeExact("met", "hod")); +SwitchPoint.invalidateAll(new SwitchPoint[]{ spt }); +assert(!spt.isValid()); +assertEquals("hodmet", (String) worker.invokeExact("met", "hod")); +{} + }} + } + + /* ---- TEMPLATE ---- + @Test public void testFoo() throws Throwable { + {{ +{} /// JAVADOC +{} + }} + } + */ }
--- a/test/java/lang/invoke/MethodHandlesTest.java Sat Jun 04 06:45:17 2011 -0700 +++ b/test/java/lang/invoke/MethodHandlesTest.java Sat Jun 04 06:52:01 2011 -0700 @@ -100,6 +100,31 @@ // ValueConversions.varargsArray: UnsupportedOperationException: NYI: cannot form a varargs array of length 13 testInsertArguments(0, 0, MAX_ARG_INCREASE+10); } + @Test @Ignore("permuteArguments has trouble with double slots") + public void testFail_7() throws Throwable { + testPermuteArguments(new Object[]{10, 200L}, + new Class<?>[]{Integer.class, long.class}, + new int[]{1,0}); + testPermuteArguments(new Object[]{10, 200L, 5000L}, + new Class<?>[]{Integer.class, long.class, long.class}, + new int[]{2,0,1}); //rot + testPermuteArguments(new Object[]{10, 200L, 5000L}, + new Class<?>[]{Integer.class, long.class, long.class}, + new int[]{1,2,0}); //rot + testPermuteArguments(new Object[]{10, 200L, 5000L}, + new Class<?>[]{Integer.class, long.class, long.class}, + new int[]{2,1,0}); //swap + testPermuteArguments(new Object[]{10, 200L, 5000L}, + new Class<?>[]{Integer.class, long.class, long.class}, + new int[]{0,1,2,2}); //dup + testPermuteArguments(new Object[]{10, 200L, 5000L}, + new Class<?>[]{Integer.class, long.class, long.class}, + new int[]{2,0,1,2}); + testPermuteArguments(new Object[]{10, 200L, 5000L}, + new Class<?>[]{Integer.class, long.class, long.class}, + new int[]{2,2,0,1}); + testPermuteArguments(4, Integer.class, 2, long.class, 6); + } static final int MAX_ARG_INCREASE = 3; public MethodHandlesTest() { @@ -356,7 +381,7 @@ ArrayList<Class<?>> argTypes = new ArrayList<Class<?>>(targetType.parameterList()); Collections.fill(argTypes.subList(beg, end), argType); MethodType ttype2 = MethodType.methodType(targetType.returnType(), argTypes); - return MethodHandles.convertArguments(target, ttype2); + return target.asType(ttype2); } // This lookup is good for all members in and under MethodHandlesTest. @@ -505,8 +530,15 @@ System.out.print(':'); } + static final boolean DEBUG_METHOD_HANDLE_NAMES = Boolean.getBoolean("java.lang.invoke.MethodHandle.DEBUG_NAMES"); + // rough check of name string - static void assertNameStringContains(Object x, String s) { + static void assertNameStringContains(MethodHandle x, String s) { + if (!DEBUG_METHOD_HANDLE_NAMES) { + // ignore s + assertEquals("MethodHandle"+x.type(), x.toString()); + return; + } if (x.toString().contains(s)) return; assertEquals(s, x); } @@ -998,13 +1030,13 @@ Class<?> vtype = ftype; if (ftype != int.class) vtype = Object.class; if (isGetter) { - mh = MethodHandles.convertArguments(mh, mh.type().generic() - .changeReturnType(vtype)); + mh = mh.asType(mh.type().generic() + .changeReturnType(vtype)); } else { int last = mh.type().parameterCount() - 1; - mh = MethodHandles.convertArguments(mh, mh.type().generic() - .changeReturnType(void.class) - .changeParameterType(last, vtype)); + mh = mh.asType(mh.type().generic() + .changeReturnType(void.class) + .changeParameterType(last, vtype)); } if (f != null && f.getDeclaringClass() == HasFields.class) { assertEquals(f.get(fields), value); // clean to start with @@ -1132,7 +1164,7 @@ // FIXME: change Integer.class and (Integer) below to int.class and (int) below. MethodType gtype = mh.type().generic().changeParameterType(1, Integer.class); if (testSetter) gtype = gtype.changeReturnType(void.class); - mh = MethodHandles.convertArguments(mh, gtype); + mh = mh.asType(gtype); } Object sawValue, expValue; List<Object> model = array2list(array); @@ -1226,11 +1258,10 @@ } void testConvert(MethodHandle id, Class<?> rtype, String name, Class<?>... params) throws Throwable { - testConvert(true, false, id, rtype, name, params); - testConvert(true, true, id, rtype, name, params); + testConvert(true, id, rtype, name, params); } - void testConvert(boolean positive, boolean useAsType, + void testConvert(boolean positive, MethodHandle id, Class<?> rtype, String name, Class<?>... params) throws Throwable { countTest(positive); MethodType idType = id.type(); @@ -1258,10 +1289,7 @@ MethodHandle target = null; RuntimeException error = null; try { - if (useAsType) - target = id.asType(newType); - else - target = MethodHandles.convertArguments(id, newType); + target = id.asType(newType); } catch (RuntimeException ex) { error = ex; } @@ -1286,11 +1314,11 @@ MethodType.methodType(Object.class, String.class, Object[].class)); vac0 = vac0.bindTo("vac"); MethodHandle vac = vac0.asVarargsCollector(Object[].class); - testConvert(true, true, vac.asType(MethodType.genericMethodType(0)), null, "vac"); - testConvert(true, true, vac.asType(MethodType.genericMethodType(0)), null, "vac"); + testConvert(true, vac.asType(MethodType.genericMethodType(0)), null, "vac"); + testConvert(true, vac.asType(MethodType.genericMethodType(0)), null, "vac"); for (Class<?> at : new Class[] { Object.class, String.class, Integer.class }) { - testConvert(true, true, vac.asType(MethodType.genericMethodType(1)), null, "vac", at); - testConvert(true, true, vac.asType(MethodType.genericMethodType(2)), null, "vac", at, at); + testConvert(true, vac.asType(MethodType.genericMethodType(1)), null, "vac", at); + testConvert(true, vac.asType(MethodType.genericMethodType(2)), null, "vac", at, at); } } @@ -1299,8 +1327,8 @@ if (CAN_SKIP_WORKING) return; startTest("permuteArguments"); testPermuteArguments(4, Integer.class, 2, String.class, 0); - //testPermuteArguments(6, Integer.class, 0, null, 30); - //testPermuteArguments(4, Integer.class, 1, int.class, 6); + testPermuteArguments(6, Integer.class, 0, null, 30); + //testPermuteArguments(4, Integer.class, 2, long.class, 6); // FIXME Fail_7 } public void testPermuteArguments(int max, Class<?> type1, int t2c, Class<?> type2, int dilution) throws Throwable { if (verbosity >= 2) @@ -1414,8 +1442,9 @@ } MethodType inType = MethodType.methodType(Object.class, types); MethodType outType = MethodType.methodType(Object.class, permTypes); - MethodHandle target = MethodHandles.convertArguments(varargsList(outargs), outType); + MethodHandle target = varargsList(outargs).asType(outType); MethodHandle newTarget = MethodHandles.permuteArguments(target, inType, reorder); + if (verbosity >= 5) System.out.println("newTarget = "+newTarget); Object result = newTarget.invokeWithArguments(args); Object expected = Arrays.asList(permArgs); if (!expected.equals(result)) { @@ -1659,7 +1688,7 @@ countTest(); MethodHandle target = varargsList(nargs); MethodHandle filter = varargsList(1); - filter = MethodHandles.convertArguments(filter, filter.type().generic()); + filter = filter.asType(filter.type().generic()); Object[] argsToPass = randomArgs(nargs, Object.class); if (verbosity >= 3) System.out.println("filter "+target+" at "+pos+" with "+filter); @@ -1800,7 +1829,7 @@ // generic invoker countTest(); inv = MethodHandles.invoker(type); - if (nargs <= 3) { + if (nargs <= 3 && type == type.generic()) { calledLog.clear(); switch (nargs) { case 0: @@ -1826,10 +1855,16 @@ // varargs invoker #0 calledLog.clear(); inv = MethodHandles.spreadInvoker(type, 0); - result = inv.invokeExact(target, args); + if (type.returnType() == Object.class) { + result = inv.invokeExact(target, args); + } else if (type.returnType() == void.class) { + result = null; inv.invokeExact(target, args); + } else { + result = inv.invokeWithArguments(target, (Object) args); + } if (testRetCode) assertEquals(code, result); assertCalled("invokee", args); - if (nargs >= 1) { + if (nargs >= 1 && type == type.generic()) { // varargs invoker #1 calledLog.clear(); inv = MethodHandles.spreadInvoker(type, 1); @@ -1837,7 +1872,7 @@ if (testRetCode) assertEquals(code, result); assertCalled("invokee", args); } - if (nargs >= 2) { + if (nargs >= 2 && type == type.generic()) { // varargs invoker #2 calledLog.clear(); inv = MethodHandles.spreadInvoker(type, 2); @@ -1845,7 +1880,7 @@ if (testRetCode) assertEquals(code, result); assertCalled("invokee", args); } - if (nargs >= 3) { + if (nargs >= 3 && type == type.generic()) { // varargs invoker #3 calledLog.clear(); inv = MethodHandles.spreadInvoker(type, 3); @@ -1858,6 +1893,10 @@ countTest(); calledLog.clear(); inv = MethodHandles.spreadInvoker(type, k); + MethodType expType = (type.dropParameterTypes(k, nargs) + .appendParameterTypes(Object[].class) + .insertParameterTypes(0, MethodHandle.class)); + assertEquals(expType, inv.type()); List<Object> targetPlusVarArgs = new ArrayList<Object>(targetPlusArgs); List<Object> tailList = targetPlusVarArgs.subList(1+k, 1+nargs); Object[] tail = tailList.toArray(); @@ -2038,7 +2077,7 @@ //System.out.println("throwing with "+target+" : "+thrown); MethodType expectedType = MethodType.methodType(returnType, exType); assertEquals(expectedType, target.type()); - target = MethodHandles.convertArguments(target, target.type().generic()); + target = target.asType(target.type().generic()); Throwable caught = null; try { Object res = target.invokeExact((Object) thrown); @@ -2110,12 +2149,12 @@ if (mode.endsWith("/return")) { if (mode.equals("unbox/return")) { // fail on return to ((Integer)surprise).intValue - surprise = MethodHandles.convertArguments(surprise, MethodType.methodType(int.class, Object.class)); - identity = MethodHandles.convertArguments(identity, MethodType.methodType(int.class, Object.class)); + surprise = surprise.asType(MethodType.methodType(int.class, Object.class)); + identity = identity.asType(MethodType.methodType(int.class, Object.class)); } else if (mode.equals("cast/return")) { // fail on return to (Integer)surprise - surprise = MethodHandles.convertArguments(surprise, MethodType.methodType(Integer.class, Object.class)); - identity = MethodHandles.convertArguments(identity, MethodType.methodType(Integer.class, Object.class)); + surprise = surprise.asType(MethodType.methodType(Integer.class, Object.class)); + identity = identity.asType(MethodType.methodType(Integer.class, Object.class)); } } else if (mode.endsWith("/argument")) { MethodHandle callee = null; @@ -2127,14 +2166,14 @@ callee = Surprise.BOX_IDENTITY; } if (callee != null) { - callee = MethodHandles.convertArguments(callee, MethodType.genericMethodType(1)); + callee = callee.asType(MethodType.genericMethodType(1)); surprise = MethodHandles.filterArguments(callee, 0, surprise); identity = MethodHandles.filterArguments(callee, 0, identity); } } assertNotSame(mode, surprise, surprise0); - identity = MethodHandles.convertArguments(identity, MethodType.genericMethodType(1)); - surprise = MethodHandles.convertArguments(surprise, MethodType.genericMethodType(1)); + identity = identity.asType(MethodType.genericMethodType(1)); + surprise = surprise.asType(MethodType.genericMethodType(1)); Object x = 42; for (int i = 0; i < okCount; i++) { Object y = identity.invokeExact(x); @@ -2223,14 +2262,14 @@ { MethodType mt = MethodType.methodType(void.class); MethodHandle mh = lookup.findStatic(MethodHandlesTest.class, "runForRunnable", mt); - Runnable proxy = MethodHandles.asInstance(mh, Runnable.class); + Runnable proxy = MethodHandleProxies.asInterfaceInstance(Runnable.class, mh); proxy.run(); assertCalled("runForRunnable"); } { MethodType mt = MethodType.methodType(Object.class, Fooable.class, Object.class); MethodHandle mh = lookup.findStatic(MethodHandlesTest.class, "fooForFooable", mt); - Fooable proxy = MethodHandles.asInstance(mh, Fooable.class); + Fooable proxy = MethodHandleProxies.asInterfaceInstance(Fooable.class, mh); Object[] args = randomArgs(mt.parameterArray()); Object result = proxy.foo((Fooable) args[0], args[1]); assertCalled("fooForFooable", args); @@ -2244,7 +2283,7 @@ }) { MethodHandle mh = MethodHandles.throwException(void.class, Throwable.class); mh = MethodHandles.insertArguments(mh, 0, ex); - WillThrow proxy = MethodHandles.asInstance(mh, WillThrow.class); + WillThrow proxy = MethodHandleProxies.asInterfaceInstance(WillThrow.class, mh); try { proxy.willThrow(); System.out.println("Failed to throw: "+ex); @@ -2272,7 +2311,7 @@ CharSequence.class, Example.class }) { try { - MethodHandles.asInstance(varargsArray(0), nonSAM); + MethodHandleProxies.asInterfaceInstance(nonSAM, varargsArray(0)); System.out.println("Failed to throw"); assertTrue(false); } catch (IllegalArgumentException ex) {
--- a/test/java/lang/invoke/MethodTypeTest.java Sat Jun 04 06:45:17 2011 -0700 +++ b/test/java/lang/invoke/MethodTypeTest.java Sat Jun 04 06:52:01 2011 -0700 @@ -1,12 +1,10 @@ /* - * Copyright 2008, 2011 Sun Microsystems, Inc. All Rights Reserved. + * Copyright (c) 2008, 2011, 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. Sun designates this - * particular file as subject to the "Classpath" exception as provided - * by Sun in the LICENSE file that accompanied this code. + * published by the Free Software Foundation. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or @@ -18,9 +16,9 @@ * 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, - * CA 95054 USA or visit www.sun.com if you need additional information or - * have any questions. + * 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. */ /* @test
--- a/test/java/lang/invoke/indify/Indify.java Sat Jun 04 06:45:17 2011 -0700 +++ b/test/java/lang/invoke/indify/Indify.java Sat Jun 04 06:52:01 2011 -0700 @@ -524,6 +524,8 @@ if (verifySpecifierCount >= 0) { List<Object[]> specs = bootstrapMethodSpecifiers(false); int specsLen = (specs == null ? 0 : specs.size()); + // Pass by specsLen == 0, to help with associated (inner) classes. + if (specsLen == 0) specsLen = verifySpecifierCount; if (specsLen != verifySpecifierCount) { throw new IllegalArgumentException("BootstrapMethods length is "+specsLen+" but should be "+verifySpecifierCount); }
--- a/test/java/rmi/server/UnicastRemoteObject/exportObject/GcDuringExport.java Sat Jun 04 06:45:17 2011 -0700 +++ b/test/java/rmi/server/UnicastRemoteObject/exportObject/GcDuringExport.java Sat Jun 04 06:52:01 2011 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011 Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2011, 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
--- a/test/java/util/EnumMap/DistinctEntrySetElements.java Sat Jun 04 06:45:17 2011 -0700 +++ b/test/java/util/EnumMap/DistinctEntrySetElements.java Sat Jun 04 06:52:01 2011 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011 Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2011, 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
--- a/test/java/util/EnumMap/EntrySetIteratorRemoveInvalidatesEntry.java Sat Jun 04 06:45:17 2011 -0700 +++ b/test/java/util/EnumMap/EntrySetIteratorRemoveInvalidatesEntry.java Sat Jun 04 06:52:01 2011 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011 Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2011, 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
--- a/test/java/util/EnumMap/SimpleSerialization.java Sat Jun 04 06:45:17 2011 -0700 +++ b/test/java/util/EnumMap/SimpleSerialization.java Sat Jun 04 06:52:01 2011 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011 Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2011, 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
--- a/test/java/util/EnumSet/LargeEnumIteratorRemoveResilience.java Sat Jun 04 06:45:17 2011 -0700 +++ b/test/java/util/EnumSet/LargeEnumIteratorRemoveResilience.java Sat Jun 04 06:52:01 2011 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011 Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2011, 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
--- a/test/java/util/EnumSet/SmallEnumIteratorRemoveResilience.java Sat Jun 04 06:45:17 2011 -0700 +++ b/test/java/util/EnumSet/SmallEnumIteratorRemoveResilience.java Sat Jun 04 06:52:01 2011 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011 Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2011, 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
--- a/test/java/util/Hashtable/SerializationDeadlock.java Sat Jun 04 06:45:17 2011 -0700 +++ b/test/java/util/Hashtable/SerializationDeadlock.java Sat Jun 04 06:52:01 2011 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2010, 2011 Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2010, 2011, 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
--- a/test/java/util/Hashtable/SimpleSerialization.java Sat Jun 04 06:45:17 2011 -0700 +++ b/test/java/util/Hashtable/SimpleSerialization.java Sat Jun 04 06:52:01 2011 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2010, 2011 Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2010, 2011, 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
--- a/test/java/util/IdentityHashMap/DistinctEntrySetElements.java Sat Jun 04 06:45:17 2011 -0700 +++ b/test/java/util/IdentityHashMap/DistinctEntrySetElements.java Sat Jun 04 06:52:01 2011 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011 Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2011, 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
--- a/test/java/util/IdentityHashMap/EntrySetIteratorRemoveInvalidatesEntry.java Sat Jun 04 06:45:17 2011 -0700 +++ b/test/java/util/IdentityHashMap/EntrySetIteratorRemoveInvalidatesEntry.java Sat Jun 04 06:52:01 2011 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011 Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2011, 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
--- a/test/java/util/Vector/SerializationDeadlock.java Sat Jun 04 06:45:17 2011 -0700 +++ b/test/java/util/Vector/SerializationDeadlock.java Sat Jun 04 06:52:01 2011 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2010, 2011 Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2010, 2011, 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
--- a/test/java/util/Vector/SimpleSerialization.java Sat Jun 04 06:45:17 2011 -0700 +++ b/test/java/util/Vector/SimpleSerialization.java Sat Jun 04 06:52:01 2011 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2010, 2011 Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2010, 2011, 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
--- a/test/java/util/concurrent/ConcurrentHashMap/DistinctEntrySetElements.java Sat Jun 04 06:45:17 2011 -0700 +++ b/test/java/util/concurrent/ConcurrentHashMap/DistinctEntrySetElements.java Sat Jun 04 06:52:01 2011 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011 Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2011, 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
--- a/test/java/util/zip/ZipFile/ClearStaleZipFileInputStreams.java Sat Jun 04 06:45:17 2011 -0700 +++ b/test/java/util/zip/ZipFile/ClearStaleZipFileInputStreams.java Sat Jun 04 06:52:01 2011 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011 Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2011, 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
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/javax/swing/plaf/nimbus/Test7048204.java Sat Jun 04 06:52:01 2011 -0700 @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2011, 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. + * + * 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. + */ + +/* @test + @bug 7048204 + @summary NPE from NimbusLookAndFeel.addDefault + @author Pavel Porvatov +*/ + +import javax.swing.*; +import javax.swing.plaf.nimbus.NimbusLookAndFeel; + +public class Test7048204 { + public static void main(String[] args) throws Exception { + UIManager.setLookAndFeel(new NimbusLookAndFeel()); + + SwingUtilities.invokeAndWait(new Runnable() { + public void run() { + new JLabel(); + + UIDefaults uid = UIManager.getDefaults(); + uid.putDefaults(new Object[0]); + uid.put("what.ever", "else"); + } + }); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/javax/swing/text/Utilities/bug7045593.java Sat Jun 04 06:52:01 2011 -0700 @@ -0,0 +1,78 @@ +/* + * Copyright (c) 2011, 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. + * + * 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. + */ + +/* + * @test + * @bug 7045593 + * @summary Possible Regression : JTextfield cursor placement behavior algorithm has changed + * @author Pavel Porvatov + */ + +import sun.awt.SunToolkit; + +import javax.swing.*; +import javax.swing.text.BadLocationException; +import java.awt.*; + +public class bug7045593 { + private static volatile JTextField jtf; + + public static void main(String[] args) throws Exception { + SwingUtilities.invokeAndWait(new Runnable() { + public void run() { + jtf = new JTextField("WW"); + + JFrame frame = new JFrame(); + frame.getContentPane().add(jtf); + frame.pack(); + frame.setVisible(true); + } + }); + + ((SunToolkit) SunToolkit.getDefaultToolkit()).realSync(); + + SwingUtilities.invokeAndWait(new Runnable() { + public void run() { + try { + Rectangle r = jtf.modelToView(1); + + int delta = 2; + + for (int x = r.x - delta; x < r.x + delta; x++) { + assertEquals(jtf.viewToModel(new Point(x, r.y)), 1); + } + + System.out.println("Passed."); + } catch (BadLocationException e) { + throw new RuntimeException("Test failed", e); + } + } + }); + } + + private static void assertEquals(int i1, int i2) { + if (i1 != i2) { + throw new RuntimeException("Test failed, " + i1 + " != " + i2); + } + } +}
--- a/test/sun/net/InetAddress/nameservice/chaining/META-INF/services/sun.net.spi.nameservice.NameServiceDescriptor Sat Jun 04 06:45:17 2011 -0700 +++ b/test/sun/net/InetAddress/nameservice/chaining/META-INF/services/sun.net.spi.nameservice.NameServiceDescriptor Sat Jun 04 06:52:01 2011 -0700 @@ -17,7 +17,7 @@ # # 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 +# questions. Simple1NameServiceDescriptor Simple2NameServiceDescriptor
--- a/test/tools/launcher/TestHelper.java Sat Jun 04 06:45:17 2011 -0700 +++ b/test/tools/launcher/TestHelper.java Sat Jun 04 06:52:01 2011 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2011 Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2008, 2011, 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
--- a/test/tools/pack200/CommandLineTests.java Sat Jun 04 06:45:17 2011 -0700 +++ b/test/tools/pack200/CommandLineTests.java Sat Jun 04 06:52:01 2011 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2007, 2010 Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2007, 2010, 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
--- a/test/tools/pack200/Pack200Test.java Sat Jun 04 06:45:17 2011 -0700 +++ b/test/tools/pack200/Pack200Test.java Sat Jun 04 06:52:01 2011 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2007, 2010 Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2007, 2010, 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
--- a/test/tools/pack200/Utils.java Sat Jun 04 06:45:17 2011 -0700 +++ b/test/tools/pack200/Utils.java Sat Jun 04 06:52:01 2011 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2007, 2010 Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2007, 2010, 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