@InterceptCalls
    @StaticMethod(ofClass = Files.class)
    public static boolean intercept_isRegularFile(
        Path path,
        @VarargParameter LinkOption[] options,
        @CallerClassName String consumer
    ) {
        tryReportFileSystemEntryObserved(path, consumer);
        return Files.isRegularFile(path, options);
    }

    @InterceptCalls
    @StaticMethod(ofClass = Files.class)

public class KotlinStdlibFileInterceptors {
    @InterceptCalls
    @StaticMethod(ofClass = FilesKt.class)
    public static byte[] intercept_readBytes(
        File self,
        @CallerClassName String consumer
    ) {
        Instrumented.fileOpened(self, consumer);
        return FilesKt.readBytes(self);
    }

    @InterceptCalls
    @StaticMethod(ofClass = FilesKt.class)
    public static void intercept_forEachBlock(

import org.gradle.internal.instrumentation.api.annotations.SpecificJvmCallInterceptors;
import org.gradle.internal.instrumentation.api.annotations.CallableKind.StaticMethod;
import org.gradle.internal.instrumentation.api.annotations.InterceptCalls;
import org.gradle.internal.instrumentation.api.annotations.ParameterKind.CallerClassName;

@NonNullApi
@SpecificJvmCallInterceptors(generatedClassName = InterceptorDeclaration.JVM_BYTECODE_GENERATED_CLASS_NAME_FOR_CONFIG_CACHE)
public class GroovyDynamicDispatchInterceptors {
    @InterceptJvmCalls
    @CallableKind.StaticMethod(ofClass = ScriptBytecodeAdapter.class)
    public static void intercept_setGroovyObjectProperty(
        Object messageArgument,
        /* Sometimes it's null, we can't rely on it, so we still use @CallerClassName */

            class Test {
                @InterceptCalls
                @CallableKind.StaticMethod(ofClass = my.Test.class)
                @CallableDefinition.Name("${first}Target")
                public static void ${first}() {}

                @InterceptCalls
                @CallableKind.StaticMethod(ofClass = my.Test.class)
                @CallableDefinition.Name("${second}Target")

    STATIC_METHOD, INSTANCE_METHOD, AFTER_CONSTRUCTOR, GROOVY_PROPERTY_GETTER, GROOVY_PROPERTY_SETTER;

    public static CallableKindInfo fromAnnotation(Annotation annotation) {
        if (annotation instanceof CallableKind.StaticMethod) {
            return STATIC_METHOD;
        }
        if (annotation instanceof CallableKind.InstanceMethod) {
            return INSTANCE_METHOD;
        }

    @Target(ElementType.METHOD)
    @Retention(RetentionPolicy.CLASS)
    public @interface InstanceMethod {
    }

    @Target(ElementType.METHOD)
    @Retention(RetentionPolicy.CLASS)
    public @interface StaticMethod {
        Class<?> ofClass();
    }

    @Target(ElementType.METHOD)
    @Retention(RetentionPolicy.CLASS)
    public @interface GroovyPropertyGetter {
    }

    @Target(ElementType.METHOD)

        }
    }

    private static Type extractOwnerClass(ExecutableElement executableElement) {
        Optional<? extends AnnotationMirror> maybeStaticMethod = findAnnotationMirror(executableElement, CallableKind.StaticMethod.class);
        List<VariableElement> receivers = executableElement.getParameters().stream()
            .filter(it -> it.getAnnotation(ParameterKind.Receiver.class) != null)
            .collect(Collectors.toList());

    assertFalse(delegate.isOverridable());
    assertFalse(delegate.isVarArgs());
  }

  public void testStaticMethod_isOverridable() throws Exception {
    Invokable<?, ?> delegate = Prepender.method("staticMethod");
    assertTrue(delegate.isStatic());
    assertFalse(delegate.isOverridable());
    assertFalse(delegate.isVarArgs());
  }

  public void testStaticFinalMethod_isFinal() throws Exception {

    assertFalse(delegate.isOverridable());
    assertFalse(delegate.isVarArgs());
  }

  public void testStaticMethod_isOverridable() throws Exception {
    Invokable<?, ?> delegate = Prepender.method("staticMethod");
    assertTrue(delegate.isStatic());
    assertFalse(delegate.isOverridable());
    assertFalse(delegate.isVarArgs());
  }

  public void testStaticFinalMethod_isFinal() throws Exception {