jdk-sandbox: comparison jdk/src/share/classes/java/dyn/MethodHandles.java

equal deleted inserted replaced

-:faedb20bdcbb
+:16c1792b2ee6
 /*
-* Copyright (c) 2008, 2009, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2008, 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
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 import sun.reflect.Reflection;
 import static sun.dyn.MemberName.newIllegalArgumentException;
 import static sun.dyn.MemberName.newNoAccessException;
 /**
-* Fundamental operations and utilities for MethodHandle.
+* This class consists exclusively of static methods that operate on or return
-* They fall into several categories:
+* method handles. They fall into several categories:
 * <ul>
-* <li>Reifying methods and fields.  This is subject to access checks.
+* <li>Factory methods which create method handles for methods and fields.
-* <li>Invoking method handles on dynamically typed arguments and/or varargs arrays.
+* <li>Invoker methods which can invoke method handles on dynamically typed arguments and/or varargs arrays.
-* <li>Combining or transforming pre-existing method handles into new ones.
+* <li>Combinator methods, which combine or transforming pre-existing method handles into new ones.
-* <li>Miscellaneous emulation of common JVM operations or control flow patterns.
+* <li>Factory methods which create method handles that emulate other common JVM operations or control flow patterns.
 * </ul>
 * <p>
 * @author John Rose, JSR 292 EG
 */
 public class MethodHandles {
 static { MethodHandleImpl.initStatics(); }
 // See IMPL_LOOKUP below.
 //// Method handle creation from ordinary methods.
-/** Create a {@link Lookup} lookup object on the caller.
+/**
-*
+* Return a {@link Lookup lookup object} on the caller,
+* which has the capability to access any method handle that the caller has access to,
+* including direct method handles to private fields and methods.
+* This lookup object is a <em>capability</em> which may be delegated to trusted agents.
+* Do not store it in place where untrusted code can access it.
 */
 public static Lookup lookup() {
 return new Lookup();
 }
-/** Version of lookup which is trusted minimally.
+/**
-*  It can only be used to create method handles to
+* Return a {@link Lookup lookup object} which is trusted minimally.
-*  publicly accessible members.
+* It can only be used to create method handles to
+* publicly accessible fields and methods.
 */
 public static Lookup publicLookup() {
 return Lookup.PUBLIC_LOOKUP;
 }
 /**
-* A factory object for creating method handles, when the creation
+* A <em>lookup object</em> is a factory for creating method handles,
-* requires access checking.  Method handles do not perform
+* when the creation requires access checking.
+* Method handles do not perform
 * access checks when they are called; this is a major difference
 * from reflective {@link Method}, which performs access checking
-* against every caller, on every call.  Method handle access
+* against every caller, on every call.
-* restrictions are enforced when a method handle is created.
+* Therefore, method handle access
+* restrictions must be enforced when a method handle is created.
 * The caller class against which those restrictions are enforced
-* is known as the "lookup class".  {@link Lookup} embodies an
+* is known as the {@linkplain #lookupClass lookup class}.
+* A lookup object embodies an
 * authenticated lookup class, and can be used to create any number
 * of access-checked method handles, all checked against a single
 * lookup class.
 * <p>
 * A class which needs to create method handles will call
-* {@code MethodHandles.lookup()} to create a factory for itself.
+* {@link MethodHandles#lookup MethodHandles.lookup} to create a factory for itself.
 * It may then use this factory to create method handles on
 * all of its methods, including private ones.
 * It may also delegate the lookup (e.g., to a metaobject protocol)
 * by passing the {@code Lookup} object to other code.
 * If this other code creates method handles, they will be access
 * checked against the original lookup class, and not with any higher
 * privileges.
 * <p>
-* Note that access checks only apply to named and reflected methods.
+* Access checks only apply to named and reflected methods.
-* Other method handle creation methods, such as {@link #convertArguments},
+* Other method handle creation methods, such as
+* {@link #convertArguments MethodHandles.convertArguments},
 * do not require any access checks, and can be done independently
 * of any lookup class.
-* <p>
+* <h3>How access errors are handled</h3>
-* <em>A note about error conditions:<em>  A lookup can fail, because
+* A lookup can fail, because
 * the containing class is not accessible to the lookup class, or
 * because the desired class member is missing, or because the
 * desired class member is not accessible to the lookup class.
 * It can also fail if a security manager is installed and refuses
 * access.  In any of these cases, an exception will be
 * At least some of these error conditions are likely to be
 * represented by checked exceptions in the final version of this API.
 */
 public static final
 class Lookup {
+/** The class on behalf of whom the lookup is being performed. */
 private final Class<?> lookupClass;
+/** The allowed sorts of members which may be looked up (public, etc.), with STRICT for package. */
+private final int allowedModes;
+private static final int
+PUBLIC    = Modifier.PUBLIC,
+PACKAGE   = Modifier.STRICT,
+PROTECTED = Modifier.PROTECTED,
+PRIVATE   = Modifier.PRIVATE,
+ALL_MODES = (PUBLIC | PACKAGE | PROTECTED | PRIVATE),
+TRUSTED   = -1;
+private static int fixmods(int mods) {
+mods &= (ALL_MODES - PACKAGE);
+return (mods != 0) ? mods : PACKAGE;
+}
 /** Which class is performing the lookup?  It is this class against
 *  which checks are performed for visibility and access permissions.
 *  <p>
 *  This value is null if and only if this lookup was produced
 */
 public Class<?> lookupClass() {
 return lookupClass;
 }
+// This is just for calling out to MethodHandleImpl.
+private Class<?> lookupClassOrNull() {
+return (allowedModes == TRUSTED) ? null : lookupClass;
+}
+/** Which types of members can this lookup object produce?
+*  The result is a bit-mask of the modifier bits PUBLIC, PROTECTED, PRIVATE, and STRICT.
+*  The modifier bit STRICT stands in for the (non-existent) package protection mode.
+*/
+int lookupModes() {
+return allowedModes & ALL_MODES;
+}
 /** Embody the current class (the lookupClass) as a lookup class
 * for method handle creation.
 * Must be called by from a method in this package,
 * which in turn is called by a method not in this package.
+* <p>
 * Also, don't make it private, lest javac interpose
 * an access$N method.
 */
 Lookup() {
-this(IMPL_TOKEN, getCallerClassAtEntryPoint());
+this(getCallerClassAtEntryPoint(), ALL_MODES);
-}
-Lookup(Access token, Class<?> lookupClass) {
 // make sure we haven't accidentally picked up a privileged class:
 checkUnprivilegedlookupClass(lookupClass);
+}
+Lookup(Access token, Class<?> lookupClass) {
+this(lookupClass, ALL_MODES);
+Access.check(token);
+}
+private Lookup(Class<?> lookupClass, int allowedModes) {
 this.lookupClass = lookupClass;
+this.allowedModes = allowedModes;
 }
 /**
-* Create a lookup on the specified class.
+* Create a lookup on the specified new lookup class.
-* The result is guaranteed to have no more access privileges
+* The resulting object will report the specified
-* than the original.
+* class as its own {@link #lookupClass}.
-*/
+* <p>
-public Lookup in(Class<?> newLookupClass) {
+* However, the resulting {@code Lookup} object is guaranteed
-if (this == PUBLIC_LOOKUP)  return PUBLIC_LOOKUP;
+* to have no more access capabilities than the original.
-if (newLookupClass == null)  return PUBLIC_LOOKUP;
+* In particular:<ul>
-if (newLookupClass == lookupClass)  return this;
+* <li>If the new lookup class differs from the old one,
-if (this != IMPL_LOOKUP) {
+* protected members will not be accessible by virtue of inheritance.
-if (!VerifyAccess.isSamePackage(lookupClass, newLookupClass))
+* <li>If the new lookup class is in a different package
-throw newNoAccessException(new MemberName(newLookupClass), this);
+* than the old one, protected and default (package) members will not be accessible.
-checkUnprivilegedlookupClass(newLookupClass);
+* <li>If the new lookup class is not within the same package member
+* as the old one, private members will not be accessible.
+* <li>In all cases, public members will continue to be accessible.
+* </ul>
+*/
+public Lookup in(Class<?> requestedLookupClass) {
+requestedLookupClass.getClass();  // null check
+if (allowedModes == TRUSTED)  // IMPL_LOOKUP can make any lookup at all
+return new Lookup(requestedLookupClass, ALL_MODES);
+if (requestedLookupClass == this.lookupClass)
+return this;  // keep same capabilities
+int newModes = (allowedModes & (ALL_MODES & ~PROTECTED));
+if ((newModes & PACKAGE) != 0
+&& !VerifyAccess.isSamePackage(this.lookupClass, requestedLookupClass)) {
+newModes &= ~(PACKAGE|PRIVATE);
 }
-return new Lookup(newLookupClass);
+if ((newModes & PRIVATE) != 0
-}
+&& !VerifyAccess.isSamePackageMember(this.lookupClass, requestedLookupClass)) {
+newModes &= ~PRIVATE;
-private Lookup(Class<?> lookupClass) {
+}
-this.lookupClass = lookupClass;
+checkUnprivilegedlookupClass(requestedLookupClass);
+return new Lookup(requestedLookupClass, newModes);
 }
 // Make sure outer class is initialized first.
 static { IMPL_TOKEN.getClass(); }
-private static final Class<?> PUBLIC_ONLY = sun.dyn.empty.Empty.class;
 /** Version of lookup which is trusted minimally.
 *  It can only be used to create method handles to
 *  publicly accessible members.
 */
-static final Lookup PUBLIC_LOOKUP = new Lookup(PUBLIC_ONLY);
+static final Lookup PUBLIC_LOOKUP = new Lookup(Object.class, PUBLIC);
 /** Package-private version of lookup which is trusted. */
-static final Lookup IMPL_LOOKUP = new Lookup(null);
+static final Lookup IMPL_LOOKUP = new Lookup(Object.class, TRUSTED);
 static { MethodHandleImpl.initLookup(IMPL_TOKEN, IMPL_LOOKUP); }
 private static void checkUnprivilegedlookupClass(Class<?> lookupClass) {
 String name = lookupClass.getName();
 if (name.startsWith("java.dyn.") || name.startsWith("sun.dyn."))
 throw newIllegalArgumentException("illegal lookupClass: "+lookupClass);
 }
+/** Display the name of the class.
+*  If there are restrictions on the access permitted to this lookup,
+*  display those also.
+*/
 @Override
 public String toString() {
-if (lookupClass == PUBLIC_ONLY)
+String modestr;
-return "public";
+String cname = lookupClass.getName();
-if (lookupClass == null)
+switch (allowedModes) {
-return "privileged";
+case TRUSTED:
-return lookupClass.getName();
+return "/trusted";
+case PUBLIC:
+modestr = "/public";
+if (lookupClass == Object.class)
+return modestr;
+break;
+case PUBLIC|PACKAGE:
+return cname + "/package";
+case 0:  // should not happen
+return cname + "/empty";
+case ALL_MODES:
+return cname;
+}
+StringBuilder buf = new StringBuilder(cname);
+if ((allowedModes & PUBLIC) != 0)     buf.append("/public");
+if ((allowedModes & PACKAGE) != 0)    buf.append("/package");
+if ((allowedModes & PROTECTED) != 0)  buf.append("/protected");
+if ((allowedModes & PRIVATE) != 0)    buf.append("/private");
+return buf.toString();
 }
 // call this from an entry point method in Lookup with extraFrames=0.
 private static Class<?> getCallerClassAtEntryPoint() {
 final int CALLER_DEPTH = 4;
 /**
 * Produce a method handle for a static method.
 * The type of the method handle will be that of the method.
 * (Since static methods do not take receivers, there is no
 * additional receiver argument inserted into the method handle type,
-* as there would be with {@linkplain #findVirtual} or {@linkplain #findSpecial}.)
+* as there would be with {@link #findVirtual} or {@link #findSpecial}.)
 * The method and all its argument types must be accessible to the lookup class.
 * If the method's class has not yet been initialized, that is done
 * immediately, before the method handle is returned.
-* @param defc the class from which the method is accessed
+* @param refc the class from which the method is accessed
 * @param name the name of the method
 * @param type the type of the method
 * @return the desired method handle
 * @exception SecurityException <em>TBD</em>
 * @exception NoAccessException if the method does not exist or access checking fails
 */
 public
-MethodHandle findStatic(Class<?> defc, String name, MethodType type) throws NoAccessException {
+MethodHandle findStatic(Class<?> refc, String name, MethodType type) throws NoAccessException {
-MemberName method = IMPL_NAMES.resolveOrFail(new MemberName(defc, name, type, Modifier.STATIC), true, lookupClass());
+MemberName method = resolveOrFail(refc, name, type, true);
-VerifyAccess.checkName(method, this);
+checkMethod(refc, method, true);
-checkStatic(true, method, this);
+return MethodHandleImpl.findMethod(IMPL_TOKEN, method, false, lookupClassOrNull());
-//throw NoSuchMethodException
-return MethodHandleImpl.findMethod(IMPL_TOKEN, method, false, lookupClass());
 }
 /**
 * Produce a method handle for a virtual method.
 * The type of the method handle will be that of the method,
-* with the receiver type ({@code defc}) prepended.
+* with the receiver type (usually {@code refc}) prepended.
 * The method and all its argument types must be accessible to the lookup class.
 * <p>
 * (<em>BUG NOTE:</em> The type {@code Object} may be prepended instead
 * of the receiver type, if the receiver type is not on the boot class path.
 * This is due to a temporary JVM limitation, in which MethodHandle
 * When called, the handle will treat the first argument as a receiver
 * and dispatch on the receiver's type to determine which method
 * implementation to enter.
 * (The dispatching action is identical with that performed by an
 * {@code invokevirtual} or {@code invokeinterface} instruction.)
-* @param defc the class or interface from which the method is accessed
+* @param refc the class or interface from which the method is accessed
 * @param name the name of the method
 * @param type the type of the method, with the receiver argument omitted
 * @return the desired method handle
 * @exception SecurityException <em>TBD</em>
 * @exception NoAccessException if the method does not exist or access checking fails
 */
-public MethodHandle findVirtual(Class<?> defc, String name, MethodType type) throws NoAccessException {
+public MethodHandle findVirtual(Class<?> refc, String name, MethodType type) throws NoAccessException {
-MemberName method = IMPL_NAMES.resolveOrFail(new MemberName(defc, name, type), true, lookupClass());
+MemberName method = resolveOrFail(refc, name, type, false);
-VerifyAccess.checkName(method, this);
+checkMethod(refc, method, false);
-checkStatic(false, method, this);
+MethodHandle mh = MethodHandleImpl.findMethod(IMPL_TOKEN, method, true, lookupClassOrNull());
-return MethodHandleImpl.findMethod(IMPL_TOKEN, method, true, lookupClass());
+return restrictProtectedReceiver(method, mh);
+}
+/**
+* Produce a method handle which creates an object and initializes it, using
+* the constructor of the specified type.
+* The parameter types of the method handle will be those of the constructor,
+* while the return type will be a reference to the constructor's class.
+* The constructor and all its argument types must be accessible to the lookup class.
+* If the constructor's class has not yet been initialized, that is done
+* immediately, before the method handle is returned.
+* <p>
+* Note:  The requested type must have a return type of {@code void}.
+* This is consistent with the JVM's treatment of constructor signatures.
+* @param refc the class or interface from which the method is accessed
+* @param type the type of the method, with the receiver argument omitted, and a void return type
+* @return the desired method handle
+* @exception SecurityException <em>TBD</em>
+* @exception NoAccessException if the method does not exist or access checking fails
+*/
+public MethodHandle findConstructor(Class<?> refc, MethodType type) throws NoAccessException {
+String name = "<init>";
+MemberName ctor = resolveOrFail(refc, name, type, false, false, lookupClassOrNull());
+assert(ctor.isConstructor());
+checkAccess(refc, ctor);
+MethodHandle rawMH = MethodHandleImpl.findMethod(IMPL_TOKEN, ctor, false, lookupClassOrNull());
+return MethodHandleImpl.makeAllocator(IMPL_TOKEN, rawMH);
 }
 /**
 * Produce an early-bound method handle for a virtual method,
 * as if called from an {@code invokespecial}
 * (This direct invocation action is identical with that performed by an
 * {@code invokespecial} instruction.)
 * <p>
 * If the explicitly specified caller class is not identical with the
 * lookup class, a security check TBD is performed.
-* @param defc the class or interface from which the method is accessed
+* @param refc the class or interface from which the method is accessed
-* @param name the name of the method, or "<init>" for a constructor
+* @param name the name of the method (which must not be "&lt;init&gt;")
 * @param type the type of the method, with the receiver argument omitted
 * @param specialCaller the proposed calling class to perform the {@code invokespecial}
 * @return the desired method handle
 * @exception SecurityException <em>TBD</em>
 * @exception NoAccessException if the method does not exist or access checking fails
 */
-public MethodHandle findSpecial(Class<?> defc, String name, MethodType type,
+public MethodHandle findSpecial(Class<?> refc, String name, MethodType type,
 Class<?> specialCaller) throws NoAccessException {
-checkSpecialCaller(specialCaller, this);
+checkSpecialCaller(specialCaller);
-Lookup slookup = this.in(specialCaller);
+MemberName method = resolveOrFail(refc, name, type, false, false, specialCaller);
-MemberName method = IMPL_NAMES.resolveOrFail(new MemberName(defc, name, type), false, slookup.lookupClass());
+checkMethod(refc, method, false);
-VerifyAccess.checkName(method, this);
+MethodHandle mh = MethodHandleImpl.findMethod(IMPL_TOKEN, method, false, specialCaller);
-checkStatic(false, method, this);
+return restrictReceiver(method, mh, specialCaller);
-if (name.equals("<init>")) {
+}
-throw newNoAccessException("cannot directly invoke a constructor", method, null);
-} else if (defc.isInterface() || !defc.isAssignableFrom(specialCaller)) {
+/**
-throw newNoAccessException("method must be in a superclass of lookup class", method, slookup.lookupClass());
+* <em>PROVISIONAL API, WORK IN PROGRESS:</em>
-}
+* Produce a method handle giving read access to a field.
-return MethodHandleImpl.findMethod(IMPL_TOKEN, method, false, slookup.lookupClass());
+* The type of the method handle will have a return type of the field's
+* value type.
+* If the field is static, the method handle will take no arguments.
+* Otherwise, its single argument will be the instance containing
+* the field.
+* Access checking is performed immediately on behalf of the lookup class.
+* @param name the field's name
+* @param type the field's type
+* @param isStatic true if and only if the field is static
+* @return a method handle which can load values from the field
+* @exception NoAccessException if access checking fails
+*/
+public MethodHandle findGetter(Class<?> refc, String name, Class<?> type, boolean isStatic) throws NoAccessException {
+return makeAccessor(refc, name, type, isStatic, false);
+}
+/**
+* <em>PROVISIONAL API, WORK IN PROGRESS:</em>
+* Produce a method handle giving write access to a reflected field.
+* The type of the method handle will have a void return type.
+* If the field is static, the method handle will take a single
+* argument, of the field's value type, the value to be stored.
+* Otherwise, the two arguments will be the instance containing
+* the field, and the value to be stored.
+* Access checking is performed immediately on behalf of the lookup class.
+* @param name the field's name
+* @param type the field's type
+* @param isStatic true if and only if the field is static
+* @return a method handle which can store values into the reflected field
+* @exception NoAccessException if access checking fails
+*/
+public MethodHandle findSetter(Class<?> refc, String name, Class<?> type,
+boolean isStatic) throws NoAccessException {
+return makeAccessor(refc, name, type, isStatic, true);
 }
 /**
 * Produce an early-bound method handle for a non-static method.
 * The receiver must have a supertype {@code defc} in which a method
 * so that every call to the method handle will invoke the
 * requested method on the given receiver.
 * <p>
 * This is equivalent to the following expression:
 * <code>
-* {@link #insertArguments}({@link #findVirtual}(defc, name, type), receiver)
+* {@link #insertArguments insertArguments}({@link #findVirtual findVirtual}(defc, name, type), receiver)
 * </code>
 * where {@code defc} is either {@code receiver.getClass()} or a super
 * type of that class, in which the requested method is accessible
 * to the lookup class.
 * @param receiver the object from which the method is accessed
 * @return the desired method handle
 * @exception SecurityException <em>TBD</em>
 * @exception NoAccessException if the method does not exist or access checking fails
 */
 public MethodHandle bind(Object receiver, String name, MethodType type) throws NoAccessException {
-Class<? extends Object> rcvc = receiver.getClass(); // may get NPE
+Class<? extends Object> refc = receiver.getClass(); // may get NPE
-MemberName reference = new MemberName(rcvc, name, type);
+MemberName method = resolveOrFail(refc, name, type, false);
-MemberName method = IMPL_NAMES.resolveOrFail(reference, true, lookupClass());
+checkMethod(refc, method, false);
-VerifyAccess.checkName(method, this);
+MethodHandle dmh = MethodHandleImpl.findMethod(IMPL_TOKEN, method, true, lookupClassOrNull());
-checkStatic(false, method, this);
-MethodHandle dmh = MethodHandleImpl.findMethod(IMPL_TOKEN, method, true, lookupClass());
 MethodHandle bmh = MethodHandleImpl.bindReceiver(IMPL_TOKEN, dmh, receiver);
 if (bmh == null)
-throw newNoAccessException(method, this);
+throw newNoAccessException(method, lookupClass());
 return bmh;
 }
 /**
 * <em>PROVISIONAL API, WORK IN PROGRESS:</em>
 * @param m the reflected method
 * @return a method handle which can invoke the reflected method
 * @exception NoAccessException if access checking fails
 */
 public MethodHandle unreflect(Method m) throws NoAccessException {
-return unreflectImpl(new MemberName(m), m.isAccessible(), true, false, this);
+MemberName method = new MemberName(m);
+assert(method.isMethod());
+if (!m.isAccessible())  checkMethod(method.getDeclaringClass(), method, method.isStatic());
+MethodHandle mh = MethodHandleImpl.findMethod(IMPL_TOKEN, method, true, lookupClassOrNull());
+if (!m.isAccessible())  mh = restrictProtectedReceiver(method, mh);
+return mh;
 }
 /**
 * <em>PROVISIONAL API, WORK IN PROGRESS:</em>
 * Produce a method handle for a reflected method.
 * It will bypass checks for overriding methods on the receiver,
-* as if by the {@code invokespecial} instruction.
+* as if by a {@code invokespecial} instruction from within the {@code specialCaller}.
 * The type of the method handle will be that of the method,
-* with the receiver type prepended.
+* with the special caller type prepended (and <em>not</em> the receiver of the method).
 * If the method's {@code accessible} flag is not set,
 * access checking is performed immediately on behalf of the lookup class,
 * as if {@code invokespecial} instruction were being linked.
 * @param m the reflected method
+* @param specialCaller the class nominally calling the method
 * @return a method handle which can invoke the reflected method
 * @exception NoAccessException if access checking fails
 */
 public MethodHandle unreflectSpecial(Method m, Class<?> specialCaller) throws NoAccessException {
-checkSpecialCaller(specialCaller, this);
+checkSpecialCaller(specialCaller);
-Lookup slookup = this.in(specialCaller);
+MemberName method = new MemberName(m);
-MemberName mname = new MemberName(m);
+assert(method.isMethod());
-checkStatic(false, mname, this);
+// ignore m.isAccessible:  this is a new kind of access
-return unreflectImpl(mname, m.isAccessible(), false, false, slookup);
+checkMethod(m.getDeclaringClass(), method, false);
+MethodHandle mh = MethodHandleImpl.findMethod(IMPL_TOKEN, method, false, lookupClassOrNull());
+return restrictReceiver(method, mh, specialCaller);
 }
 /**
 * <em>PROVISIONAL API, WORK IN PROGRESS:</em>
 * Produce a method handle for a reflected constructor.
 * creating a new instance of the constructor's class on the
 * arguments passed to the method handle.
 * <p>
 * If the constructor's {@code accessible} flag is not set,
 * access checking is performed immediately on behalf of the lookup class.
-* @param ctor the reflected constructor
+* @param c the reflected constructor
 * @return a method handle which can invoke the reflected constructor
 * @exception NoAccessException if access checking fails
 */
-public MethodHandle unreflectConstructor(Constructor ctor) throws NoAccessException {
+public MethodHandle unreflectConstructor(Constructor c) throws NoAccessException {
-MemberName m = new MemberName(ctor);
+MemberName ctor = new MemberName(c);
-return unreflectImpl(m, ctor.isAccessible(), false, false, this);
+assert(ctor.isConstructor());
+if (!c.isAccessible())  checkAccess(c.getDeclaringClass(), ctor);
+MethodHandle rawCtor = MethodHandleImpl.findMethod(IMPL_TOKEN, ctor, false, lookupClassOrNull());
+return MethodHandleImpl.makeAllocator(IMPL_TOKEN, rawCtor);
 }
 /**
 * <em>PROVISIONAL API, WORK IN PROGRESS:</em>
 * Produce a method handle giving read access to a reflected field.
 * @param f the reflected field
 * @return a method handle which can load values from the reflected field
 * @exception NoAccessException if access checking fails
 */
 public MethodHandle unreflectGetter(Field f) throws NoAccessException {
-MemberName m = new MemberName(f);
+return makeAccessor(f.getDeclaringClass(), new MemberName(f), f.isAccessible(), false);
-return unreflectImpl(m, f.isAccessible(), false, false, this);
 }
 /**
 * <em>PROVISIONAL API, WORK IN PROGRESS:</em>
 * Produce a method handle giving write access to a reflected field.
 * @param f the reflected field
 * @return a method handle which can store values into the reflected field
 * @exception NoAccessException if access checking fails
 */
 public MethodHandle unreflectSetter(Field f) throws NoAccessException {
-MemberName m = new MemberName(f);
+return makeAccessor(f.getDeclaringClass(), new MemberName(f), f.isAccessible(), true);
-return unreflectImpl(m, f.isAccessible(), false, true, this);
+}
-}
+/// Helper methods, all package-private.
-}
+MemberName resolveOrFail(Class<?> refc, String name, Class<?> type, boolean isStatic) {
-static /*must not be public*/
+checkSymbolicClass(refc);  // do this before attempting to resolve
-MethodHandle findStaticFrom(Lookup lookup,
+int mods = (isStatic ? Modifier.STATIC : 0);
-Class<?> defc, String name, MethodType type) throws NoAccessException {
+return IMPL_NAMES.resolveOrFail(new MemberName(refc, name, type, mods), true, lookupClassOrNull());
-MemberName method = IMPL_NAMES.resolveOrFail(new MemberName(defc, name, type, Modifier.STATIC), true, lookup.lookupClass());
+}
-VerifyAccess.checkName(method, lookup);
-checkStatic(true, method, lookup);
+MemberName resolveOrFail(Class<?> refc, String name, MethodType type, boolean isStatic) {
-return MethodHandleImpl.findMethod(IMPL_TOKEN, method, false, lookup.lookupClass());
+checkSymbolicClass(refc);  // do this before attempting to resolve
-}
+int mods = (isStatic ? Modifier.STATIC : 0);
+return IMPL_NAMES.resolveOrFail(new MemberName(refc, name, type, mods), true, lookupClassOrNull());
-static void checkStatic(boolean wantStatic, MemberName m, Lookup lookup) {
+}
-if (wantStatic != m.isStatic()) {
-String message = wantStatic ? "expected a static method" : "expected a non-static method";
+MemberName resolveOrFail(Class<?> refc, String name, MethodType type, boolean isStatic,
-throw newNoAccessException(message, m, lookup.lookupClass());
+boolean searchSupers, Class<?> specialCaller) {
-}
+checkSymbolicClass(refc);  // do this before attempting to resolve
-}
+int mods = (isStatic ? Modifier.STATIC : 0);
+return IMPL_NAMES.resolveOrFail(new MemberName(refc, name, type, mods), searchSupers, specialCaller);
-static void checkSpecialCaller(Class<?> specialCaller, Lookup lookup) {
+}
-if (lookup == Lookup.IMPL_LOOKUP)
-return;  // privileged action
+void checkSymbolicClass(Class<?> refc) {
-assert(lookup.lookupClass() != null);
+Class<?> caller = lookupClassOrNull();
-if (!VerifyAccess.isSamePackageMember(specialCaller, lookup.lookupClass()))
+if (caller != null && !VerifyAccess.isClassAccessible(refc, caller))
-throw newNoAccessException("no private access", new MemberName(specialCaller), lookup.lookupClass());
+throw newNoAccessException("symbolic reference class is not public", new MemberName(refc), caller);
 }
-// Helper for creating handles on reflected methods and constructors.
+void checkMethod(Class<?> refc, MemberName m, boolean wantStatic) {
-static MethodHandle unreflectImpl(MemberName m, boolean isAccessible,
+String message;
-boolean doDispatch, boolean isSetter, Lookup lookup) {
+if (m.isConstructor())
-MethodType narrowMethodType = null;
+message = "expected a method, not a constructor";
-Class<?> defc = m.getDeclaringClass();
+else if (!m.isMethod())
-boolean isSpecialInvoke = m.isInvocable() && !doDispatch;
+message = "expected a method";
-int mods = m.getModifiers();
+else if (wantStatic != m.isStatic())
-if (m.isStatic()) {
+message = wantStatic ? "expected a static method" : "expected a non-static method";
-if (!isAccessible &&
+else
-VerifyAccess.isAccessible(defc, mods, lookup.lookupClass(), false) == null)
+{ checkAccess(refc, m); return; }
-throw newNoAccessException(m, lookup);
+throw newNoAccessException(message, m, lookupClass());
-} else {
+}
-Class<?> constraint;
-if (isAccessible) {
+void checkAccess(Class<?> refc, MemberName m) {
-// abbreviated access check for "unlocked" method
+int allowedModes = this.allowedModes;
-constraint = doDispatch ? defc : lookup.lookupClass();
+if (allowedModes == TRUSTED)  return;
-} else {
+int mods = m.getModifiers();
-constraint = VerifyAccess.isAccessible(defc, mods, lookup.lookupClass(), isSpecialInvoke);
+if (Modifier.isPublic(mods) && Modifier.isPublic(refc.getModifiers()))
+return;  // common case
+int requestedModes = fixmods(mods);  // adjust 0 => PACKAGE
+if ((requestedModes & allowedModes) != 0
+&& VerifyAccess.isMemberAccessible(refc, m.getDeclaringClass(),
+mods, lookupClass()))
+return;
+if (((requestedModes & ~allowedModes) & PROTECTED) != 0
+&& VerifyAccess.isSamePackage(m.getDeclaringClass(), lookupClass()))
+// Protected members can also be checked as if they were package-private.
+return;
+throw newNoAccessException(accessFailedMessage(refc, m), m, lookupClass());
+}
+String accessFailedMessage(Class<?> refc, MemberName m) {
+Class<?> defc = m.getDeclaringClass();
+int mods = m.getModifiers();
+if (!VerifyAccess.isClassAccessible(defc, lookupClass()))
+return "class is not public";
+if (refc != defc && !VerifyAccess.isClassAccessible(refc, lookupClass()))
+return "symbolic reference "+refc.getName()+" is not public";
+if (Modifier.isPublic(mods))
+return "access to public member failed";  // (how?)
+else if (allowedModes == PUBLIC)
+return "member is not public";
+if (Modifier.isPrivate(mods))
+return "member is private";
+if (Modifier.isProtected(mods))
+return "member is protected";
+return "member is private to package";
+}
+void checkSpecialCaller(Class<?> specialCaller) {
+if (allowedModes == TRUSTED)  return;
+if (!VerifyAccess.isSamePackageMember(specialCaller, lookupClass()))
+throw newNoAccessException("no private access for invokespecial",
+new MemberName(specialCaller), lookupClass());
+}
+MethodHandle restrictProtectedReceiver(MemberName method, MethodHandle mh) {
+// The accessing class only has the right to use a protected member
+// on itself or a subclass.  Enforce that restriction, from JVMS 5.4.4, etc.
+if (!method.isProtected() || method.isStatic()
+|| allowedModes == TRUSTED
+|| VerifyAccess.isSamePackageMember(method.getDeclaringClass(), lookupClass()))
+return mh;
+else
+return restrictReceiver(method, mh, lookupClass());
+}
+MethodHandle restrictReceiver(MemberName method, MethodHandle mh, Class<?> caller) {
+assert(!method.isStatic());
+Class<?> defc = method.getDeclaringClass();  // receiver type of mh is too wide
+if (defc.isInterface() || !defc.isAssignableFrom(caller)) {
+throw newNoAccessException("caller class must be a subclass below the method", method, caller);
 }
-if (constraint == null) {
+MethodType rawType = mh.type();
-throw newNoAccessException(m, lookup);
+if (rawType.parameterType(0) == caller)  return mh;
-}
+MethodType narrowType = rawType.changeParameterType(0, caller);
-if (constraint != defc && !constraint.isAssignableFrom(defc)) {
+return MethodHandleImpl.convertArguments(IMPL_TOKEN, mh, narrowType, rawType, null);
-if (!defc.isAssignableFrom(constraint))
+}
-throw newNoAccessException("receiver must be in caller class", m, lookup.lookupClass());
-if (m.isInvocable())
+MethodHandle makeAccessor(Class<?> refc, String name, Class<?> type,
-narrowMethodType = m.getInvocationType().changeParameterType(0, constraint);
+boolean isStatic, boolean isSetter) throws NoAccessException {
-else if (m.isField())
+MemberName field = resolveOrFail(refc, name, type, isStatic);
-narrowMethodType = (!isSetter
+if (isStatic != field.isStatic())
-? MethodType.methodType(m.getFieldType(), constraint)
+throw newNoAccessException(isStatic
-: MethodType.methodType(void.class, constraint, m.getFieldType()));
+? "expected a static field"
-}
+: "expected a non-static field",
-}
+field, lookupClass());
-if (m.isInvocable())
+return makeAccessor(refc, field, false, isSetter);
-return MethodHandleImpl.findMethod(IMPL_TOKEN, m, doDispatch, lookup.lookupClass());
+}
-else if (m.isField())
-return MethodHandleImpl.accessField(IMPL_TOKEN, m, isSetter, lookup.lookupClass());
+MethodHandle makeAccessor(Class<?> refc, MemberName field,
-else
+boolean trusted, boolean isSetter) throws NoAccessException {
-throw new InternalError();
+assert(field.isField());
+if (trusted)
+return MethodHandleImpl.accessField(IMPL_TOKEN, field, isSetter, lookupClassOrNull());
+checkAccess(refc, field);
+MethodHandle mh = MethodHandleImpl.accessField(IMPL_TOKEN, field, isSetter, lookupClassOrNull());
+return restrictProtectedReceiver(field, mh);
+}
 }
 /**
 * <em>PROVISIONAL API, WORK IN PROGRESS:</em>
 * Produce a method handle giving read access to elements of an array.
 * </pre></blockquote>
 * @return a method handle which always invokes the call site's target
 */
 public static
 MethodHandle dynamicInvoker(CallSite site) {
-MethodHandle getTarget = MethodHandleImpl.bindReceiver(IMPL_TOKEN, CallSite.GET_TARGET, site);
+MethodHandle getCSTarget = GET_TARGET;
+if (getCSTarget == null)
+GET_TARGET = getCSTarget = Lookup.IMPL_LOOKUP.
+findVirtual(CallSite.class, "getTarget", MethodType.methodType(MethodHandle.class));
+MethodHandle getTarget = MethodHandleImpl.bindReceiver(IMPL_TOKEN, getCSTarget, site);
 MethodHandle invoker = exactInvoker(site.type());
 return foldArguments(invoker, getTarget);
 }
+private static MethodHandle GET_TARGET = null;  // link this lazily, not eagerly
 static Invokers invokers(MethodType type) {
 return MethodTypeImpl.invokers(IMPL_TOKEN, type);
 }
 * <p>
 * <b>Example:</b>
 * <p><blockquote><pre>
 *   MethodHandle cat = MethodHandles.lookup().
 *     findVirtual(String.class, "concat", String.class, String.class);
-*   System.out.println(cat.&lt;String&gt;invoke("x", "y")); // xy
+*   System.out.println(cat.&lt;String&gt;invokeExact("x", "y")); // xy
 *   MethodHandle d0 = dropArguments(cat, 0, String.class);
-*   System.out.println(d0.&lt;String&gt;invoke("x", "y", "z")); // xy
+*   System.out.println(d0.&lt;String&gt;invokeExact("x", "y", "z")); // xy
 *   MethodHandle d1 = dropArguments(cat, 1, String.class);
-*   System.out.println(d1.&lt;String&gt;invoke("x", "y", "z")); // xz
+*   System.out.println(d1.&lt;String&gt;invokeExact("x", "y", "z")); // xz
 *   MethodHandle d2 = dropArguments(cat, 2, String.class);
-*   System.out.println(d2.&lt;String&gt;invoke("x", "y", "z")); // yz
+*   System.out.println(d2.&lt;String&gt;invokeExact("x", "y", "z")); // yz
 *   MethodHandle d12 = dropArguments(cat, 1, String.class, String.class);
-*   System.out.println(d12.&lt;String&gt;invoke("w", "x", "y", "z")); // wz
+*   System.out.println(d12.&lt;String&gt;invokeExact("w", "x", "y", "z")); // wz
 * </pre></blockquote>
 * @param target the method handle to invoke after the argument is dropped
 * @param valueTypes the type(s) of the argument to drop
 * @param pos which argument to drop (zero for the first)
 * @return a new method handle which drops an argument of the given type,
 choose = appendArgument(choose, target);
 choose = appendArgument(choose, fallback);
 MethodHandle dispatch = compose(choose, test);
 // dispatch = \(a...).(test(a...) ? target : fallback)
 return combineArguments(invoke, dispatch, 0);
-// return \(a...).((test(a...) ? target : fallback).invoke(a...))
+// return \(a...).((test(a...) ? target : fallback).invokeExact(a...))
 } */
 return MethodHandleImpl.makeGuardWithTest(IMPL_TOKEN, test, target, fallback);
 }
 static RuntimeException misMatchedTypes(String what, MethodType t1, MethodType t2) {
 */
 public static
 MethodHandle throwException(Class<?> returnType, Class<? extends Throwable> exType) {
 return MethodHandleImpl.throwException(IMPL_TOKEN, MethodType.methodType(returnType, exType));
 }
-/** Alias for {@link MethodType#methodType}. */
-@Deprecated // "use MethodType.methodType instead"
-public static MethodType methodType(Class<?> rtype) {
-return MethodType.methodType(rtype);
-}
-/** Alias for {@link MethodType#methodType}. */
-@Deprecated // "use MethodType.methodType instead"
-public static MethodType methodType(Class<?> rtype, Class<?> ptype) {
-return MethodType.methodType(rtype, ptype);
-}
-/** Alias for {@link MethodType#methodType}. */
-@Deprecated // "use MethodType.methodType instead"
-public static MethodType methodType(Class<?> rtype, Class<?> ptype0, Class<?>... ptypes) {
-return MethodType.methodType(rtype, ptype0, ptypes);
-}
 }

changeset 5725	16c1792b2ee6
parent 5506	202f599c92aa
parent 5722	4ada807383c8
child 5727	f825b9b605e4