}

    protected void writeMethod(MethodMember method) {
        MethodVisitor mv = apiMemberAdapter.visitMethod(
            method.getAccess(), method.getName(), method.getTypeDesc(), method.getSignature(),
            method.getExceptions().toArray(new String[0]));
        writeMethodAnnotations(mv, method.getAnnotations());
        writeMethodAnnotations(mv, method.getParameterAnnotations());
        mv.visitEnd();
    }

 */

package org.gradle.model.internal.inspect;

import java.lang.reflect.Method;

public interface RuleSourceValidationProblemCollector extends ValidationProblemCollector {
    void add(MethodRuleDefinition<?, ?> method, String problem);

    void add(MethodRuleDefinition<?, ?> method, String problem, Throwable cause);

    void add(Method method, String problem);

	_ = x /* ERROR "impossible type assertion: x.(T1)\n\tT1 does not implement I1 (method foo has pointer receiver)" */ .(T1)

	T1{}.foo /* ERROR "cannot call pointer method foo on T1" */ ()
	x.Foo /* ERROR "x.Foo undefined (type I1 has no field or method Foo, but does have method foo)" */ ()

	return
}

// SplitMethod splits the method symbol name into pointer, receiver,
// and method components. It must be called only on Method symbols.
//
// Example: "(*Buffer).Grow" -> (true, "Buffer", "Grow")
func (sym *Symbol) SplitMethod() (ptr bool, recv, name string) {
	if sym.Kind != Method {
		panic("not a method")
	}
	recv, name, _ = strings.Cut(sym.Name, ".")

            @Override
            Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                if (method.name == "equals") {
                    return false
                }
                if (method.name == "hashCode") {
                    return this.hashCode()
                }
                if (method.name == "toString") {
                    return "<proxy>"
                }

import java.lang.reflect.Method;
import java.lang.reflect.Type;

abstract class AbstractServiceMethod implements ServiceMethod {
    private final Method method;
    private final Class<?> owner;
    private final String name;
    private final Type[] parameterTypes;
    private final Type serviceType;

    AbstractServiceMethod(Method target) {
        this.method = target;

import okhttp3.Headers

class PushPromise(
  @get:JvmName("method") val method: String,
  @get:JvmName("path") val path: String,
  @get:JvmName("headers") val headers: Headers,
  @get:JvmName("response") val response: MockResponse,
) {
  @JvmName("-deprecated_method")
  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "method"),
    level = DeprecationLevel.ERROR,
  )

package errors

import (
	"internal/reflectlite"
)

// Unwrap returns the result of calling the Unwrap method on err, if err's
// type contains an Unwrap method returning error.
// Otherwise, Unwrap returns nil.
//
// Unwrap only calls a method of the form "Unwrap() error".
// In particular Unwrap does not unwrap errors returned by [Join].
func Unwrap(err error) error {
	u, ok := err.(interface {

        private final Method getter;
        private final Field field;
        private final Class<?> elementType;

        public PropertyFieldSetter(Method getter, Field field) {
            this(getter, field, ModelType.of(getter.getGenericReturnType()).getTypeVariables().get(0).getRawClass());
        }

        public PropertyFieldSetter(Method getter, Field field, Class<?> elementType) {

            }
        }
    }

    private void validateNonRuleMethod(Method method, RuleSourceValidationProblemCollector problems) {
        if (!Modifier.isPrivate(method.getModifiers()) && !Modifier.isStatic(method.getModifiers()) && !method.isSynthetic() && !GroovyMethods.isObjectMethod(method)) {
            problems.add(method, "A method that is not annotated as a rule must be private");
        }
    }