1 /*

     2  * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

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

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

    10  *

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

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

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

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

    15  * accompanied this code).

    16  *

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

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

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

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package java.dyn;

    27 

    28 import java.lang.reflect.*;

    29 import sun.dyn.Access;

    30 import sun.dyn.MemberName;

    31 import sun.dyn.MethodHandleImpl;

    32 import sun.dyn.WrapperInstance;

    33 import sun.dyn.util.ValueConversions;

    34 import sun.dyn.util.VerifyAccess;

    35 import sun.dyn.util.Wrapper;

    36 import java.util.List;

    37 import java.util.ArrayList;

    38 import java.util.Arrays;

    39 import sun.dyn.Invokers;

    40 import sun.dyn.MethodTypeImpl;

    41 import sun.reflect.Reflection;

    42 import static sun.dyn.MemberName.newIllegalArgumentException;

    43 import static sun.dyn.MemberName.newNoAccessException;

    44 

    45 /**

    46  * This class consists exclusively of static methods that operate on or return

    47  * method handles. They fall into several categories:

    48  * <ul>

    49  * <li>Lookup methods which help create method handles for methods and fields.

    50  * <li>Combinator methods, which combine or transform pre-existing method handles into new ones.

    51  * <li>Other factory methods to create method handles that emulate other common JVM operations or control flow patterns.

    52  * <li>Wrapper methods which can convert between method handles and other function-like "SAM types".

    53  * </ul>

    54  * <p>

    55  * @author John Rose, JSR 292 EG

    56  */

    57 public class MethodHandles {

    58 

    59     private MethodHandles() { }  // do not instantiate

    60 

    61     private static final Access IMPL_TOKEN = Access.getToken();

    62     private static final MemberName.Factory IMPL_NAMES = MemberName.getFactory(IMPL_TOKEN);

    63     static { MethodHandleImpl.initStatics(); }

    64     // See IMPL_LOOKUP below.

    65 

    66     //// Method handle creation from ordinary methods.

    67 

    68     /**

    69      * Return a {@link Lookup lookup object} on the caller,

    70      * which has the capability to access any method handle that the caller has access to,

    71      * including direct method handles to private fields and methods.

    72      * This lookup object is a <em>capability</em> which may be delegated to trusted agents.

    73      * Do not store it in place where untrusted code can access it.

    74      */

    75     public static Lookup lookup() {

    76         return new Lookup();

    77     }

    78 

    79     /**

    80      * Return a {@link Lookup lookup object} which is trusted minimally.

    81      * It can only be used to create method handles to

    82      * publicly accessible fields and methods.

    83      * <p>

    84      * As a matter of pure convention, the {@linkplain Lookup#lookupClass lookup class}

    85      * of this lookup object will be {@link java.lang.Object}.

    86      * <p>

    87      * The lookup class can be changed to any other class {@code C} using an expression of the form

    88      * {@linkplain Lookup#in <code>publicLookup().in(C.class)</code>}.

    89      * Since all classes have equal access to public names,

    90      * such a change would confer no new access rights.

    91      */

    92     public static Lookup publicLookup() {

    93         return Lookup.PUBLIC_LOOKUP;

    94     }

    95 

    96     /**

    97      * A <em>lookup object</em> is a factory for creating method handles,

    98      * when the creation requires access checking.

    99      * Method handles do not perform

   100      * access checks when they are called, but rather when they are created.

   101      * Therefore, method handle access

   102      * restrictions must be enforced when a method handle is created.

   103      * The caller class against which those restrictions are enforced

   104      * is known as the {@linkplain #lookupClass lookup class}.

   105      * <p>

   106      * A lookup class which needs to create method handles will call

   107      * {@link MethodHandles#lookup MethodHandles.lookup} to create a factory for itself.

   108      * When the {@code Lookup} factory object is created, the identity of the lookup class is

   109      * determined, and securely stored in the {@code Lookup} object.

   110      * The lookup class (or its delegates) may then use factory methods

   111      * on the {@code Lookup} object to create method handles for access-checked members.

   112      * This includes all methods, constructors, and fields which are allowed to the lookup class,

   113      * even private ones.

   114      * <p>

   115      * The factory methods on a {@code Lookup} object correspond to all major

   116      * use cases for methods, constructors, and fields.

   117      * Here is a summary of the correspondence between these factory methods and

   118      * the behavior the resulting method handles:

   119      * <code>

   120      * <table border=1 cellpadding=5 summary="lookup method behaviors">

   121      * <tr><th>lookup expression</th><th>member</th><th>behavior</th></tr>

   122      * <tr>

   123      *     <td>{@linkplain java.dyn.MethodHandles.Lookup#findGetter lookup.findGetter(C.class,"f",FT.class)}</td>

   124      *     <td>FT f;</td><td>(T) this.f;</td>

   125      * </tr>

   126      * <tr>

   127      *     <td>{@linkplain java.dyn.MethodHandles.Lookup#findStaticGetter lookup.findStaticGetter(C.class,"f",FT.class)}</td>

   128      *     <td>static<br>FT f;</td><td>(T) C.f;</td>

   129      * </tr>

   130      * <tr>

   131      *     <td>{@linkplain java.dyn.MethodHandles.Lookup#findSetter lookup.findSetter(C.class,"f",FT.class)}</td>

   132      *     <td>FT f;</td><td>this.f = x;</td>

   133      * </tr>

   134      * <tr>

   135      *     <td>{@linkplain java.dyn.MethodHandles.Lookup#findStaticSetter lookup.findStaticSetter(C.class,"f",FT.class)}</td>

   136      *     <td>static<br>FT f;</td><td>C.f = arg;</td>

   137      * </tr>

   138      * <tr>

   139      *     <td>{@linkplain java.dyn.MethodHandles.Lookup#findVirtual lookup.findVirtual(C.class,"m",MT)}</td>

   140      *     <td>T m(A*);</td><td>(T) this.m(arg*);</td>

   141      * </tr>

   142      * <tr>

   143      *     <td>{@linkplain java.dyn.MethodHandles.Lookup#findStatic lookup.findStatic(C.class,"m",MT)}</td>

   144      *     <td>static<br>T m(A*);</td><td>(T) C.m(arg*);</td>

   145      * </tr>

   146      * <tr>

   147      *     <td>{@linkplain java.dyn.MethodHandles.Lookup#findSpecial lookup.findSpecial(C.class,"m",MT,this.class)}</td>

   148      *     <td>T m(A*);</td><td>(T) super.m(arg*);</td>

   149      * </tr>

   150      * <tr>

   151      *     <td>{@linkplain java.dyn.MethodHandles.Lookup#findConstructor lookup.findConstructor(C.class,MT)}</td>

   152      *     <td>C(A*);</td><td>(T) new C(arg*);</td>

   153      * </tr>

   154      * <tr>

   155      *     <td>{@linkplain java.dyn.MethodHandles.Lookup#unreflectGetter lookup.unreflectGetter(aField)}</td>

   156      *     <td>(static)?<br>FT f;</td><td>(FT) aField.get(thisOrNull);</td>

   157      * </tr>

   158      * <tr>

   159      *     <td>{@linkplain java.dyn.MethodHandles.Lookup#unreflectSetter lookup.unreflectSetter(aField)}</td>

   160      *     <td>(static)?<br>FT f;</td><td>aField.set(thisOrNull, arg);</td>

   161      * </tr>

   162      * <tr>

   163      *     <td>{@linkplain java.dyn.MethodHandles.Lookup#unreflect lookup.unreflect(aMethod)}</td>

   164      *     <td>(static)?<br>T m(A*);</td><td>(T) aMethod.invoke(thisOrNull, arg*);</td>

   165      * </tr>

   166      * <tr>

   167      *     <td>{@linkplain java.dyn.MethodHandles.Lookup#unreflectConstructor lookup.unreflectConstructor(aConstructor)}</td>

   168      *     <td>C(A*);</td><td>(C) aConstructor.newInstance(arg*);</td>

   169      * </tr>

   170      * <tr>

   171      *     <td>{@linkplain java.dyn.MethodHandles.Lookup#unreflect lookup.unreflect(aMethod)}</td>

   172      *     <td>(static)?<br>T m(A*);</td><td>(T) aMethod.invoke(thisOrNull, arg*);</td>

   173      * </tr>

   174      * </table>

   175      * </code>

   176      * Here, the type {@code C} is the class or interface being searched for a member,

   177      * documented as a parameter named {@code refc} in the lookup methods.

   178      * The method or constructor type {@code MT} is composed from the return type {@code T}

   179      * and the sequence of argument types {@code A*}.

   180      * Both {@code MT} and the field type {@code FT} are documented as a parameter named {@code type}.

   181      * The formal parameter {@code this} stands for the self-reference of type {@code C};

   182      * if it is present, it is always the leading argument to the method handle invocation.

   183      * The name {@code arg} stands for all the other method handle arguments.

   184      * In the code examples for the Core Reflection API, the name {@code thisOrNull}

   185      * stands for a null reference if the accessed method or field is static,

   186      * and {@code this} otherwise.

   187      * The names {@code aMethod}, {@code aField}, and {@code aConstructor} stand

   188      * for reflective objects corresponding to the given members.

   189      * <p>

   190      * The equivalence between looked-up method handles and underlying

   191      * class members can break down in a few ways:

   192      * <ul>

   193      * <li>If {@code C} is not symbolically accessible from the lookup class's loader,

   194      * the lookup can still succeed, even when there is no equivalent

   195      * Java expression or bytecoded constant.

   196      * <li>Likewise, if {@code T} or {@code MT}

   197      * is not symbolically accessible from the lookup class's loader,

   198      * the lookup can still succeed.

   199      * For example, lookups for {@code MethodHandle.invokeExact} and

   200      * {@code MethodHandle.invokeGeneric} will always succeed, regardless of requested type.

   201      * <li>If there is a security manager installed, it can forbid the lookup

   202      * on various grounds (<a href="#secmgr">see below</a>).

   203      * By contrast, the {@code ldc} instruction is not subject to

   204      * security manager checks.

   205      * </ul>

   206      *

   207      * <h3><a name="access"></a>Access checking</h3>

   208      * Access checks are applied in the factory methods of {@code Lookup},

   209      * when a method handle is created.

   210      * This is a key difference from the Core Reflection API, since

   211      * {@link java.lang.reflect.Method#invoke Method.invoke}

   212      * performs access checking against every caller, on every call.

   213      * <p>

   214      * All access checks start from a {@code Lookup} object, which

   215      * compares its recorded lookup class against all requests to

   216      * create method handles.

   217      * A single {@code Lookup} object can be used to create any number

   218      * of access-checked method handles, all checked against a single

   219      * lookup class.

   220      * <p>

   221      * A {@code Lookup} object can be shared with other trusted code,

   222      * such as a metaobject protocol.

   223      * A shared {@code Lookup} object delegates the capability

   224      * to create method handles on private members of the lookup class.

   225      * Even if privileged code uses the {@code Lookup} object,

   226      * the access checking is confined to the privileges of the

   227      * original lookup class.

   228      * <p>

   229      * A lookup can fail, because

   230      * the containing class is not accessible to the lookup class, or

   231      * because the desired class member is missing, or because the

   232      * desired class member is not accessible to the lookup class.

   233      * In any of these cases, a {@code ReflectiveOperationException} will be

   234      * thrown from the attempted lookup.  The exact class will be one of

   235      * the following:

   236      * <ul>

   237      * <li>NoSuchMethodException &mdash; if a method is requested but does not exist

   238      * <li>NoSuchFieldException &mdash; if a field is requested but does not exist

   239      * <li>IllegalAccessException &mdash; if the member exists but an access check fails

   240      * </ul>

   241      * <p>

   242      * In general, the conditions under which a method handle may be

   243      * looked up for a method {@code M} are exactly equivalent to the conditions

   244      * under which the lookup class could have compiled and resolved a call to {@code M}.

   245      * And the effect of invoking the method handle resulting from the lookup

   246      * is exactly equivalent to executing the compiled and resolved call to {@code M}.

   247      * The same point is true of fields and constructors.

   248      * <p>

   249      * In some cases, access between nested classes is obtained by the Java compiler by creating

   250      * an wrapper method to access a private method of another class

   251      * in the same top-level declaration.

   252      * For example, a nested class {@code C.D}

   253      * can access private members within other related classes such as

   254      * {@code C}, {@code C.D.E}, or {@code C.B},

   255      * but the Java compiler may need to generate wrapper methods in

   256      * those related classes.  In such cases, a {@code Lookup} object on

   257      * {@code C.E} would be unable to those private members.

   258      * A workaround for this limitation is the {@link Lookup#in Lookup.in} method,

   259      * which can transform a lookup on {@code C.E} into one on any of those other

   260      * classes, without special elevation of privilege.

   261      * <p>

   262      * Although bytecode instructions can only refer to classes in

   263      * a related class loader, this API can search for methods in any

   264      * class, as long as a reference to its {@code Class} object is

   265      * available.  Such cross-loader references are also possible with the

   266      * Core Reflection API, and are impossible to bytecode instructions

   267      * such as {@code invokestatic} or {@code getfield}.

   268      * There is a {@linkplain java.lang.SecurityManager security manager API}

   269      * to allow applications to check such cross-loader references.

   270      * These checks apply to both the {@code MethodHandles.Lookup} API

   271      * and the Core Reflection API

   272      * (as found on {@link java.lang.Class Class}).

   273      * <p>

   274      * Access checks only apply to named and reflected methods,

   275      * constructors, and fields.

   276      * Other method handle creation methods, such as

   277      * {@link #convertArguments MethodHandles.convertArguments},

   278      * do not require any access checks, and are done

   279      * with static methods of {@link MethodHandles},

   280      * independently of any {@code Lookup} object.

   281      *

   282      * <h3>Security manager interactions</h3>

   283      * <a name="secmgr"></a>

   284      * If a security manager is present, member lookups are subject to

   285      * additional checks.

   286      * From one to four calls are made to the security manager.

   287      * Any of these calls can refuse access by throwing a

   288      * {@link java.lang.SecurityException SecurityException}.

   289      * Define {@code smgr} as the security manager,

   290      * {@code refc} as the containing class in which the member

   291      * is being sought, and {@code defc} as the class in which the

   292      * member is actually defined.

   293      * The calls are made according to the following rules:

   294      * <ul>

   295      * <li>In all cases, {@link SecurityManager#checkMemberAccess

   296      *     smgr.checkMemberAccess(refc, Member.PUBLIC)} is called.

   297      * <li>If the class loader of the lookup class is not

   298      *     the same as or an ancestor of the class loader of {@code refc},

   299      *     then {@link SecurityManager#checkPackageAccess

   300      *     smgr.checkPackageAccess(refcPkg)} is called,

   301      *     where {@code refcPkg} is the package of {@code refc}.

   302      * <li>If the retrieved member is not public,

   303      *     {@link SecurityManager#checkMemberAccess

   304      *     smgr.checkMemberAccess(defc, Member.DECLARED)} is called.

   305      *     (Note that {@code defc} might be the same as {@code refc}.)

   306      * <li>If the retrieved member is not public,

   307      *     and if {@code defc} and {@code refc} are in different class loaders,

   308      *     and if the class loader of the lookup class is not

   309      *     the same as or an ancestor of the class loader of {@code defc},

   310      *     then {@link SecurityManager#checkPackageAccess

   311      *     smgr.checkPackageAccess(defcPkg)} is called,

   312      *     where {@code defcPkg} is the package of {@code defc}.

   313      * </ul>

   314      * In all cases, the requesting class presented to the security

   315      * manager will be the lookup class from the current {@code Lookup} object.

   316      */

   317     public static final

   318     class Lookup {

   319         /** The class on behalf of whom the lookup is being performed. */

   320         private final Class<?> lookupClass;

   321 

   322         /** The allowed sorts of members which may be looked up (PUBLIC, etc.). */

   323         private final int allowedModes;

   324 

   325         /** A single-bit mask representing {@code public} access,

   326          *  which may contribute to the result of {@link #lookupModes lookupModes}.

   327          *  The value, {@code 0x01}, happens to be the same as the value of the

   328          *  {@code public} {@linkplain java.lang.reflect.Modifier#PUBLIC modifier bit}.

   329          */

   330         public static final int PUBLIC = Modifier.PUBLIC;

   331 

   332         /** A single-bit mask representing {@code private} access,

   333          *  which may contribute to the result of {@link #lookupModes lookupModes}.

   334          *  The value, {@code 0x02}, happens to be the same as the value of the

   335          *  {@code private} {@linkplain java.lang.reflect.Modifier#PRIVATE modifier bit}.

   336          */

   337         public static final int PRIVATE = Modifier.PRIVATE;

   338 

   339         /** A single-bit mask representing {@code protected} access,

   340          *  which may contribute to the result of {@link #lookupModes lookupModes}.

   341          *  The value, {@code 0x04}, happens to be the same as the value of the

   342          *  {@code protected} {@linkplain java.lang.reflect.Modifier#PROTECTED modifier bit}.

   343          */

   344         public static final int PROTECTED = Modifier.PROTECTED;

   345 

   346         /** A single-bit mask representing {@code package} access (default access),

   347          *  which may contribute to the result of {@link #lookupModes lookupModes}.

   348          *  The value is {@code 0x08}, which does not correspond meaningfully to

   349          *  any particular {@linkplain java.lang.reflect.Modifier modifier bit}.

   350          */

   351         public static final int PACKAGE = Modifier.STATIC;

   352 

   353         private static final int ALL_MODES = (PUBLIC | PRIVATE | PROTECTED | PACKAGE);

   354         private static final int TRUSTED   = -1;

   355 

   356         private static int fixmods(int mods) {

   357             mods &= (ALL_MODES - PACKAGE);

   358             return (mods != 0) ? mods : PACKAGE;

   359         }

   360 

   361         /** Tells which class is performing the lookup.  It is this class against

   362          *  which checks are performed for visibility and access permissions.

   363          *  <p>

   364          *  The class implies a maximum level of access permission,

   365          *  but the permissions may be additionally limited by the bitmask

   366          *  {@link #lookupModes lookupModes}, which controls whether non-public members

   367          *  can be accessed.

   368          */

   369         public Class<?> lookupClass() {

   370             return lookupClass;

   371         }

   372 

   373         // This is just for calling out to MethodHandleImpl.

   374         private Class<?> lookupClassOrNull() {

   375             return (allowedModes == TRUSTED) ? null : lookupClass;

   376         }

   377 

   378         /** Tells which access-protection classes of members this lookup object can produce.

   379          *  The result is a bit-mask of the bits

   380          *  {@linkplain #PUBLIC PUBLIC (0x01)},

   381          *  {@linkplain #PRIVATE PRIVATE (0x02)},

   382          *  {@linkplain #PROTECTED PROTECTED (0x04)},

   383          *  and {@linkplain #PACKAGE PACKAGE (0x08)}.

   384          *  <p>

   385          *  A freshly-created lookup object

   386          *  on the {@linkplain java.dyn.MethodHandles#lookup() caller's class}

   387          *  has all possible bits set, since the caller class can access all its own members.

   388          *  A lookup object on a new lookup class

   389          *  {@linkplain java.dyn.MethodHandles.Lookup#in created from a previous lookup object}

   390          *  may have some mode bits set to zero.

   391          *  The purpose of this is to restrict access via the new lookup object,

   392          *  so that it can access only names which can be reached by the original

   393          *  lookup object, and also by the new lookup class.

   394          */

   395         public int lookupModes() {

   396             return allowedModes & ALL_MODES;

   397         }

   398 

   399         /** Embody the current class (the lookupClass) as a lookup class

   400          * for method handle creation.

   401          * Must be called by from a method in this package,

   402          * which in turn is called by a method not in this package.

   403          * <p>

   404          * Also, don't make it private, lest javac interpose

   405          * an access$N method.

   406          */

   407         Lookup() {

   408             this(getCallerClassAtEntryPoint(), ALL_MODES);

   409             // make sure we haven't accidentally picked up a privileged class:

   410             checkUnprivilegedlookupClass(lookupClass);

   411         }

   412 

   413         Lookup(Access token, Class<?> lookupClass) {

   414             this(lookupClass, ALL_MODES);

   415             Access.check(token);

   416         }

   417 

   418         private Lookup(Class<?> lookupClass, int allowedModes) {

   419             this.lookupClass = lookupClass;

   420             this.allowedModes = allowedModes;

   421         }

   422 

   423         /**

   424          * Creates a lookup on the specified new lookup class.

   425          * The resulting object will report the specified

   426          * class as its own {@link #lookupClass lookupClass}.

   427          * <p>

   428          * However, the resulting {@code Lookup} object is guaranteed

   429          * to have no more access capabilities than the original.

   430          * In particular, access capabilities can be lost as follows:<ul>

   431          * <li>If the new lookup class differs from the old one,

   432          * protected members will not be accessible by virtue of inheritance.

   433          * (Protected members may continue to be accessible because of package sharing.)

   434          * <li>If the new lookup class is in a different package

   435          * than the old one, protected and default (package) members will not be accessible.

   436          * <li>If the new lookup class is not within the same package member

   437          * as the old one, private members will not be accessible.

   438          * <li>If the new lookup class is not accessible to the old lookup class,

   439          * then no members, not even public members, will be accessible.

   440          * (In all other cases, public members will continue to be accessible.)

   441          * </ul>

   442          *

   443          * @param requestedLookupClass the desired lookup class for the new lookup object

   444          * @return a lookup object which reports the desired lookup class

   445          * @throws NullPointerException if the argument is null

   446          */

   447         public Lookup in(Class<?> requestedLookupClass) {

   448             requestedLookupClass.getClass();  // null check

   449             if (allowedModes == TRUSTED)  // IMPL_LOOKUP can make any lookup at all

   450                 return new Lookup(requestedLookupClass, ALL_MODES);

   451             if (requestedLookupClass == this.lookupClass)

   452                 return this;  // keep same capabilities

   453             int newModes = (allowedModes & (ALL_MODES & ~PROTECTED));

   454             if ((newModes & PACKAGE) != 0

   455                 && !VerifyAccess.isSamePackage(this.lookupClass, requestedLookupClass)) {

   456                 newModes &= ~(PACKAGE|PRIVATE);

   457             }

   458             // Allow nestmate lookups to be created without special privilege:

   459             if ((newModes & PRIVATE) != 0

   460                 && !VerifyAccess.isSamePackageMember(this.lookupClass, requestedLookupClass)) {

   461                 newModes &= ~PRIVATE;

   462             }

   463             if (newModes == PUBLIC

   464                 && !VerifyAccess.isClassAccessible(requestedLookupClass, this.lookupClass)) {

   465                 // The requested class it not accessible from the lookup class.

   466                 // No permissions.

   467                 newModes = 0;

   468             }

   469             checkUnprivilegedlookupClass(requestedLookupClass);

   470             return new Lookup(requestedLookupClass, newModes);

   471         }

   472 

   473         // Make sure outer class is initialized first.

   474         static { IMPL_TOKEN.getClass(); }

   475 

   476         /** Version of lookup which is trusted minimally.

   477          *  It can only be used to create method handles to

   478          *  publicly accessible members.

   479          */

   480         static final Lookup PUBLIC_LOOKUP = new Lookup(Object.class, PUBLIC);

   481 

   482         /** Package-private version of lookup which is trusted. */

   483         static final Lookup IMPL_LOOKUP = new Lookup(Object.class, TRUSTED);

   484         static { MethodHandleImpl.initLookup(IMPL_TOKEN, IMPL_LOOKUP); }

   485 

   486         private static void checkUnprivilegedlookupClass(Class<?> lookupClass) {

   487             String name = lookupClass.getName();

   488             if (name.startsWith("java.dyn.") || name.startsWith("sun.dyn."))

   489                 throw newIllegalArgumentException("illegal lookupClass: "+lookupClass);

   490         }

   491 

   492         /**

   493          * Displays the name of the class from which lookups are to be made.

   494          * (The name is the one reported by {@link java.lang.Class#getName() Class.getName}.)

   495          * If there are restrictions on the access permitted to this lookup,

   496          * this is indicated by adding a suffix to the class name, consisting

   497          * of a slash and a keyword.  The keyword represents the strongest

   498          * allowed access, and is chosen as follows:

   499          * <ul>

   500          * <li>If no access is allowed, the suffix is "/noaccess".

   501          * <li>If only public access is allowed, the suffix is "/public".

   502          * <li>If only public and package access are allowed, the suffix is "/package".

   503          * <li>If only public, package, and private access are allowed, the suffix is "/private".

   504          * </ul>

   505          * If none of the above cases apply, it is the case that full

   506          * access (public, package, private, and protected) is allowed.

   507          * In this case, no suffix is added.

   508          * This is true only of an object obtained originally from

   509          * {@link java.dyn.MethodHandles#lookup MethodHandles.lookup}.

   510          * Objects created by {@link java.dyn.MethodHandles.Lookup#in Lookup.in}

   511          * always have restricted access, and will display a suffix.

   512          * <p>

   513          * (It may seem strange that protected access should be

   514          * stronger than private access.  Viewed independently from

   515          * package access, protected access is the first to be lost,

   516          * because it requires a direct subclass relationship between

   517          * caller and callee.)

   518          * @see #in

   519          */

   520         @Override

   521         public String toString() {

   522             String cname = lookupClass.getName();

   523             switch (allowedModes) {

   524             case 0:  // no privileges

   525                 return cname + "/noaccess";

   526             case PUBLIC:

   527                 return cname + "/public";

   528             case PUBLIC|PACKAGE:

   529                 return cname + "/package";

   530             case ALL_MODES & ~PROTECTED:

   531                 return cname + "/private";

   532             case ALL_MODES:

   533                 return cname;

   534             case TRUSTED:

   535                 return "/trusted";  // internal only; not exported

   536             default:  // Should not happen, but it's a bitfield...

   537                 cname = cname + "/" + Integer.toHexString(allowedModes);

   538                 assert(false) : cname;

   539                 return cname;

   540             }

   541         }

   542 

   543         // call this from an entry point method in Lookup with extraFrames=0.

   544         private static Class<?> getCallerClassAtEntryPoint() {

   545             final int CALLER_DEPTH = 4;

   546             // 0: Reflection.getCC, 1: getCallerClassAtEntryPoint,

   547             // 2: Lookup.<init>, 3: MethodHandles.*, 4: caller

   548             // Note:  This should be the only use of getCallerClass in this file.

   549             assert(Reflection.getCallerClass(CALLER_DEPTH-1) == MethodHandles.class);

   550             return Reflection.getCallerClass(CALLER_DEPTH);

   551         }

   552 

   553         /**

   554          * Produces a method handle for a static method.

   555          * The type of the method handle will be that of the method.

   556          * (Since static methods do not take receivers, there is no

   557          * additional receiver argument inserted into the method handle type,

   558          * as there would be with {@link #findVirtual findVirtual} or {@link #findSpecial findSpecial}.)

   559          * The method and all its argument types must be accessible to the lookup class.

   560          * If the method's class has not yet been initialized, that is done

   561          * immediately, before the method handle is returned.

   562          * <p>

   563          * The returned method handle will have

   564          * {@linkplain MethodHandle#asVarargsCollector variable arity} if and only if

   565          * the method's variable arity modifier bit ({@code 0x0080}) is set.

   566          * @param refc the class from which the method is accessed

   567          * @param name the name of the method

   568          * @param type the type of the method

   569          * @return the desired method handle

   570          * @throws NoSuchMethodException if the method does not exist

   571          * @throws IllegalAccessException if access checking fails, or if the method is not {@code static}

   572          * @exception SecurityException if a security manager is present and it

   573          *                              <a href="MethodHandles.Lookup.html#secmgr">refuses access</a>

   574          * @throws NullPointerException if any argument is null

   575          */

   576         public

   577         MethodHandle findStatic(Class<?> refc, String name, MethodType type) throws NoSuchMethodException, IllegalAccessException {

   578             MemberName method = resolveOrFail(refc, name, type, true);

   579             checkMethod(refc, method, true);

   580             return MethodHandleImpl.findMethod(IMPL_TOKEN, method, false, lookupClassOrNull());

   581         }

   582 

   583         /**

   584          * Produces a method handle for a virtual method.

   585          * The type of the method handle will be that of the method,

   586          * with the receiver type (usually {@code refc}) prepended.

   587          * The method and all its argument types must be accessible to the lookup class.

   588          * <p>

   589          * When called, the handle will treat the first argument as a receiver

   590          * and dispatch on the receiver's type to determine which method

   591          * implementation to enter.

   592          * (The dispatching action is identical with that performed by an

   593          * {@code invokevirtual} or {@code invokeinterface} instruction.)

   594          * <p>

   595          * The returned method handle will have

   596          * {@linkplain MethodHandle#asVarargsCollector variable arity} if and only if

   597          * the method's variable arity modifier bit ({@code 0x0080}) is set.

   598          * <p>

   599          * Because of the general equivalence between {@code invokevirtual}

   600          * instructions and method handles produced by {@code findVirtual},

   601          * if the class is {@code MethodHandle} and the name string is

   602          * {@code invokeExact} or {@code invokeGeneric}, the resulting

   603          * method handle is equivalent to one produced by

   604          * {@link java.dyn.MethodHandles#exactInvoker MethodHandles.exactInvoker} or

   605          * {@link java.dyn.MethodHandles#genericInvoker MethodHandles.genericInvoker}

   606          * with the same {@code type} argument.

   607          *

   608          * @param refc the class or interface from which the method is accessed

   609          * @param name the name of the method

   610          * @param type the type of the method, with the receiver argument omitted

   611          * @return the desired method handle

   612          * @throws NoSuchMethodException if the method does not exist

   613          * @throws IllegalAccessException if access checking fails, or if the method is {@code static}

   614          * @exception SecurityException if a security manager is present and it

   615          *                              <a href="MethodHandles.Lookup.html#secmgr">refuses access</a>

   616          * @throws NullPointerException if any argument is null

   617          */

   618         public MethodHandle findVirtual(Class<?> refc, String name, MethodType type) throws NoSuchMethodException, IllegalAccessException {

   619             MemberName method = resolveOrFail(refc, name, type, false);

   620             checkMethod(refc, method, false);

   621             MethodHandle mh = MethodHandleImpl.findMethod(IMPL_TOKEN, method, true, lookupClassOrNull());

   622             return restrictProtectedReceiver(method, mh);

   623         }

   624 

   625         /**

   626          * Produces a method handle which creates an object and initializes it, using

   627          * the constructor of the specified type.

   628          * The parameter types of the method handle will be those of the constructor,

   629          * while the return type will be a reference to the constructor's class.

   630          * The constructor and all its argument types must be accessible to the lookup class.

   631          * If the constructor's class has not yet been initialized, that is done

   632          * immediately, before the method handle is returned.

   633          * <p>

   634          * Note:  The requested type must have a return type of {@code void}.

   635          * This is consistent with the JVM's treatment of constructor type descriptors.

   636          * <p>

   637          * The returned method handle will have

   638          * {@linkplain MethodHandle#asVarargsCollector variable arity} if and only if

   639          * the constructor's variable arity modifier bit ({@code 0x0080}) is set.

   640          * @param refc the class or interface from which the method is accessed

   641          * @param type the type of the method, with the receiver argument omitted, and a void return type

   642          * @return the desired method handle

   643          * @throws NoSuchMethodException if the constructor does not exist

   644          * @throws IllegalAccessException if access checking fails

   645          * @exception SecurityException if a security manager is present and it

   646          *                              <a href="MethodHandles.Lookup.html#secmgr">refuses access</a>

   647          * @throws NullPointerException if any argument is null

   648          */

   649         public MethodHandle findConstructor(Class<?> refc, MethodType type) throws NoSuchMethodException, IllegalAccessException {

   650             String name = "<init>";

   651             MemberName ctor = resolveOrFail(refc, name, type, false, false, lookupClassOrNull());

   652             assert(ctor.isConstructor());

   653             checkAccess(refc, ctor);

   654             MethodHandle rawMH = MethodHandleImpl.findMethod(IMPL_TOKEN, ctor, false, lookupClassOrNull());

   655             MethodHandle allocMH = MethodHandleImpl.makeAllocator(IMPL_TOKEN, rawMH);

   656             return fixVarargs(allocMH, rawMH);

   657         }

   658 

   659         /** Return a version of MH which matches matchMH w.r.t. isVarargsCollector. */

   660         private static MethodHandle fixVarargs(MethodHandle mh, MethodHandle matchMH) {

   661             boolean va1 = mh.isVarargsCollector();

   662             boolean va2 = matchMH.isVarargsCollector();

   663             if (va1 == va2) {

   664                 return mh;

   665             } else if (va2) {

   666                 MethodType type = mh.type();

   667                 int arity = type.parameterCount();

   668                 return mh.asVarargsCollector(type.parameterType(arity-1));

   669             } else {

   670                 throw new InternalError("already varargs, but template is not: "+mh);

   671             }

   672         }

   673 

   674         /**

   675          * Produces an early-bound method handle for a virtual method,

   676          * as if called from an {@code invokespecial}

   677          * instruction from {@code caller}.

   678          * The type of the method handle will be that of the method,

   679          * with a suitably restricted receiver type (such as {@code caller}) prepended.

   680          * The method and all its argument types must be accessible

   681          * to the caller.

   682          * <p>

   683          * When called, the handle will treat the first argument as a receiver,

   684          * but will not dispatch on the receiver's type.

   685          * (This direct invocation action is identical with that performed by an

   686          * {@code invokespecial} instruction.)

   687          * <p>

   688          * If the explicitly specified caller class is not identical with the

   689          * lookup class, or if this lookup object does not have private access

   690          * privileges, the access fails.

   691          * <p>

   692          * The returned method handle will have

   693          * {@linkplain MethodHandle#asVarargsCollector variable arity} if and only if

   694          * the method's variable arity modifier bit ({@code 0x0080}) is set.

   695          * @param refc the class or interface from which the method is accessed

   696          * @param name the name of the method (which must not be "<init>")

   697          * @param type the type of the method, with the receiver argument omitted

   698          * @param specialCaller the proposed calling class to perform the {@code invokespecial}

   699          * @return the desired method handle

   700          * @throws NoSuchMethodException if the method does not exist

   701          * @throws IllegalAccessException if access checking fails

   702          * @exception SecurityException if a security manager is present and it

   703          *                              <a href="MethodHandles.Lookup.html#secmgr">refuses access</a>

   704          * @throws NullPointerException if any argument is null

   705          */

   706         public MethodHandle findSpecial(Class<?> refc, String name, MethodType type,

   707                                         Class<?> specialCaller) throws NoSuchMethodException, IllegalAccessException {

   708             checkSpecialCaller(specialCaller);

   709             MemberName method = resolveOrFail(refc, name, type, false, false, specialCaller);

   710             checkMethod(refc, method, false);

   711             MethodHandle mh = MethodHandleImpl.findMethod(IMPL_TOKEN, method, false, specialCaller);

   712             return restrictReceiver(method, mh, specialCaller);

   713         }

   714 

   715         /**

   716          * Produces a method handle giving read access to a non-static field.

   717          * The type of the method handle will have a return type of the field's

   718          * value type.

   719          * The method handle's single argument will be the instance containing

   720          * the field.

   721          * Access checking is performed immediately on behalf of the lookup class.

   722          * @param refc the class or interface from which the method is accessed

   723          * @param name the field's name

   724          * @param type the field's type

   725          * @return a method handle which can load values from the field

   726          * @throws NoSuchFieldException if the field does not exist

   727          * @throws IllegalAccessException if access checking fails, or if the field is {@code static}

   728          * @exception SecurityException if a security manager is present and it

   729          *                              <a href="MethodHandles.Lookup.html#secmgr">refuses access</a>

   730          * @throws NullPointerException if any argument is null

   731          */

   732         public MethodHandle findGetter(Class<?> refc, String name, Class<?> type) throws NoSuchFieldException, IllegalAccessException {

   733             return makeAccessor(refc, name, type, false, false);

   734         }

   735 

   736         /**

   737          * Produces a method handle giving write access to a non-static field.

   738          * The type of the method handle will have a void return type.

   739          * The method handle will take two arguments, the instance containing

   740          * the field, and the value to be stored.

   741          * The second argument will be of the field's value type.

   742          * Access checking is performed immediately on behalf of the lookup class.

   743          * @param refc the class or interface from which the method is accessed

   744          * @param name the field's name

   745          * @param type the field's type

   746          * @return a method handle which can store values into the field

   747          * @throws NoSuchFieldException if the field does not exist

   748          * @throws IllegalAccessException if access checking fails, or if the field is {@code static}

   749          * @exception SecurityException if a security manager is present and it

   750          *                              <a href="MethodHandles.Lookup.html#secmgr">refuses access</a>

   751          * @throws NullPointerException if any argument is null

   752          */

   753         public MethodHandle findSetter(Class<?> refc, String name, Class<?> type) throws NoSuchFieldException, IllegalAccessException {

   754             return makeAccessor(refc, name, type, false, true);

   755         }

   756 

   757         /**

   758          * Produces a method handle giving read access to a static field.

   759          * The type of the method handle will have a return type of the field's

   760          * value type.

   761          * The method handle will take no arguments.

   762          * Access checking is performed immediately on behalf of the lookup class.

   763          * @param refc the class or interface from which the method is accessed

   764          * @param name the field's name

   765          * @param type the field's type

   766          * @return a method handle which can load values from the field

   767          * @throws NoSuchFieldException if the field does not exist

   768          * @throws IllegalAccessException if access checking fails, or if the field is not {@code static}

   769          * @exception SecurityException if a security manager is present and it

   770          *                              <a href="MethodHandles.Lookup.html#secmgr">refuses access</a>

   771          * @throws NullPointerException if any argument is null

   772          */

   773         public MethodHandle findStaticGetter(Class<?> refc, String name, Class<?> type) throws NoSuchFieldException, IllegalAccessException {

   774             return makeAccessor(refc, name, type, true, false);

   775         }

   776 

   777         /**

   778          * Produces a method handle giving write access to a static field.

   779          * The type of the method handle will have a void return type.

   780          * The method handle will take a single

   781          * argument, of the field's value type, the value to be stored.

   782          * Access checking is performed immediately on behalf of the lookup class.

   783          * @param refc the class or interface from which the method is accessed

   784          * @param name the field's name

   785          * @param type the field's type

   786          * @return a method handle which can store values into the field

   787          * @throws NoSuchFieldException if the field does not exist

   788          * @throws IllegalAccessException if access checking fails, or if the field is not {@code static}

   789          * @exception SecurityException if a security manager is present and it

   790          *                              <a href="MethodHandles.Lookup.html#secmgr">refuses access</a>

   791          * @throws NullPointerException if any argument is null

   792          */

   793         public MethodHandle findStaticSetter(Class<?> refc, String name, Class<?> type) throws NoSuchFieldException, IllegalAccessException {

   794             return makeAccessor(refc, name, type, true, true);

   795         }

   796 

   797         /**

   798          * Produces an early-bound method handle for a non-static method.

   799          * The receiver must have a supertype {@code defc} in which a method

   800          * of the given name and type is accessible to the lookup class.

   801          * The method and all its argument types must be accessible to the lookup class.

   802          * The type of the method handle will be that of the method,

   803          * without any insertion of an additional receiver parameter.

   804          * The given receiver will be bound into the method handle,

   805          * so that every call to the method handle will invoke the

   806          * requested method on the given receiver.

   807          * <p>

   808          * The returned method handle will have

   809          * {@linkplain MethodHandle#asVarargsCollector variable arity} if and only if

   810          * the method's variable arity modifier bit ({@code 0x0080}) is set

   811          * <em>and</em> the trailing array argument is not the only argument.

   812          * (If the trailing array argument is the only argument,

   813          * the given receiver value will be bound to it.)

   814          * <p>

   815          * This is equivalent to the following code:

   816          * <blockquote><pre>

   817 MethodHandle mh0 = {@link #findVirtual findVirtual}(defc, name, type);

   818 MethodHandle mh1 = mh0.{@link MethodHandle#bindTo bindTo}(receiver);

   819 MethodType mt1 = mh1.type();

   820 if (mh0.isVarargsCollector() && mt1.parameterCount() > 0) {

   821   mh1 = mh1.asVarargsCollector(mt1.parameterType(mt1.parameterCount()-1));

   822 return mh1;

   823          * </pre></blockquote>

   824          * where {@code defc} is either {@code receiver.getClass()} or a super

   825          * type of that class, in which the requested method is accessible

   826          * to the lookup class.

   827          * (Note that {@code bindTo} does not preserve variable arity.)

   828          * @param receiver the object from which the method is accessed

   829          * @param name the name of the method

   830          * @param type the type of the method, with the receiver argument omitted

   831          * @return the desired method handle

   832          * @throws NoSuchMethodException if the method does not exist

   833          * @throws IllegalAccessException if access checking fails

   834          * @exception SecurityException if a security manager is present and it

   835          *                              <a href="MethodHandles.Lookup.html#secmgr">refuses access</a>

   836          * @throws NullPointerException if any argument is null

   837          */

   838         public MethodHandle bind(Object receiver, String name, MethodType type) throws NoSuchMethodException, IllegalAccessException {

   839             Class<? extends Object> refc = receiver.getClass(); // may get NPE

   840             MemberName method = resolveOrFail(refc, name, type, false);

   841             checkMethod(refc, method, false);

   842             MethodHandle dmh = MethodHandleImpl.findMethod(IMPL_TOKEN, method, true, lookupClassOrNull());

   843             MethodHandle bmh = MethodHandleImpl.bindReceiver(IMPL_TOKEN, dmh, receiver);

   844             if (bmh == null)

   845                 throw newNoAccessException(method, this);

   846             if (dmh.type().parameterCount() == 0)

   847                 return dmh;  // bound the trailing parameter; no varargs possible

   848             return fixVarargs(bmh, dmh);

   849         }

   850 

   851         /**

   852          * Make a direct method handle to <i>m</i>, if the lookup class has permission.

   853          * If <i>m</i> is non-static, the receiver argument is treated as an initial argument.

   854          * If <i>m</i> is virtual, overriding is respected on every call.

   855          * Unlike the Core Reflection API, exceptions are <em>not</em> wrapped.

   856          * The type of the method handle will be that of the method,

   857          * with the receiver type prepended (but only if it is non-static).

   858          * If the method's {@code accessible} flag is not set,

   859          * access checking is performed immediately on behalf of the lookup class.

   860          * If <i>m</i> is not public, do not share the resulting handle with untrusted parties.

   861          * <p>

   862          * The returned method handle will have

   863          * {@linkplain MethodHandle#asVarargsCollector variable arity} if and only if

   864          * the method's variable arity modifier bit ({@code 0x0080}) is set.

   865          * @param m the reflected method

   866          * @return a method handle which can invoke the reflected method

   867          * @throws IllegalAccessException if access checking fails

   868          * @throws NullPointerException if the argument is null

   869          */

   870         public MethodHandle unreflect(Method m) throws IllegalAccessException {

   871             MemberName method = new MemberName(m);

   872             assert(method.isMethod());

   873             if (!m.isAccessible())  checkMethod(method.getDeclaringClass(), method, method.isStatic());

   874             MethodHandle mh = MethodHandleImpl.findMethod(IMPL_TOKEN, method, true, lookupClassOrNull());

   875             if (!m.isAccessible())  mh = restrictProtectedReceiver(method, mh);

   876             return mh;

   877         }

   878 

   879         /**

   880          * Produces a method handle for a reflected method.

   881          * It will bypass checks for overriding methods on the receiver,

   882          * as if by a {@code invokespecial} instruction from within the {@code specialCaller}.

   883          * The type of the method handle will be that of the method,

   884          * with the special caller type prepended (and <em>not</em> the receiver of the method).

   885          * If the method's {@code accessible} flag is not set,

   886          * access checking is performed immediately on behalf of the lookup class,

   887          * as if {@code invokespecial} instruction were being linked.

   888          * <p>

   889          * The returned method handle will have

   890          * {@linkplain MethodHandle#asVarargsCollector variable arity} if and only if

   891          * the method's variable arity modifier bit ({@code 0x0080}) is set.

   892          * @param m the reflected method

   893          * @param specialCaller the class nominally calling the method

   894          * @return a method handle which can invoke the reflected method

   895          * @throws IllegalAccessException if access checking fails

   896          * @throws NullPointerException if any argument is null

   897          */

   898         public MethodHandle unreflectSpecial(Method m, Class<?> specialCaller) throws IllegalAccessException {

   899             checkSpecialCaller(specialCaller);

   900             MemberName method = new MemberName(m);

   901             assert(method.isMethod());

   902             // ignore m.isAccessible:  this is a new kind of access

   903             checkMethod(m.getDeclaringClass(), method, false);

   904             MethodHandle mh = MethodHandleImpl.findMethod(IMPL_TOKEN, method, false, lookupClassOrNull());

   905             return restrictReceiver(method, mh, specialCaller);

   906         }

   907 

   908         /**

   909          * Produces a method handle for a reflected constructor.

   910          * The type of the method handle will be that of the constructor,

   911          * with the return type changed to the declaring class.

   912          * The method handle will perform a {@code newInstance} operation,

   913          * creating a new instance of the constructor's class on the

   914          * arguments passed to the method handle.

   915          * <p>

   916          * If the constructor's {@code accessible} flag is not set,

   917          * access checking is performed immediately on behalf of the lookup class.

   918          * <p>

   919          * The returned method handle will have

   920          * {@linkplain MethodHandle#asVarargsCollector variable arity} if and only if

   921          * the constructor's variable arity modifier bit ({@code 0x0080}) is set.

   922          * @param c the reflected constructor

   923          * @return a method handle which can invoke the reflected constructor

   924          * @throws IllegalAccessException if access checking fails

   925          * @throws NullPointerException if the argument is null

   926          */

   927         public MethodHandle unreflectConstructor(Constructor c) throws IllegalAccessException {

   928             MemberName ctor = new MemberName(c);

   929             assert(ctor.isConstructor());

   930             if (!c.isAccessible())  checkAccess(c.getDeclaringClass(), ctor);

   931             MethodHandle rawCtor = MethodHandleImpl.findMethod(IMPL_TOKEN, ctor, false, lookupClassOrNull());

   932             MethodHandle allocator = MethodHandleImpl.makeAllocator(IMPL_TOKEN, rawCtor);

   933             return fixVarargs(allocator, rawCtor);

   934         }

   935 

   936         /**

   937          * Produces a method handle giving read access to a reflected field.

   938          * The type of the method handle will have a return type of the field's

   939          * value type.

   940          * If the field is static, the method handle will take no arguments.

   941          * Otherwise, its single argument will be the instance containing

   942          * the field.

   943          * If the method's {@code accessible} flag is not set,

   944          * access checking is performed immediately on behalf of the lookup class.

   945          * @param f the reflected field

   946          * @return a method handle which can load values from the reflected field

   947          * @throws IllegalAccessException if access checking fails

   948          * @throws NullPointerException if the argument is null

   949          */

   950         public MethodHandle unreflectGetter(Field f) throws IllegalAccessException {

   951             return makeAccessor(f.getDeclaringClass(), new MemberName(f), f.isAccessible(), false);

   952         }

   953 

   954         /**

   955          * Produces a method handle giving write access to a reflected field.

   956          * The type of the method handle will have a void return type.

   957          * If the field is static, the method handle will take a single

   958          * argument, of the field's value type, the value to be stored.

   959          * Otherwise, the two arguments will be the instance containing

   960          * the field, and the value to be stored.

   961          * If the method's {@code accessible} flag is not set,

   962          * access checking is performed immediately on behalf of the lookup class.

   963          * @param f the reflected field

   964          * @return a method handle which can store values into the reflected field

   965          * @throws IllegalAccessException if access checking fails

   966          * @throws NullPointerException if the argument is null

   967          */

   968         public MethodHandle unreflectSetter(Field f) throws IllegalAccessException {

   969             return makeAccessor(f.getDeclaringClass(), new MemberName(f), f.isAccessible(), true);

   970         }

   971 

   972         /// Helper methods, all package-private.

   973 

   974         MemberName resolveOrFail(Class<?> refc, String name, Class<?> type, boolean isStatic) throws NoSuchFieldException, IllegalAccessException {

   975             checkSymbolicClass(refc);  // do this before attempting to resolve

   976             name.getClass(); type.getClass();  // NPE

   977             int mods = (isStatic ? Modifier.STATIC : 0);

   978             return IMPL_NAMES.resolveOrFail(new MemberName(refc, name, type, mods), true, lookupClassOrNull(),

   979                                             NoSuchFieldException.class);

   980         }

   981 

   982         MemberName resolveOrFail(Class<?> refc, String name, MethodType type, boolean isStatic) throws NoSuchMethodException, IllegalAccessException {

   983             checkSymbolicClass(refc);  // do this before attempting to resolve

   984             name.getClass(); type.getClass();  // NPE

   985             int mods = (isStatic ? Modifier.STATIC : 0);

   986             return IMPL_NAMES.resolveOrFail(new MemberName(refc, name, type, mods), true, lookupClassOrNull(),

   987                                             NoSuchMethodException.class);

   988         }

   989 

   990         MemberName resolveOrFail(Class<?> refc, String name, MethodType type, boolean isStatic,

   991                                  boolean searchSupers, Class<?> specialCaller) throws NoSuchMethodException, IllegalAccessException {

   992             checkSymbolicClass(refc);  // do this before attempting to resolve

   993             name.getClass(); type.getClass();  // NPE

   994             int mods = (isStatic ? Modifier.STATIC : 0);

   995             return IMPL_NAMES.resolveOrFail(new MemberName(refc, name, type, mods), searchSupers, specialCaller,

   996                                             NoSuchMethodException.class);

   997         }

   998 

   999         void checkSymbolicClass(Class<?> refc) throws IllegalAccessException {

  1000             Class<?> caller = lookupClassOrNull();

  1001             if (caller != null && !VerifyAccess.isClassAccessible(refc, caller))

  1002                 throw newNoAccessException("symbolic reference class is not public", new MemberName(refc), this);

  1003         }

  1004 

  1005         void checkMethod(Class<?> refc, MemberName m, boolean wantStatic) throws IllegalAccessException {

  1006             String message;

  1007             if (m.isConstructor())

  1008                 message = "expected a method, not a constructor";

  1009             else if (!m.isMethod())

  1010                 message = "expected a method";

  1011             else if (wantStatic != m.isStatic())

  1012                 message = wantStatic ? "expected a static method" : "expected a non-static method";

  1013             else

  1014                 { checkAccess(refc, m); return; }

  1015             throw newNoAccessException(message, m, this);

  1016         }

  1017 

  1018         void checkAccess(Class<?> refc, MemberName m) throws IllegalAccessException {

  1019             int allowedModes = this.allowedModes;

  1020             if (allowedModes == TRUSTED)  return;

  1021             int mods = m.getModifiers();

  1022             if (Modifier.isPublic(mods) && Modifier.isPublic(refc.getModifiers()) && allowedModes != 0)

  1023                 return;  // common case

  1024             int requestedModes = fixmods(mods);  // adjust 0 => PACKAGE

  1025             if ((requestedModes & allowedModes) != 0

  1026                 && VerifyAccess.isMemberAccessible(refc, m.getDeclaringClass(),

  1027                                                    mods, lookupClass()))

  1028                 return;

  1029             if (((requestedModes & ~allowedModes) & PROTECTED) != 0

  1030                 && VerifyAccess.isSamePackage(m.getDeclaringClass(), lookupClass()))

  1031                 // Protected members can also be checked as if they were package-private.

  1032                 return;

  1033             throw newNoAccessException(accessFailedMessage(refc, m), m, this);

  1034         }

  1035 

  1036         String accessFailedMessage(Class<?> refc, MemberName m) {

  1037             Class<?> defc = m.getDeclaringClass();

  1038             int mods = m.getModifiers();

  1039             // check the class first:

  1040             boolean classOK = (Modifier.isPublic(defc.getModifiers()) &&

  1041                                (defc == refc ||

  1042                                 Modifier.isPublic(refc.getModifiers())));

  1043             if (!classOK && (allowedModes & PACKAGE) != 0) {

  1044                 classOK = (VerifyAccess.isClassAccessible(defc, lookupClass()) &&

  1045                            (defc == refc ||

  1046                             VerifyAccess.isClassAccessible(refc, lookupClass())));

  1047             }

  1048             if (!classOK)

  1049                 return "class is not public";

  1050             if (Modifier.isPublic(mods))

  1051                 return "access to public member failed";  // (how?)

  1052             if (Modifier.isPrivate(mods))

  1053                 return "member is private";

  1054             if (Modifier.isProtected(mods))

  1055                 return "member is protected";

  1056             return "member is private to package";

  1057         }

  1058 

  1059         private static final boolean ALLOW_NESTMATE_ACCESS = false;

  1060 

  1061         void checkSpecialCaller(Class<?> specialCaller) throws IllegalAccessException {

  1062             if (allowedModes == TRUSTED)  return;

  1063             if ((allowedModes & PRIVATE) == 0

  1064                 || (specialCaller != lookupClass()

  1065                     && !(ALLOW_NESTMATE_ACCESS &&

  1066                          VerifyAccess.isSamePackageMember(specialCaller, lookupClass()))))

  1067                 throw newNoAccessException("no private access for invokespecial",

  1068                                            new MemberName(specialCaller), this);

  1069         }

  1070 

  1071         MethodHandle restrictProtectedReceiver(MemberName method, MethodHandle mh) throws IllegalAccessException {

  1072             // The accessing class only has the right to use a protected member

  1073             // on itself or a subclass.  Enforce that restriction, from JVMS 5.4.4, etc.

  1074             if (!method.isProtected() || method.isStatic()

  1075                 || allowedModes == TRUSTED

  1076                 || method.getDeclaringClass() == lookupClass()

  1077                 || (ALLOW_NESTMATE_ACCESS &&

  1078                     VerifyAccess.isSamePackageMember(method.getDeclaringClass(), lookupClass())))

  1079                 return mh;

  1080             else

  1081                 return restrictReceiver(method, mh, lookupClass());

  1082         }

  1083         MethodHandle restrictReceiver(MemberName method, MethodHandle mh, Class<?> caller) throws IllegalAccessException {

  1084             assert(!method.isStatic());

  1085             Class<?> defc = method.getDeclaringClass();  // receiver type of mh is too wide

  1086             if (defc.isInterface() || !defc.isAssignableFrom(caller)) {

  1087                 throw newNoAccessException("caller class must be a subclass below the method", method, caller);

  1088             }

  1089             MethodType rawType = mh.type();

  1090             if (rawType.parameterType(0) == caller)  return mh;

  1091             MethodType narrowType = rawType.changeParameterType(0, caller);

  1092             MethodHandle narrowMH = MethodHandleImpl.convertArguments(IMPL_TOKEN, mh, narrowType, rawType, null);

  1093             return fixVarargs(narrowMH, mh);

  1094         }

  1095 

  1096         MethodHandle makeAccessor(Class<?> refc, String name, Class<?> type,

  1097                                   boolean isStatic, boolean isSetter) throws NoSuchFieldException, IllegalAccessException {

  1098             MemberName field = resolveOrFail(refc, name, type, isStatic);

  1099             if (isStatic != field.isStatic())

  1100                 throw newNoAccessException(isStatic

  1101                                            ? "expected a static field"

  1102                                            : "expected a non-static field",

  1103                                            field, this);

  1104             return makeAccessor(refc, field, false, isSetter);

  1105         }

  1106 

  1107         MethodHandle makeAccessor(Class<?> refc, MemberName field,

  1108                                   boolean trusted, boolean isSetter) throws IllegalAccessException {

  1109             assert(field.isField());

  1110             if (trusted)

  1111                 return MethodHandleImpl.accessField(IMPL_TOKEN, field, isSetter, lookupClassOrNull());

  1112             checkAccess(refc, field);

  1113             MethodHandle mh = MethodHandleImpl.accessField(IMPL_TOKEN, field, isSetter, lookupClassOrNull());

  1114             return restrictProtectedReceiver(field, mh);

  1115         }

  1116     }

  1117 

  1118     /**

  1119      * Produces a method handle giving read access to elements of an array.

  1120      * The type of the method handle will have a return type of the array's

  1121      * element type.  Its first argument will be the array type,

  1122      * and the second will be {@code int}.

  1123      * @param arrayClass an array type

  1124      * @return a method handle which can load values from the given array type

  1125      * @throws NullPointerException if the argument is null

  1126      * @throws  IllegalArgumentException if arrayClass is not an array type

  1127      */

  1128     public static

  1129     MethodHandle arrayElementGetter(Class<?> arrayClass) throws IllegalArgumentException {

  1130         return MethodHandleImpl.accessArrayElement(IMPL_TOKEN, arrayClass, false);

  1131     }

  1132 

  1133     /**

  1134      * Produces a method handle giving write access to elements of an array.