Method <org.gradle.api.plugins.quality.Checkstyle.getConfig()> has raw return type org.gradle.api.resources.TextResource in (Checkstyle.java:0)
Method <org.gradle.api.plugins.quality.CodeNarc.getConfig()> has raw return type org.gradle.api.resources.TextResource in (CodeNarc.java:0)
Method <org.gradle.api.plugins.quality.Pmd.getRuleSetConfig()> has raw return type org.gradle.api.resources.TextResource in (Pmd.java:0)

	// misspelled     x.Foo   ==    FoO    type X has no field or method Foo, but does have field FoO
	// misspelled     x.Foo   ==    foo    type X has no field or method Foo, but does have field foo
	// misspelled     x.Foo   ==    foO    type X has no field or method Foo, but does have field foO
	//
	// misspelled     x.foo   ==    Foo    type X has no field or method foo, but does have field 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, ".")

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 {

// `OpQuantSpec` will be deprecated and `Method` will be used instead.
void PopulateCoeffOpQuantDimIfPerChannelQuantized(
    TF::XlaCallModuleOp xla_call_module_op, OpQuantSpec& spec) {
  absl::StatusOr<Method> method = GetQuantizationMethod(xla_call_module_op);
  if (method.ok() && method->has_static_range_ptq()) {
    // TODO: b/331145946 - Use `Method` accessors.

     *
     * <p>
     * When invoked on a property with no value, this method first sets the value
     * of the property to its current convention value, if set, or an empty collection.
     * </p>
     * <p>Even if the given provider has no value, after this method is invoked,
     * the actual value of this property is guaranteed to be present.</p>
     *

     * the lease prior to doing any meaningful work.
     *
     * This method is reentrant so that a thread can call this method from the given action.
     *
     * This method blocks until a worker lease is available.
     */
    <T> T runAsWorkerThread(Factory<T> action);

    /**

    // source: 'fragment.kt'
    public method <init>(): void
    public final static method run(p0: Foo, p1: java.lang.String, p2: kotlin.jvm.internal.Ref$IntRef): void
    public final inner class kotlin/jvm/internal/Ref$IntRef
}

public final class ContextKt

public final class Foo {
    // source: 'context.kt'
    public method <init>(): void

        if (result == null) {
            return null;
        } else {
            return targetClass.cast(result);
        }
    }

    /**
     * Utility method to invoke a method on an object by reflective means.
     *
     * @return the result of the method invocation as an {@link Object}
     * @see #invokeMethod(Object, String, Class) for the generic version of this method
     */
    @Nullable

    public static ParameterizedClassDesc createParameterizedClassDesc(final Method method, final int index,
            final Map<TypeVariable<?>, Type> map) {
        assertArgumentNotNull("method", method);
        assertArgumentArrayIndex("index", index, method.getParameterTypes().length);
        assertArgumentNotNull("map", map);

        return createParameterizedClassDesc(method.getGenericParameterTypes()[index], map);
    }

    /**