lang/invoke/MethodHandles.java

123             throw newIllegalArgumentException("illegal lookupClass: "+caller);
134      * As a matter of pure convention, the {@linkplain Lookup#lookupClass() lookup class}
166      * the {@link Lookup#lookupClass() lookup class}, and {@code m2} is the module containing
201         Module callerModule = lookup.lookupClass().getModule();
262      * is known as the {@linkplain #lookupClass() lookup class}.
637         private final Class<?> lookupClass;
717         public Class<?> lookupClass() {
718             return lookupClass;
723             return (allowedModes == TRUSTED) ? null : lookupClass;
760         /** Embody the current class (the lookupClass) as a lookup class
765         Lookup(Class<?> lookupClass) {
766             this(lookupClass, FULL_POWER_MODES);
768             checkUnprivilegedlookupClass(lookupClass);
771         private Lookup(Class<?> lookupClass, int allowedModes) {
772             this.lookupClass = lookupClass;
779          * class as its own {@link #lookupClass() lookupClass}.
820             if (requestedLookupClass == this.lookupClass)
823             if (!VerifyAccess.isSameModule(this.lookupClass, requestedLookupClass)) {
826                 if (this.lookupClass.getModule().isNamed()
833                 && !VerifyAccess.isSamePackage(this.lookupClass, requestedLookupClass)) {
838                 && !VerifyAccess.isSamePackageMember(this.lookupClass, requestedLookupClass)) {
842                 && !VerifyAccess.isClassAccessible(requestedLookupClass, this.lookupClass, allowedModes)) {
884             return new Lookup(lookupClass(), newModes);
890          * {@linkplain #lookupClass() lookup class}.
956             if (!pn.equals(lookupClass.getPackageName())) {
961             ClassLoader loader = lookupClass.getClassLoader();
965             assert clazz.getClassLoader() == lookupClass.getClassLoader()
966                     && clazz.getPackageName().equals(lookupClass.getPackageName())
974                 cachedProtectionDomain = pd = protectionDomain(lookupClass);
1000         private static void checkUnprivilegedlookupClass(Class<?> lookupClass) {
1001             String name = lookupClass.getName();
1003                 throw newIllegalArgumentException("illegal lookupClass: "+lookupClass);
1041             String cname = lookupClass.getName();
1274          * The lookup context here is determined by the {@linkplain #lookupClass() lookup class}, its class
1291             Class<?> targetClass = Class.forName(targetName, false, lookupClass.getClassLoader());
1299          * The lookup context here is determined by the {@linkplain #lookupClass() lookup class} and the
1313             if (!VerifyAccess.isClassAccessible(targetClass, lookupClass, allowedModes)) {
2010                 if (!hasPrivateAccess() || callerClass != lookupClass())
2060          * If this lookup object has private access, then the caller class is the lookupClass.
2068                     callerClass = lookupClass;
2088          * If this lookup object has private access, then the caller class is the lookupClass.
2098                 !VerifyAccess.classLoaderIsAncestor(lookupClass, refc)) {
2185                                                     mods, lookupClass(), allowedModes))
2190                         && VerifyAccess.isSamePackage(m.getDeclaringClass(), lookupClass()))
2204                 classOK = (VerifyAccess.isClassAccessible(defc, lookupClass(), FULL_POWER_MODES) &&
2206                             VerifyAccess.isClassAccessible(refc, lookupClass(), FULL_POWER_MODES)));
2225                 || (specialCaller != lookupClass()
2229                          VerifyAccess.isSamePackageMember(specialCaller, lookupClass()))))
2239                 || method.getDeclaringClass() == lookupClass()
2240                 || VerifyAccess.isSamePackage(method.getDeclaringClass(), lookupClass())
2242                     VerifyAccess.isSamePackageMember(method.getDeclaringClass(), lookupClass())))
2289                 refc != lookupClass() &&
2291                 refc != lookupClass().getSuperclass() &&
2292                 refc.isAssignableFrom(lookupClass())) {
2301                 Class<?> refcAsSuper = lookupClass();
2324                 mh = restrictReceiver(method, dmh, lookupClass());
2335             Class<?> hostClass = lookupClass;
2363                 return restrictReceiver(field, dmh, lookupClass());
2405                 if (!getField.getDeclaringClass().isAssignableFrom(lookupClass())) {
2406                     throw getField.makeAccessException("caller class must be a subclass below the method", lookupClass());
2408                 refc = lookupClass();
2505                 return getDirectMethodNoSecurityManager(refKind, defc, member, lookupClass);