1 /*
  2  * Copyright (c) 2008, 2024, 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.lang.invoke;
 27 
 28 import java.lang.constant.ClassDesc;
 29 import java.lang.constant.MethodTypeDesc;
 30 import java.lang.invoke.MethodHandles.Lookup;
 31 import java.lang.module.ModuleDescriptor;
 32 import java.lang.ref.WeakReference;
 33 import java.lang.reflect.Method;
 34 import java.lang.reflect.Modifier;
 35 import java.lang.reflect.UndeclaredThrowableException;
 36 import java.security.AccessController;
 37 import java.security.PrivilegedAction;
 38 import java.util.ArrayList;
 39 import java.util.Arrays;
 40 import java.util.Collections;
 41 import java.util.HashSet;
 42 import java.util.List;
 43 import java.util.Objects;
 44 import java.util.Set;
 45 import java.util.WeakHashMap;
 46 import java.util.concurrent.atomic.AtomicInteger;
 47 import java.util.stream.Stream;
 48 
 49 import jdk.internal.access.JavaLangReflectAccess;
 50 import jdk.internal.access.SharedSecrets;
 51 import jdk.internal.classfile.ClassHierarchyResolver;
 52 import jdk.internal.classfile.Classfile;
 53 import jdk.internal.classfile.CodeBuilder;
 54 import jdk.internal.classfile.TypeKind;
 55 import jdk.internal.misc.PreviewFeatures;
 56 import jdk.internal.module.Modules;
 57 import jdk.internal.reflect.CallerSensitive;
 58 import jdk.internal.reflect.Reflection;
 59 import jdk.internal.util.ClassFileDumper;
 60 import sun.reflect.misc.ReflectUtil;
 61 
 62 import static java.lang.constant.ConstantDescs.*;
 63 import static java.lang.invoke.MethodHandleStatics.*;
 64 import static java.lang.invoke.MethodType.methodType;
 65 import static java.lang.module.ModuleDescriptor.Modifier.SYNTHETIC;
 66 import static jdk.internal.classfile.Classfile.*;
 67 
 68 /**
 69  * This class consists exclusively of static methods that help adapt
 70  * method handles to other JVM types, such as interfaces.
 71  *
 72  * @since 1.7
 73  */
 74 public class MethodHandleProxies {
 75 
 76     private MethodHandleProxies() { }  // do not instantiate
 77 
 78     /**
 79      * Produces an instance of the given single-method interface which redirects
 80      * its calls to the given method handle.
 81      * <p>
 82      * A single-method interface is an interface which declares a uniquely named method.
 83      * When determining the uniquely named method of a single-method interface,
 84      * the public {@code Object} methods ({@code toString}, {@code equals}, {@code hashCode})
 85      * are disregarded as are any default (non-abstract) methods.
 86      * For example, {@link java.util.Comparator} is a single-method interface,
 87      * even though it re-declares the {@code Object.equals} method and also
 88      * declares default methods, such as {@code Comparator.reverse}.
 89      * <p>
 90      * The interface must be public, not {@linkplain Class#isHidden() hidden},
 91      * and not {@linkplain Class#isSealed() sealed}.
 92      * No additional access checks are performed.
 93      * <p>
 94      * The resulting instance of the required type will respond to
 95      * invocation of the type's uniquely named method by calling
 96      * the given target on the incoming arguments,
 97      * and returning or throwing whatever the target
 98      * returns or throws.  The invocation will be as if by
 99      * {@code target.invoke}.
100      * The target's type will be checked before the
101      * instance is created, as if by a call to {@code asType},
102      * which may result in a {@code WrongMethodTypeException}.
103      * <p>
104      * The uniquely named method is allowed to be multiply declared,
105      * with distinct type descriptors.  (E.g., it can be overloaded,
106      * or can possess bridge methods.)  All such declarations are
107      * connected directly to the target method handle.
108      * Argument and return types are adjusted by {@code asType}
109      * for each individual declaration.
110      * <p>
111      * The wrapper instance will implement the requested interface
112      * and its super-types, but no other single-method interfaces.
113      * This means that the instance will not unexpectedly
114      * pass an {@code instanceof} test for any unrequested type.
115      * <p style="font-size:smaller;">
116      * <em>Implementation Note:</em>
117      * Therefore, each instance must implement a unique single-method interface.
118      * Implementations may not bundle together
119      * multiple single-method interfaces onto single implementation classes
120      * in the style of {@link java.desktop/java.awt.AWTEventMulticaster}.
121      * <p>
122      * The method handle may throw an <em>undeclared exception</em>,
123      * which means any checked exception (or other checked throwable)
124      * not declared by the requested type's single abstract method.
125      * If this happens, the throwable will be wrapped in an instance of
126      * {@link java.lang.reflect.UndeclaredThrowableException UndeclaredThrowableException}
127      * and thrown in that wrapped form.
128      * <p>
129      * Like {@link java.lang.Integer#valueOf Integer.valueOf},
130      * {@code asInterfaceInstance} is a factory method whose results are defined
131      * by their behavior.
132      * It is not guaranteed to return a new instance for every call.
133      * <p>
134      * Because of the possibility of {@linkplain java.lang.reflect.Method#isBridge bridge methods}
135      * and other corner cases, the interface may also have several abstract methods
136      * with the same name but having distinct descriptors (types of returns and parameters).
137      * In this case, all the methods are bound in common to the one given target.
138      * The type check and effective {@code asType} conversion is applied to each
139      * method type descriptor, and all abstract methods are bound to the target in common.
140      * Beyond this type check, no further checks are made to determine that the
141      * abstract methods are related in any way.
142      * <p>
143      * Future versions of this API may accept additional types,
144      * such as abstract classes with single abstract methods.
145      * Future versions of this API may also equip wrapper instances
146      * with one or more additional public "marker" interfaces.
147      * <p>
148      * If a security manager is installed, this method is caller sensitive.
149      * During any invocation of the target method handle via the returned wrapper,
150      * the original creator of the wrapper (the caller) will be visible
151      * to context checks requested by the security manager.
152      *
153      * @param <T> the desired type of the wrapper, a single-method interface
154      * @param intfc a class object representing {@code T}
155      * @param target the method handle to invoke from the wrapper
156      * @return a correctly-typed wrapper for the given target
157      * @throws NullPointerException if either argument is null
158      * @throws IllegalArgumentException if the {@code intfc} is not a
159      *         valid argument to this method
160      * @throws WrongMethodTypeException if the target cannot
161      *         be converted to the type required by the requested interface
162      */
163     @SuppressWarnings("doclint:reference") // cross-module links
164     @CallerSensitive
165     public static <T> T asInterfaceInstance(final Class<T> intfc, final MethodHandle target) {
166         if (!intfc.isInterface() || !Modifier.isPublic(intfc.getModifiers()))
167             throw newIllegalArgumentException("not a public interface", intfc.getName());
168         if (intfc.isSealed())
169             throw newIllegalArgumentException("a sealed interface", intfc.getName());
170         if (intfc.isHidden())
171             throw newIllegalArgumentException("a hidden interface", intfc.getName());
172         Objects.requireNonNull(target);
173         final MethodHandle mh;
174         @SuppressWarnings("removal")
175         var sm = System.getSecurityManager();
176         if (sm != null) {
177             final Class<?> caller = Reflection.getCallerClass();
178             final ClassLoader ccl = caller != null ? caller.getClassLoader() : null;
179             ReflectUtil.checkProxyPackageAccess(ccl, intfc);
180             mh = ccl != null ? bindCaller(target, caller) : target;
181         } else {
182             mh = target;
183         }
184 
185         // Define one hidden class for each interface.  Create an instance of
186         // the hidden class for a given target method handle which will be
187         // accessed via getfield.  Multiple instances may be created for a
188         // hidden class.  This approach allows the generated hidden classes
189         // more shareable.
190         //
191         // The implementation class is weakly referenced; a new class is
192         // defined if the last one has been garbage collected.
193         //
194         // An alternative approach is to define one hidden class with the
195         // target method handle as class data and the target method handle
196         // is loaded via ldc/condy.  If more than one target method handles
197         // are used, the extra classes will pollute the same type profiles.
198         // In addition, hidden classes without class data is more friendly
199         // for pre-generation (shifting the dynamic class generation from
200         // runtime to an earlier phrase).
201         Class<?> proxyClass = getProxyClass(intfc);  // throws IllegalArgumentException
202         Lookup lookup = new Lookup(proxyClass);
203         Object proxy;
204         try {
205             MethodHandle constructor = lookup.findConstructor(proxyClass,
206                                                               MT_void_Lookup_MethodHandle_MethodHandle)
207                                              .asType(MT_Object_Lookup_MethodHandle_MethodHandle);
208             proxy = constructor.invokeExact(lookup, target, mh);
209         } catch (Throwable ex) {
210             throw uncaughtException(ex);
211         }
212         assert proxy.getClass().getModule().isNamed() : proxy.getClass() + " " + proxy.getClass().getModule();
213         return intfc.cast(proxy);
214     }
215 
216     private record MethodInfo(MethodTypeDesc desc, List<ClassDesc> thrown, String fieldName) {}
217 
218     private static final ClassFileDumper DUMPER = ClassFileDumper.getInstance(
219             "jdk.invoke.MethodHandleProxies.dumpClassFiles", "DUMP_MH_PROXY_CLASSFILES");
220 
221     private static final Set<Class<?>> WRAPPER_TYPES = Collections.newSetFromMap(new WeakHashMap<>());
222     private static final ClassValue<WeakReferenceHolder<Class<?>>> PROXIES = new ClassValue<>() {
223         @Override
224         protected WeakReferenceHolder<Class<?>> computeValue(Class<?> intfc) {
225             return new WeakReferenceHolder<>(newProxyClass(intfc));
226         }
227     };
228 
229     private static Class<?> newProxyClass(Class<?> intfc) {
230         List<MethodInfo> methods = new ArrayList<>();
231         Set<Class<?>> referencedTypes = new HashSet<>();
232         referencedTypes.add(intfc);
233         String uniqueName = null;
234         int count = 0;
235         for (Method m : intfc.getMethods()) {
236             if (!Modifier.isAbstract(m.getModifiers()))
237                 continue;
238 
239             if (isObjectMethod(m))
240                 continue;
241 
242             // ensure it's SAM interface
243             String methodName = m.getName();
244             if (uniqueName == null) {
245                 uniqueName = methodName;
246             } else if (!uniqueName.equals(methodName)) {
247                 // too many abstract methods
248                 throw newIllegalArgumentException("not a single-method interface", intfc.getName());
249             }
250 
251             // the field name holding the method handle for this method
252             String fieldName = "m" + count++;
253             var mt = methodType(m.getReturnType(), JLRA.getExecutableSharedParameterTypes(m), true);
254             var thrown = JLRA.getExecutableSharedExceptionTypes(m);
255             var exceptionTypeDescs =
256                     thrown.length == 0 ? DEFAULT_RETHROWS
257                                        : Stream.concat(DEFAULT_RETHROWS.stream(),
258                                                        Arrays.stream(thrown).map(MethodHandleProxies::desc))
259                                                .distinct().toList();
260             methods.add(new MethodInfo(desc(mt), exceptionTypeDescs, fieldName));
261 
262             // find the types referenced by this method
263             addElementType(referencedTypes, m.getReturnType());
264             addElementTypes(referencedTypes, JLRA.getExecutableSharedParameterTypes(m));
265             addElementTypes(referencedTypes, JLRA.getExecutableSharedExceptionTypes(m));
266         }
267 
268         if (uniqueName == null)
269             throw newIllegalArgumentException("no method in ", intfc.getName());
270 
271         // create a dynamic module for each proxy class, which needs access
272         // to the types referenced by the members of the interface including
273         // the parameter types, return type and exception types
274         var loader = intfc.getClassLoader();
275         Module targetModule = newDynamicModule(loader, referencedTypes);
276 
277         // generate a class file in the package of the dynamic module
278         String packageName = targetModule.getName();
279         String intfcName = intfc.getName();
280         int i = intfcName.lastIndexOf('.');
281         // jdk.MHProxy#.Interface
282         String className = packageName + "." + (i > 0 ? intfcName.substring(i + 1) : intfcName);
283         byte[] template = createTemplate(loader, ClassDesc.of(className), desc(intfc), uniqueName, methods);
284         // define the dynamic module to the class loader of the interface
285         var definer = new Lookup(intfc).makeHiddenClassDefiner(className, template, Set.of(), DUMPER);
286 
287         @SuppressWarnings("removal")
288         var sm = System.getSecurityManager();
289         Lookup lookup;
290         if (sm != null) {
291             @SuppressWarnings("removal")
292             var l = AccessController.doPrivileged((PrivilegedAction<Lookup>) () ->
293                     definer.defineClassAsLookup(true));
294             lookup = l;
295         } else {
296             lookup = definer.defineClassAsLookup(true);
297         }
298         // cache the wrapper type
299         var ret = lookup.lookupClass();
300         WRAPPER_TYPES.add(ret);
301         return ret;
302     }
303 
304     private static final class WeakReferenceHolder<T> {
305         private volatile WeakReference<T> ref;
306 
307         WeakReferenceHolder(T value) {
308             set(value);
309         }
310 
311         void set(T value) {
312             ref = new WeakReference<>(value);
313         }
314 
315         T get() {
316             return ref.get();
317         }
318     }
319 
320     private static Class<?> getProxyClass(Class<?> intfc) {
321         WeakReferenceHolder<Class<?>> r = PROXIES.get(intfc);
322         Class<?> cl = r.get();
323         if (cl != null)
324             return cl;
325 
326         // avoid spinning multiple classes in a race
327         synchronized (r) {
328             cl = r.get();
329             if (cl != null)
330                 return cl;
331 
332             // If the referent is cleared, create a new value and update cached weak reference.
333             cl = newProxyClass(intfc);
334             r.set(cl);
335             return cl;
336         }
337     }
338 
339     private static final List<ClassDesc> DEFAULT_RETHROWS = List.of(desc(RuntimeException.class), desc(Error.class));
340     private static final ClassDesc CD_UndeclaredThrowableException = desc(UndeclaredThrowableException.class);
341     private static final ClassDesc CD_IllegalAccessException = desc(IllegalAccessException.class);
342     private static final MethodTypeDesc MTD_void_Throwable = MethodTypeDesc.of(CD_void, CD_Throwable);
343     private static final MethodType MT_void_Lookup_MethodHandle_MethodHandle =
344             methodType(void.class, Lookup.class, MethodHandle.class, MethodHandle.class);
345     private static final MethodType MT_Object_Lookup_MethodHandle_MethodHandle =
346             MT_void_Lookup_MethodHandle_MethodHandle.changeReturnType(Object.class);
347     private static final MethodType MT_MethodHandle_Object = methodType(MethodHandle.class, Object.class);
348     private static final MethodTypeDesc MTD_void_Lookup_MethodHandle_MethodHandle =
349             desc(MT_void_Lookup_MethodHandle_MethodHandle);
350     private static final MethodTypeDesc MTD_void_Lookup = MethodTypeDesc.of(CD_void, CD_MethodHandles_Lookup);
351     private static final MethodTypeDesc MTD_MethodHandle_MethodType = MethodTypeDesc.of(CD_MethodHandle, CD_MethodType);
352     private static final MethodTypeDesc MTD_Class = MethodTypeDesc.of(CD_Class);
353     private static final MethodTypeDesc MTD_int = MethodTypeDesc.of(CD_int);
354     private static final MethodTypeDesc MTD_String = MethodTypeDesc.of(CD_String);
355     private static final MethodTypeDesc MTD_void_String = MethodTypeDesc.of(CD_void, CD_String);
356     private static final String TARGET_NAME = "target";
357     private static final String TYPE_NAME = "interfaceType";
358     private static final String ENSURE_ORIGINAL_LOOKUP = "ensureOriginalLookup";
359 
360     /**
361      * Creates an implementation class file for a given interface. One implementation class is
362      * defined for each interface.
363      *
364      * @param ifaceDesc the given interface
365      * @param methodName the name of the single abstract method
366      * @param methods the information for implementation methods
367      * @return the bytes of the implementation classes
368      */
369     private static byte[] createTemplate(ClassLoader loader, ClassDesc proxyDesc, ClassDesc ifaceDesc,
370                                          String methodName, List<MethodInfo> methods) {
371         return Classfile.of(ClassHierarchyResolverOption.of(ClassHierarchyResolver.ofClassLoading(loader)))
372                         .build(proxyDesc, clb -> {
373             clb.withSuperclass(CD_Object);
374             clb.withFlags((PreviewFeatures.isEnabled() ? ACC_IDENTITY  : 0) | ACC_FINAL | ACC_SYNTHETIC);
375             clb.withInterfaceSymbols(ifaceDesc);
376 
377             // static and instance fields
378             clb.withField(TYPE_NAME, CD_Class, ACC_PRIVATE | ACC_STATIC | ACC_FINAL);
379             clb.withField(TARGET_NAME, CD_MethodHandle, ACC_PRIVATE | ACC_FINAL);
380             for (var mi : methods) {
381                 clb.withField(mi.fieldName, CD_MethodHandle, ACC_PRIVATE | ACC_FINAL);
382             }
383 
384             // <clinit>
385             clb.withMethodBody(CLASS_INIT_NAME, MTD_void, ACC_STATIC, cob -> {
386                 cob.constantInstruction(ifaceDesc);
387                 cob.putstatic(proxyDesc, TYPE_NAME, CD_Class);
388                 cob.return_();
389             });
390 
391             // <init>(Lookup, MethodHandle target, MethodHandle callerBoundTarget)
392             clb.withMethodBody(INIT_NAME, MTD_void_Lookup_MethodHandle_MethodHandle, 0, cob -> {
393                 cob.aload(0);
394                 cob.invokespecial(CD_Object, INIT_NAME, MTD_void);
395 
396                 // call ensureOriginalLookup to verify the given Lookup has access
397                 cob.aload(1);
398                 cob.invokestatic(proxyDesc, "ensureOriginalLookup", MTD_void_Lookup);
399 
400                 // this.target = target;
401                 cob.aload(0);
402                 cob.aload(2);
403                 cob.putfield(proxyDesc, TARGET_NAME, CD_MethodHandle);
404 
405                 // method handles adjusted to the method type of each method
406                 for (var mi : methods) {
407                     // this.m<i> = callerBoundTarget.asType(xxType);
408                     cob.aload(0);
409                     cob.aload(3);
410                     cob.constantInstruction(mi.desc);
411                     cob.invokevirtual(CD_MethodHandle, "asType", MTD_MethodHandle_MethodType);
412                     cob.putfield(proxyDesc, mi.fieldName, CD_MethodHandle);
413                 }
414 
415                 // complete
416                 cob.return_();
417             });
418 
419             // private static void ensureOriginalLookup(Lookup) checks if the given Lookup
420             // has ORIGINAL access to this class, i.e. the lookup class is this class;
421             // otherwise, IllegalAccessException is thrown
422             clb.withMethodBody(ENSURE_ORIGINAL_LOOKUP, MTD_void_Lookup, ACC_PRIVATE | ACC_STATIC, cob -> {
423                 var failLabel = cob.newLabel();
424                 // check lookupClass
425                 cob.aload(0);
426                 cob.invokevirtual(CD_MethodHandles_Lookup, "lookupClass", MTD_Class);
427                 cob.constantInstruction(proxyDesc);
428                 cob.if_acmpne(failLabel);
429                 // check original access
430                 cob.aload(0);
431                 cob.invokevirtual(CD_MethodHandles_Lookup, "lookupModes", MTD_int);
432                 cob.constantInstruction(Lookup.ORIGINAL);
433                 cob.iand();
434                 cob.ifeq(failLabel);
435                 // success
436                 cob.return_();
437                 // throw exception
438                 cob.labelBinding(failLabel);
439                 cob.new_(CD_IllegalAccessException);
440                 cob.dup();
441                 cob.aload(0); // lookup
442                 cob.invokevirtual(CD_Object, "toString", MTD_String);
443                 cob.invokespecial(CD_IllegalAccessException, INIT_NAME, MTD_void_String);
444                 cob.athrow();
445             });
446 
447             // implementation methods
448             for (MethodInfo mi : methods) {
449                 // no need to generate thrown exception attribute
450                 clb.withMethodBody(methodName, mi.desc, ACC_PUBLIC, cob -> cob
451                         .trying(bcb -> {
452                                     // return this.handleField.invokeExact(arguments...);
453                                     bcb.aload(0);
454                                     bcb.getfield(proxyDesc, mi.fieldName, CD_MethodHandle);
455                                     for (int j = 0; j < mi.desc.parameterCount(); j++) {
456                                         bcb.loadInstruction(TypeKind.from(mi.desc.parameterType(j)),
457                                                 bcb.parameterSlot(j));
458                                     }
459                                     bcb.invokevirtual(CD_MethodHandle, "invokeExact", mi.desc);
460                                     bcb.returnInstruction(TypeKind.from(mi.desc.returnType()));
461                                 }, ctb -> ctb
462                                         // catch (Error | RuntimeException | Declared ex) { throw ex; }
463                                         .catchingMulti(mi.thrown, CodeBuilder::athrow)
464                                         // catch (Throwable ex) { throw new UndeclaredThrowableException(ex); }
465                                         .catchingAll(cb -> cb
466                                                 .new_(CD_UndeclaredThrowableException)
467                                                 .dup_x1()
468                                                 .swap()
469                                                 .invokespecial(CD_UndeclaredThrowableException,
470                                                         INIT_NAME, MTD_void_Throwable)
471                                                 .athrow()
472                                         )
473                         ));
474             }
475         });
476     }
477 
478     private static MethodHandle bindCaller(MethodHandle target, Class<?> hostClass) {
479         return MethodHandleImpl.bindCaller(target, hostClass).withVarargs(target.isVarargsCollector());
480     }
481 
482     /**
483      * Determines if the given object was produced by a call to {@link #asInterfaceInstance asInterfaceInstance}.
484      * @param x any reference
485      * @return true if the reference is not null and points to an object produced by {@code asInterfaceInstance}
486      */
487     public static boolean isWrapperInstance(Object x) {
488         return x != null && WRAPPER_TYPES.contains(x.getClass());
489     }
490 
491     /**
492      * Produces or recovers a target method handle which is behaviorally
493      * equivalent to the unique method of this wrapper instance.
494      * The object {@code x} must have been produced by a call to {@link #asInterfaceInstance asInterfaceInstance}.
495      * This requirement may be tested via {@link #isWrapperInstance isWrapperInstance}.
496      * @param x any reference
497      * @return a method handle implementing the unique method
498      * @throws IllegalArgumentException if the reference x is not to a wrapper instance
499      */
500     public static MethodHandle wrapperInstanceTarget(Object x) {
501         if (!isWrapperInstance(x))
502             throw new IllegalArgumentException("not a wrapper instance: " + x);
503 
504         try {
505             Class<?> type = x.getClass();
506             MethodHandle getter = new Lookup(type).findGetter(type, TARGET_NAME, MethodHandle.class)
507                                                   .asType(MT_MethodHandle_Object);
508             return (MethodHandle) getter.invokeExact(x);
509         } catch (Throwable ex) {
510             throw uncaughtException(ex);
511         }
512     }
513 
514     /**
515      * Recovers the unique single-method interface type for which this wrapper instance was created.
516      * The object {@code x} must have been produced by a call to {@link #asInterfaceInstance asInterfaceInstance}.
517      * This requirement may be tested via {@link #isWrapperInstance isWrapperInstance}.
518      * @param x any reference
519      * @return the single-method interface type for which the wrapper was created
520      * @throws IllegalArgumentException if the reference x is not to a wrapper instance
521      */
522     public static Class<?> wrapperInstanceType(Object x) {
523         if (!isWrapperInstance(x))
524             throw new IllegalArgumentException("not a wrapper instance: " + x);
525 
526         try {
527             Class<?> type = x.getClass();
528             MethodHandle originalTypeField = new Lookup(type).findStaticGetter(type, TYPE_NAME, Class.class);
529             return (Class<?>) originalTypeField.invokeExact();
530         } catch (Throwable e) {
531             throw uncaughtException(e);
532         }
533     }
534 
535     private static ClassDesc desc(Class<?> cl) {
536         return cl.describeConstable().orElseThrow(() -> newInternalError("Cannot convert class "
537                 + cl.getName() + " to a constant"));
538     }
539 
540     private static MethodTypeDesc desc(MethodType mt) {
541         return mt.describeConstable().orElseThrow(() -> newInternalError("Cannot convert method type "
542                 + mt + " to a constant"));
543     }
544 
545     private static final JavaLangReflectAccess JLRA = SharedSecrets.getJavaLangReflectAccess();
546     private static final AtomicInteger counter = new AtomicInteger();
547 
548     private static String nextModuleName() {
549         return "jdk.MHProxy" + counter.incrementAndGet();
550     }
551 
552     /**
553      * Create a dynamic module defined to the given class loader and has
554      * access to the given types.
555      * <p>
556      * The dynamic module contains only one single package named the same as
557      * the name of the dynamic module.  It's not exported or open.
558      */
559     private static Module newDynamicModule(ClassLoader ld, Set<Class<?>> types) {
560         Objects.requireNonNull(types);
561 
562         // create a dynamic module and setup module access
563         String mn = nextModuleName();
564         ModuleDescriptor descriptor = ModuleDescriptor.newModule(mn, Set.of(SYNTHETIC))
565                 .packages(Set.of(mn))
566                 .build();
567 
568         Module dynModule = Modules.defineModule(ld, descriptor, null);
569         Module javaBase = Object.class.getModule();
570 
571         Modules.addReads(dynModule, javaBase);
572         Modules.addOpens(dynModule, mn, javaBase);
573 
574         for (Class<?> c : types) {
575             ensureAccess(dynModule, c);
576         }
577         return dynModule;
578     }
579 
580     private static boolean isObjectMethod(Method m) {
581         return switch (m.getName()) {
582             case "toString" -> m.getReturnType() == String.class
583                     && m.getParameterCount() == 0;
584             case "hashCode" -> m.getReturnType() == int.class
585                     && m.getParameterCount() == 0;
586             case "equals"   -> m.getReturnType() == boolean.class
587                     && m.getParameterCount() == 1
588                     && JLRA.getExecutableSharedParameterTypes(m)[0] == Object.class;
589             default -> false;
590         };
591     }
592 
593     /*
594      * Ensure the given module can access the given class.
595      */
596     private static void ensureAccess(Module target, Class<?> c) {
597         Module m = c.getModule();
598         // add read edge and qualified export for the target module to access
599         if (!target.canRead(m)) {
600             Modules.addReads(target, m);
601         }
602         String pn = c.getPackageName();
603         if (!m.isExported(pn, target)) {
604             Modules.addExports(m, pn, target);
605         }
606     }
607 
608     private static void addElementTypes(Set<Class<?>> types, Class<?>... classes) {
609         for (var cls : classes) {
610             addElementType(types, cls);
611         }
612     }
613 
614     private static void addElementType(Set<Class<?>> types, Class<?> cls) {
615         Class<?> e = cls;
616         while (e.isArray()) {
617             e = e.getComponentType();
618         }
619 
620         if (!e.isPrimitive()) {
621             types.add(e);
622         }
623     }
624 }
--- EOF ---