private final ScriptPlugin decorated;
    private final BuildOperationRunner buildOperationRunner;
    private final UserCodeApplicationContext userCodeApplicationContext;

    public BuildOperationScriptPlugin(ScriptPlugin decorated, BuildOperationRunner buildOperationRunner, UserCodeApplicationContext userCodeApplicationContext) {
        this.decorated = decorated;
        this.buildOperationRunner = buildOperationRunner;

    /**
     * Creates an {@link ExecAction} that is not decorated. Use this when the action is not made visible to the DSL.
     * If you need to make the action visible to the DSL, use {@link org.gradle.process.ExecOperations} instead.
     */
    ExecAction newExecAction();

    /**
     * Creates a {@link JavaExecAction} that is not decorated. Use this when the action is not made visible to the DSL.

    }

    /**
     * Gradle decoration does not generate correct Kotlin metadata for decorated Kotlin types.
     * Because of that, decorated types do not appear as subtypes of the original types when inspected with Kotlin reflection.
     * Workaround: use Java reflection to determine the supertypes.
     * TODO: Either fix Kotlin metadata in decorated classes or introduce generic utilities
     */
    private

import org.gradle.internal.reflect.Instantiator;

import java.lang.reflect.Modifier;

/**
 * An instantiator that uses the correct instantiation scheme depending on the plugin type.  This allows
 * us to use a decorated instantiator for types that need it (such as software type plugins) and continue
 * using the injected instantiator for types that do not need it (such as plugin types marked as final).
 */
@NonNullApi

    def buildOperationScriptPlugin = new BuildOperationScriptPlugin(decoratedScriptPlugin, buildOperationRunner, userCodeApplicationContext)
    def target = "Test Target"

    def "delegates to decorated script plugin via build operation"() {
        when:
        buildOperationScriptPlugin.apply(target)

        then:
        2 * scriptSource.getResource() >> scriptSourceResource

        MethodHandle spreader = original.asSpreader(Object[].class, original.type().parameterCount());
        MethodHandle decorated = MethodHandles.insertArguments(INTERCEPTOR, 0, this, spreader, flags, caller.lookupClass().getName());
        return decorated.asCollector(Object[].class, original.type().parameterCount()).asType(original.type());
    }

            session = verbose;
        }

        for (RepositorySessionDecorator decorator : decorators) {
            RepositorySystemSession decorated = decorator.decorate(project, session);
            if (decorated != null) {
                session = decorated;
            }
        }

        CollectRequest collect = new CollectRequest();

    def startParameter = Mock(StartParameter)
    def state = Mock(SettingsState)
    def settingsInternal = Mock(SettingsInternal)
    def rootDir = new File("root")

    def "delegates to decorated settings processor"() {
        given:
        settings()

        when:
        buildOperationScriptPlugin.process(gradleInternal, settingsLocation, classLoaderScope, startParameter)

        then:

import java.lang.invoke.MethodHandles;
import java.util.Set;

/**
 * Intercepts method and constructor calls as well as property reads in dynamic Groovy bytecode.
 * <p>
 * The interceptor serves as a factory for decorated Groovy {@link CallSite} instances.
 * These instances replace original CallSites where the calls are to be intercepted.
 * <p>
 * Descendants of this class should be thread-safe, making a stateless implementation is perfect.
 */

/**
 * Wraps another {@link JavaCompiler.CompilationTask} and sets up its annotation processors
 * according to the provided processor declarations and processor path. Incremental processors
 * are decorated in order to validate their behavior.
 *
 * This class also serves a purpose when incremental annotation processing is not active.
 * It replaces the normal processor discovery, which suffers from file descriptor leaks