1 /*
   2  * Copyright (c) 2010, 2013, 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 jdk.nashorn.internal.runtime.linker;
  27 
  28 import static jdk.nashorn.internal.codegen.CompilerConstants.staticCallNoLookup;
  29 import static jdk.nashorn.internal.runtime.ECMAErrors.typeError;
  30 
  31 import java.lang.invoke.CallSite;
  32 import java.lang.invoke.ConstantCallSite;
  33 import java.lang.invoke.MethodHandle;
  34 import java.lang.invoke.MethodHandles;
  35 import java.lang.invoke.MethodHandles.Lookup;
  36 import java.lang.invoke.MethodType;
  37 import jdk.dynalink.CallSiteDescriptor;
  38 import jdk.dynalink.DynamicLinker;
  39 import jdk.dynalink.DynamicLinkerFactory;
  40 import jdk.dynalink.beans.BeansLinker;
  41 import jdk.dynalink.beans.StaticClass;
  42 import jdk.dynalink.linker.GuardedInvocation;
  43 import jdk.dynalink.linker.GuardedInvocationTransformer;
  44 import jdk.dynalink.linker.LinkRequest;
  45 import jdk.dynalink.linker.LinkerServices;
  46 import jdk.dynalink.linker.MethodTypeConversionStrategy;
  47 import jdk.dynalink.linker.support.TypeUtilities;
  48 import jdk.nashorn.api.scripting.JSObject;
  49 import jdk.nashorn.internal.codegen.CompilerConstants.Call;
  50 import jdk.nashorn.internal.lookup.MethodHandleFactory;
  51 import jdk.nashorn.internal.lookup.MethodHandleFunctionality;
  52 import jdk.nashorn.internal.runtime.Context;
  53 import jdk.nashorn.internal.runtime.ECMAException;
  54 import jdk.nashorn.internal.runtime.JSType;
  55 import jdk.nashorn.internal.runtime.OptimisticReturnFilters;
  56 import jdk.nashorn.internal.runtime.ScriptFunction;
  57 import jdk.nashorn.internal.runtime.ScriptRuntime;
  58 
  59 /**
  60  * This class houses bootstrap method for invokedynamic instructions generated by compiler.
  61  */
  62 public final class Bootstrap {
  63     /** Reference to the seed boostrap function */
  64     public static final Call BOOTSTRAP = staticCallNoLookup(Bootstrap.class, "bootstrap", CallSite.class, Lookup.class, String.class, MethodType.class, int.class);
  65 
  66     private static final MethodHandleFunctionality MH = MethodHandleFactory.getFunctionality();
  67 
  68     private static final MethodHandle VOID_TO_OBJECT = MH.constant(Object.class, ScriptRuntime.UNDEFINED);
  69 
  70     // do not create me!!
  71     private Bootstrap() {
  72     }
  73 
  74     /**
  75      * Creates a Nashorn dynamic linker with the given app class loader.
  76      * @param appLoader the app class loader. It will be used to discover
  77      * additional language runtime linkers (if any).
  78      * @param unstableRelinkThreshold the unstable relink threshold
  79      * @return a newly created dynamic linker.
  80      */
  81     public static DynamicLinker createDynamicLinker(final ClassLoader appLoader,
  82             final int unstableRelinkThreshold) {
  83         final DynamicLinkerFactory factory = new DynamicLinkerFactory();
  84         final NashornBeansLinker nashornBeansLinker = new NashornBeansLinker();
  85         factory.setPrioritizedLinkers(
  86             new NashornLinker(),
  87             new NashornPrimitiveLinker(),
  88             new NashornStaticClassLinker(),
  89             new BoundCallableLinker(),
  90             new JavaSuperAdapterLinker(),
  91             new JSObjectLinker(nashornBeansLinker),
  92             new BrowserJSObjectLinker(nashornBeansLinker),
  93             new ReflectionCheckLinker());
  94         factory.setFallbackLinkers(nashornBeansLinker, new NashornBottomLinker());
  95         factory.setSyncOnRelink(true);
  96         factory.setPrelinkTransformer(new GuardedInvocationTransformer() {
  97             @Override
  98             public GuardedInvocation filter(final GuardedInvocation inv, final LinkRequest request, final LinkerServices linkerServices) {
  99                 final CallSiteDescriptor desc = request.getCallSiteDescriptor();
 100                 return OptimisticReturnFilters.filterOptimisticReturnValue(inv, desc).asType(linkerServices, desc.getMethodType());
 101             }
 102         });
 103         factory.setAutoConversionStrategy(new MethodTypeConversionStrategy() {
 104             @Override
 105             public MethodHandle asType(final MethodHandle target, final MethodType newType) {
 106                 return unboxReturnType(target, newType);
 107             }
 108         });
 109         factory.setInternalObjectsFilter(NashornBeansLinker.createHiddenObjectFilter());
 110         factory.setUnstableRelinkThreshold(unstableRelinkThreshold);
 111 
 112         // Linkers for any additional language runtimes deployed alongside Nashorn will be picked up by the factory.
 113         factory.setClassLoader(appLoader);
 114         return factory.createLinker();
 115     }
 116 
 117     /**
 118      * Returns if the given object is a "callable"
 119      * @param obj object to be checked for callability
 120      * @return true if the obj is callable
 121      */
 122     public static boolean isCallable(final Object obj) {
 123         if (obj == ScriptRuntime.UNDEFINED || obj == null) {
 124             return false;
 125         }
 126 
 127         return obj instanceof ScriptFunction ||
 128             isJSObjectFunction(obj) ||
 129             BeansLinker.isDynamicMethod(obj) ||
 130             obj instanceof BoundCallable ||
 131             isFunctionalInterfaceObject(obj) ||
 132             obj instanceof StaticClass;
 133     }
 134 
 135     /**
 136      * Returns true if the given object is a strict callable
 137      * @param callable the callable object to be checked for strictness
 138      * @return true if the obj is a strict callable, false if it is a non-strict callable.
 139      * @throws ECMAException with {@code TypeError} if the object is not a callable.
 140      */
 141     public static boolean isStrictCallable(final Object callable) {
 142         if (callable instanceof ScriptFunction) {
 143             return ((ScriptFunction)callable).isStrict();
 144         } else if (isJSObjectFunction(callable)) {
 145             return ((JSObject)callable).isStrictFunction();
 146         } else if (callable instanceof BoundCallable) {
 147             return isStrictCallable(((BoundCallable)callable).getCallable());
 148         } else if (BeansLinker.isDynamicMethod(callable) || callable instanceof StaticClass) {
 149             return false;
 150         }
 151         throw notFunction(callable);
 152     }
 153 
 154     private static ECMAException notFunction(final Object obj) {
 155         return typeError("not.a.function", ScriptRuntime.safeToString(obj));
 156     }
 157 
 158     private static boolean isJSObjectFunction(final Object obj) {
 159         return obj instanceof JSObject && ((JSObject)obj).isFunction();
 160     }
 161 
 162     /**
 163      * Returns if the given object is a dynalink Dynamic method
 164      * @param obj object to be checked
 165      * @return true if the obj is a dynamic method
 166      */
 167     public static boolean isDynamicMethod(final Object obj) {
 168         return BeansLinker.isDynamicMethod(obj instanceof BoundCallable ? ((BoundCallable)obj).getCallable() : obj);
 169     }
 170 
 171     /**
 172      * Returns if the given object is an instance of an interface annotated with
 173      * java.lang.FunctionalInterface
 174      * @param obj object to be checked
 175      * @return true if the obj is an instance of @FunctionalInterface interface
 176      */
 177     public static boolean isFunctionalInterfaceObject(final Object obj) {
 178         return !JSType.isPrimitive(obj) && (NashornBeansLinker.getFunctionalInterfaceMethodName(obj.getClass()) != null);
 179     }
 180 
 181     /**
 182      * Create a call site and link it for Nashorn. This version of the method conforms to the invokedynamic bootstrap
 183      * method expected signature and is referenced from Nashorn generated bytecode as the bootstrap method for all
 184      * invokedynamic instructions.
 185      * @param lookup MethodHandle lookup. Ignored as Nashorn only uses public lookup.
 186      * @param opDesc Dynalink dynamic operation descriptor.
 187      * @param type   Method type.
 188      * @param flags  flags for call type, trace/profile etc.
 189      * @return CallSite with MethodHandle to appropriate method or null if not found.
 190      */
 191     public static CallSite bootstrap(final Lookup lookup, final String opDesc, final MethodType type, final int flags) {
 192         return Context.getDynamicLinker(lookup.lookupClass()).link(LinkerCallSite.newLinkerCallSite(lookup, opDesc, type, flags));
 193     }
 194 
 195     /**
 196      * Boostrapper for math calls that may overflow
 197      * @param lookup         lookup
 198      * @param name           name of operation
 199      * @param type           method type
 200      * @param programPoint   program point to bind to callsite
 201      *
 202      * @return callsite for a math intrinsic node
 203      */
 204     public static CallSite mathBootstrap(final MethodHandles.Lookup lookup, final String name, final MethodType type, final int programPoint) {
 205         final MethodHandle mh;
 206         switch (name) {
 207         case "iadd":
 208             mh = JSType.ADD_EXACT.methodHandle();
 209             break;
 210         case "isub":
 211             mh = JSType.SUB_EXACT.methodHandle();
 212             break;
 213         case "imul":
 214             mh = JSType.MUL_EXACT.methodHandle();
 215             break;
 216         case "idiv":
 217             mh = JSType.DIV_EXACT.methodHandle();
 218             break;
 219         case "irem":
 220             mh = JSType.REM_EXACT.methodHandle();
 221             break;
 222         case "ineg":
 223             mh = JSType.NEGATE_EXACT.methodHandle();
 224             break;
 225         case "ladd":
 226             mh = JSType.ADD_EXACT_LONG.methodHandle();
 227             break;
 228         case "lsub":
 229             mh = JSType.SUB_EXACT_LONG.methodHandle();
 230             break;
 231         case "lmul":
 232             mh = JSType.MUL_EXACT_LONG.methodHandle();
 233             break;
 234         case "ldiv":
 235             mh = JSType.DIV_EXACT_LONG.methodHandle();
 236             break;
 237         case "lrem":
 238             mh = JSType.REM_EXACT_LONG.methodHandle();
 239             break;
 240         case "lneg":
 241             mh = JSType.NEGATE_EXACT_LONG.methodHandle();
 242             break;
 243         default:
 244             throw new AssertionError("unsupported math intrinsic");
 245         }
 246         return new ConstantCallSite(MH.insertArguments(mh, mh.type().parameterCount() - 1, programPoint));
 247     }
 248 
 249     /**
 250      * Returns a dynamic invoker for a specified dynamic operation using the
 251      * public lookup. You can use this method to create a method handle that
 252      * when invoked acts completely as if it were a Nashorn-linked call site.
 253      * Note that the available operations are encoded in the flags, see
 254      * {@link NashornCallSiteDescriptor} operation constants. If the operation
 255      * takes a name, it should be set otherwise empty name (not null) should be
 256      * used. All names (including the empty one) should be encoded using
 257      * {@link NameCodec#encode(String)}. Few examples:
 258      * <ul>
 259      *   <li>Get a named property with fixed name:
 260      *     <pre>
 261      * MethodHandle getColor = Boostrap.createDynamicInvoker(
 262      *     "color",
 263      *     NashornCallSiteDescriptor.GET_PROPERTY,
 264      *     Object.class, Object.class);
 265      * Object obj = ...; // somehow obtain the object
 266      * Object color = getColor.invokeExact(obj);
 267      *     </pre>
 268      *   </li>
 269      *   <li>Get a named property with variable name:
 270      *     <pre>
 271      * MethodHandle getProperty = Boostrap.createDynamicInvoker(
 272      *     NameCodec.encode(""),
 273      *     NashornCallSiteDescriptor.GET_PROPERTY,
 274      *     Object.class, Object.class, String.class);
 275      * Object obj = ...; // somehow obtain the object
 276      * Object color = getProperty.invokeExact(obj, "color");
 277      * Object shape = getProperty.invokeExact(obj, "shape");
 278      *
 279      * MethodHandle getNumProperty = Boostrap.createDynamicInvoker(
 280      *     NameCodec.encode(""),
 281      *     NashornCallSiteDescriptor.GET_ELEMENT,
 282      *     Object.class, Object.class, int.class);
 283      * Object elem42 = getNumProperty.invokeExact(obj, 42);
 284      *     </pre>
 285      *   </li>
 286      *   <li>Set a named property with fixed name:
 287      *     <pre>
 288      * MethodHandle setColor = Boostrap.createDynamicInvoker(
 289      *     "color",
 290      *     NashornCallSiteDescriptor.SET_PROPERTY,
 291      *     void.class, Object.class, Object.class);
 292      * Object obj = ...; // somehow obtain the object
 293      * setColor.invokeExact(obj, Color.BLUE);
 294      *     </pre>
 295      *   </li>
 296      *   <li>Set a property with variable name:
 297      *     <pre>
 298      * MethodHandle setProperty = Boostrap.createDynamicInvoker(
 299      *     NameCodec.encode(""),
 300      *     NashornCallSiteDescriptor.SET_PROPERTY,
 301      *     void.class, Object.class, String.class, Object.class);
 302      * Object obj = ...; // somehow obtain the object
 303      * setProperty.invokeExact(obj, "color", Color.BLUE);
 304      * setProperty.invokeExact(obj, "shape", Shape.CIRCLE);
 305      *     </pre>
 306      *   </li>
 307      *   <li>Call a function on an object; note it's a two-step process: get the
 308      *   method, then invoke the method. This is the actual:
 309      *     <pre>
 310      * MethodHandle findFooFunction = Boostrap.createDynamicInvoker(
 311      *     "foo",
 312      *     NashornCallSiteDescriptor.GET_METHOD,
 313      *     Object.class, Object.class);
 314      * Object obj = ...; // somehow obtain the object
 315      * Object foo_fn = findFooFunction.invokeExact(obj);
 316      * MethodHandle callFunctionWithTwoArgs = Boostrap.createDynamicCallInvoker(
 317      *     Object.class, Object.class, Object.class, Object.class, Object.class);
 318      * // Note: "call" operation takes a function, then a "this" value, then the arguments:
 319      * Object foo_retval = callFunctionWithTwoArgs.invokeExact(foo_fn, obj, arg1, arg2);
 320      *     </pre>
 321      *   </li>
 322      * </ul>
 323      * Few additional remarks:
 324      * <ul>
 325      * <li>Just as Nashorn works with any Java object, the invokers returned
 326      * from this method can also be applied to arbitrary Java objects in
 327      * addition to Nashorn JavaScript objects.</li>
 328      * <li>For invoking a named function on an object, you can also use the
 329      * {@link InvokeByName} convenience class.</li>
 330      * <li>There's no rule that the variable property identifier has to be a
 331      * {@code String} for {@code GET_PROPERTY/SET_PROPERTY} and {@code int} for
 332      * {@code GET_ELEMENT/SET_ELEMENT}. You can declare their type to be
 333      * {@code int}, {@code double}, {@code Object}, and so on regardless of the
 334      * kind of the operation.</li>
 335      * <li>You can be as specific in parameter types as you want. E.g. if you
 336      * know that the receiver of the operation will always be
 337      * {@code ScriptObject}, you can pass {@code ScriptObject.class} as its
 338      * parameter type. If you happen to link to a method that expects different
 339      * types, (you can use these invokers on POJOs too, after all, and end up
 340      * linking with their methods that have strongly-typed signatures), all
 341      * necessary conversions allowed by either Java or JavaScript will be
 342      * applied: if invoked methods specify either primitive or wrapped Java
 343      * numeric types, or {@code String} or {@code boolean/Boolean}, then the
 344      * parameters might be subjected to standard ECMAScript {@code ToNumber},
 345      * {@code ToString}, and {@code ToBoolean} conversion, respectively. Less
 346      * obviously, if the expected parameter type is a SAM type, and you pass a
 347      * JavaScript function, a proxy object implementing the SAM type and
 348      * delegating to the function will be passed. Linkage can often be optimized
 349      * when linkers have more specific type information than "everything can be
 350      * an object".</li>
 351      * <li>You can also be as specific in return types as you want. For return
 352      * types any necessary type conversion available in either Java or
 353      * JavaScript will be automatically applied, similar to the process
 354      * described for parameters, only in reverse direction: if you specify any
 355      * either primitive or wrapped Java numeric type, or {@code String} or
 356      * {@code boolean/Boolean}, then the return values will be subjected to
 357      * standard ECMAScript {@code ToNumber}, {@code ToString}, and
 358      * {@code ToBoolean} conversion, respectively. Less obviously, if the return
 359      * type is a SAM type, and the return value is a JavaScript function, a
 360      * proxy object implementing the SAM type and delegating to the function
 361      * will be returned.</li>
 362      * </ul>
 363      * @param name name at the call site. Must not be null. Must be encoded
 364      * using {@link NameCodec#encode(String)}. If the operation does not take a
 365      * name, use empty string (also has to be encoded).
 366      * @param flags the call site flags for the operation; see
 367      * {@link NashornCallSiteDescriptor} for available flags. The most important
 368      * part of the flags are the ones encoding the actual operation.
 369      * @param rtype the return type for the operation
 370      * @param ptypes the parameter types for the operation
 371      * @return MethodHandle for invoking the operation.
 372      */
 373     public static MethodHandle createDynamicInvoker(final String name, final int flags, final Class<?> rtype, final Class<?>... ptypes) {
 374         return bootstrap(MethodHandles.publicLookup(), name, MethodType.methodType(rtype, ptypes), flags).dynamicInvoker();
 375     }
 376 
 377     /**
 378      * Returns a dynamic invoker for the {@link NashornCallSiteDescriptor#CALL}
 379      * operation using the public lookup.
 380      * @param rtype the return type for the operation
 381      * @param ptypes the parameter types for the operation
 382      * @return a dynamic invoker for the {@code CALL} operation.
 383      */
 384     public static MethodHandle createDynamicCallInvoker(final Class<?> rtype, final Class<?>... ptypes) {
 385         return createDynamicInvoker("", NashornCallSiteDescriptor.CALL, rtype, ptypes);
 386     }
 387 
 388     /**
 389      * Returns a dynamic invoker for a specified dynamic operation using the
 390      * public lookup. Similar to
 391      * {@link #createDynamicInvoker(String, int, Class, Class...)} but with
 392      * already precomposed method type.
 393      * @param name name at the call site.
 394      * @param flags flags at the call site
 395      * @param type the method type for the operation
 396      * @return MethodHandle for invoking the operation.
 397      */
 398     public static MethodHandle createDynamicInvoker(final String name, final int flags, final MethodType type) {
 399         return bootstrap(MethodHandles.publicLookup(), name, type, flags).dynamicInvoker();
 400     }
 401 
 402     /**
 403      * Binds any object Nashorn can use as a [[Callable]] to a receiver and optionally arguments.
 404      * @param callable the callable to bind
 405      * @param boundThis the bound "this" value.
 406      * @param boundArgs the bound arguments. Can be either null or empty array to signify no arguments are bound.
 407      * @return a bound callable.
 408      * @throws ECMAException with {@code TypeError} if the object is not a callable.
 409      */
 410     public static Object bindCallable(final Object callable, final Object boundThis, final Object[] boundArgs) {
 411         if (callable instanceof ScriptFunction) {
 412             return ((ScriptFunction)callable).createBound(boundThis, boundArgs);
 413         } else if (callable instanceof BoundCallable) {
 414             return ((BoundCallable)callable).bind(boundArgs);
 415         } else if (isCallable(callable)) {
 416             return new BoundCallable(callable, boundThis, boundArgs);
 417         }
 418         throw notFunction(callable);
 419     }
 420 
 421     /**
 422      * Creates a super-adapter for an adapter, that is, an adapter to the adapter that allows invocation of superclass
 423      * methods on it.
 424      * @param adapter the original adapter
 425      * @return a new adapter that can be used to invoke super methods on the original adapter.
 426      */
 427     public static Object createSuperAdapter(final Object adapter) {
 428         return new JavaSuperAdapter(adapter);
 429     }
 430 
 431     /**
 432      * If the given class is a reflection-specific class (anything in {@code java.lang.reflect} and
 433      * {@code java.lang.invoke} package, as well a {@link Class} and any subclass of {@link ClassLoader}) and there is
 434      * a security manager in the system, then it checks the {@code nashorn.JavaReflection} {@code RuntimePermission}.
 435      * @param clazz the class being tested
 436      * @param isStatic is access checked for static members (or instance members)
 437      */
 438     public static void checkReflectionAccess(final Class<?> clazz, final boolean isStatic) {
 439         ReflectionCheckLinker.checkReflectionAccess(clazz, isStatic);
 440     }
 441 
 442     /**
 443      * Returns the Nashorn's internally used dynamic linker's services object. Note that in code that is processing a
 444      * linking request, you will normally use the {@code LinkerServices} object passed by whatever top-level linker
 445      * invoked the linking (if the call site is in Nashorn-generated code, you'll get this object anyway). You should
 446      * only resort to retrieving a linker services object using this method when you need some linker services (e.g.
 447      * type converter method handles) outside of a code path that is linking a call site.
 448      * @return Nashorn's internal dynamic linker's services object.
 449      */
 450     public static LinkerServices getLinkerServices() {
 451         return Context.getDynamicLinker().getLinkerServices();
 452     }
 453 
 454     /**
 455      * Takes a guarded invocation, and ensures its method and guard conform to the type of the call descriptor, using
 456      * all type conversions allowed by the linker's services. This method is used by Nashorn's linkers as a last step
 457      * before returning guarded invocations. Most of the code used to produce the guarded invocations does not make an
 458      * effort to coordinate types of the methods, and so a final type adjustment before a guarded invocation is returned
 459      * to the aggregating linker is the responsibility of the linkers themselves.
 460      * @param inv the guarded invocation that needs to be type-converted. Can be null.
 461      * @param linkerServices the linker services object providing the type conversions.
 462      * @param desc the call site descriptor to whose method type the invocation needs to conform.
 463      * @return the type-converted guarded invocation. If input is null, null is returned. If the input invocation
 464      * already conforms to the requested type, it is returned unchanged.
 465      */
 466     static GuardedInvocation asTypeSafeReturn(final GuardedInvocation inv, final LinkerServices linkerServices, final CallSiteDescriptor desc) {
 467         return inv == null ? null : inv.asTypeSafeReturn(linkerServices, desc.getMethodType());
 468     }
 469 
 470     /**
 471      * Adapts the return type of the method handle with {@code explicitCastArguments} when it is an unboxing
 472      * conversion. This will ensure that nulls are unwrapped to false or 0.
 473      * @param target the target method handle
 474      * @param newType the desired new type. Note that this method does not adapt the method handle completely to the
 475      * new type, it only adapts the return type; this is allowed as per
 476      * {@link DynamicLinkerFactory#setAutoConversionStrategy(MethodTypeConversionStrategy)}, which is what this method
 477      * is used for.
 478      * @return the method handle with adapted return type, if it required an unboxing conversion.
 479      */
 480     private static MethodHandle unboxReturnType(final MethodHandle target, final MethodType newType) {
 481         final MethodType targetType = target.type();
 482         final Class<?> oldReturnType = targetType.returnType();
 483         final Class<?> newReturnType = newType.returnType();
 484         if (TypeUtilities.isWrapperType(oldReturnType)) {
 485             if (newReturnType.isPrimitive()) {
 486                 // The contract of setAutoConversionStrategy is such that the difference between newType and targetType
 487                 // can only be JLS method invocation conversions.
 488                 assert TypeUtilities.isMethodInvocationConvertible(oldReturnType, newReturnType);
 489                 return MethodHandles.explicitCastArguments(target, targetType.changeReturnType(newReturnType));
 490             }
 491         } else if (oldReturnType == void.class && newReturnType == Object.class) {
 492             return MethodHandles.filterReturnValue(target, VOID_TO_OBJECT);
 493         }
 494         return target;
 495     }
 496 }