fun test() {
    val f = <expr>String</expr>::length
    val s = "hello"
    val g = s::length
    f() + g() + String::length.invoke(s) + s::length.invoke()

fun test() {
    val f = String::length
    val s = "hello"
    val g = s::length
    <expr>f</expr>(s) + g() + String::length.invoke(s) + s::length.invoke()

    public final static field INSTANCE: MainKt$test$1
    inner (anonymous) class MainKt$test$1
    static method <clinit>(): void
    method <init>(): void
    public synthetic bridge method invoke(): java.lang.Object
    public final method invoke(): void
}

public final class MainKt {
    // source: 'main.kt'
    inner (anonymous) class MainKt$test$1
    public final static method Greeting(p0: java.lang.String): void

          AlpnProvider(names),
        )
      putMethod.invoke(null, sslSocket, alpnProvider)
    } catch (e: InvocationTargetException) {
      throw AssertionError("failed to set ALPN", e)
    } catch (e: IllegalAccessException) {
      throw AssertionError("failed to set ALPN", e)
    }
  }

  override fun afterHandshake(sslSocket: SSLSocket) {
    try {
      removeMethod.invoke(null, sslSocket)
    } catch (e: IllegalAccessException) {

 * limitations under the License.
 */

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) {

            return method.getGenericParameterTypes()[0];
        }

        @Override
        public void setValue(Object target, Object value) {
            JavaMethod.of(Object.class, method).invoke(target, value);
        }
    }

    private static class PropertyValueSetter implements PropertySetter {
        private final Method method;
        private final Class<?> elementType;

            argValue = argType.getMethod("getValidPolicy", String.class).invoke(null, value);
        } catch (Exception e) {
            // New API not found. Fallback to legacy String argument.
            argType = String.class;
            argValue = value;
        }

        try {
            JavaMethod.of(TestNG.class, Object.class, "setConfigFailurePolicy", argType).invoke(testNg, argValue);
        } catch (NoSuchMethodException e) {

            Object instance = container.lookup(clazz);
            Method method = clazz.getMethod("prompt", String.class, List.class, String.class);
            return (String) method.invoke(instance, message, possibleValues, defaultReply);
        } catch (Exception e) {
            throw new PrompterException("Unable to call prompter", e);
        }
    }

    @Override

        fun Int.fooExt() {}

        val String.barExt: String
            get() = "bar"

        var Int.bazarExt: String
            get() = "bar"
            set(value) = Unit

        operator fun String.invoke(p: String, block: String.() -> Unit) = Unit

    """

    private
    val annotatedKotlinMembers = """

        /** @since 2.0 */
        @Incubating
        fun foo() {}

        /** @since 2.0 */

            }
            if (method.getName().equals("hashCode") && args == null) {
                return proxyHashCode(proxy);
            }
            return invoke(delegate.getClass(), delegate, boxedReturnType, method, args);
        }

        private <T, R> R invoke(Class<T> listenerType, Object listener, Class<R> returnType, Method method, Object[] args) {
            T listenerCast = listenerType.cast(listener);