}

}

class Handles {
    public static final Lazy<MethodHandle> FOR_EACH_LINE_DEFAULT =
        lazyKotlinStaticDefaultHandle(FilesKt.class, "forEachLine", void.class, File.class, Charset.class, Function1.class);

    public static final Lazy<MethodHandle> READ_LINES_DEFAULT =
        lazyKotlinStaticDefaultHandle(FilesKt.class, "readLines", List.class, File.class, Charset.class);

        this.interceptScopes = ImmutableSet.copyOf(interceptScopes);
    }

    @Override
    public MethodHandle decorateMethodHandle(MethodHandle original, MethodHandles.Lookup caller, int flags) {
        MethodHandle spreader = original.asSpreader(Object[].class, original.type().parameterCount());
        MethodHandle decorated = MethodHandles.insertArguments(INTERCEPTOR, 0, this, spreader, flags, caller.lookupClass().getName());

package org.gradle.internal.classpath;

import org.gradle.internal.Cast;
import org.gradle.internal.lazy.Lazy;

import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.util.Arrays;

public class MethodHandleUtils {
    public static MethodHandle findStaticOrThrowError(Class<?> refc, String name, MethodType methodType) {
        try {

package org.gradle.internal.classpath.intercept;

import java.lang.invoke.MethodHandle;

import static org.gradle.internal.classpath.intercept.InvocationUtils.unwrap;

/**
 * The implementation of {@link Invocation} that forwards the call to a MethodHandle. Supports both normal and spread Groovy calls.
 */
class MethodHandleInvocation implements Invocation {
    private final MethodHandle original;
    private final Object[] originalArgs;

     * @throws Throwable if necessary to propagate it to the caller
     */
    Object intercept(Invocation invocation, String consumer) throws Throwable;

    MethodHandle decorateMethodHandle(MethodHandle original, MethodHandles.Lookup caller, int flags);

    Set<InterceptScope> getInterceptScopes();

import javax.annotation.Nullable;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.reflect.Method;

class MethodHandleBasedServiceMethod extends AbstractServiceMethod {
    private final static MethodHandles.Lookup LOOKUP = MethodHandles.publicLookup();
    private final MethodHandle method;

    MethodHandleBasedServiceMethod(Method target) throws IllegalAccessException {

import static com.google.common.base.Preconditions.checkNotNull;

import com.google.errorprone.annotations.Immutable;
import com.google.j2objc.annotations.J2ObjCIncompatible;
import java.io.Serializable;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.nio.ByteBuffer;
import java.util.zip.Checksum;
import org.checkerframework.checker.nullness.qual.Nullable;

/**

            try {
                MethodHandles.Lookup lookup = getLookupForClassLoader(classLoader);
                MethodHandle methodHandle = lookup.findVirtual(ClassLoader.class, methodName, methodType);
                return (T) methodHandle.bindTo(classLoader).invokeWithArguments(arguments);
            } catch (Throwable e) {
                throw new RuntimeException(e);
            }
        }

    // dynamic dispatch has to happen somewhere. Wrapping the dispatch logic into the CallInterceptor allows
    // to reuse the common MethodHandle decoration routine in maybeDecorateIndyCallSite instead of using a
    // dedicated MethodHandle decorator method just for constructors.
    private final CallInterceptor dispatchingConstructorInterceptor = new AbstractCallInterceptor() {
        @Override

    public MethodHandleBasedServiceMethodFactory() {
        try {
            // Force loading to check if method handle is supported
            Class.forName("java.lang.invoke.MethodHandle");
        } catch (ClassNotFoundException e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

    @Override
    public ServiceMethod toServiceMethod(Method method) {