MethodHandle Lookup facility

Question

As far as JavaDoc states `MethodHandles.lookup()` returns facility that have ability to access the same method/functions/constructor as the caller of this function. Specifically, if the caller can access some private data, so as this MethodHandles.Lookup facility. Code below demonstrates that this is false. Where I get it wrong? ``` public class MethodHandlerAccessTest { private static class NestedClass { private static void foo(){} } @Test public void testPrivateAccess() throws Throwable { NestedClass.foo(); //compiles and executes perfectly MethodType type = MethodType.methodType(void.class); MethodHandles.Lookup lookup = MethodHandles.lookup(); MethodHandle mh = lookup.findStatic(NestedClass.class, "foo", type); } } ``` Edit: This is what I get: java.lang.IllegalAccessException: member is private: MethodHandlerAccessTest$NestedClass.foo()void, from MethodHandlerAccessTest at java.lang.invoke.MemberName.makeAccessException(MemberName.java:507) at java.lang.invoke.MethodHandles$Looku…

Accepted Answer

The problem is that your test method doesn't really call `NestedClass.foo()`. This line:

```
NestedClass.foo();
```

... is actually transformed into a call to a synthetic method which is generated in `foo`, like this:

```
NestedClass.access$000();
```

Where `access$000` looks like this:

```
// Note package access
static void access$000() {
    foo();
}
```

You can validate this by using `javap -c` to look at the actual bytecode.

At the JVM level, your outer class doesn't have access to `foo()`. The Java compiler just synthesizes access to it by creating `access$000` and calling it from your outer class whenever the source code calls `foo()`.

At execution time, the reflection libraries don't do the same thing, hence your error.

MethodHandle Lookup facility

Solution

Problem