}

    /**
     * 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

        def action = Mock(Action)
        def deferred = Mock(Action)
        def id1
        def decorated

        when:
        context.apply(source, action)

        then:
        1 * action.execute(_) >> { UserCodeApplicationId id ->
            id1 = id
            decorated = context.current().reapplyLater(deferred)
        }
        0 * deferred._

        and:

        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();

         * </ul>
         *
         * Because of it doing so, our decorated call site is removed from the dynamic invocation code path, and we lose the ability to track dynamic call entry points. <p>
         *
         * To fix that, we store the optimized call site that the Groovy runtime created (and we delegate to it in subsequent calls), and we put a reference to our
         * decorated call site back into the call site array.
         */

 *
 * This type is not thread-safe.
 *
 * Consider using {@link org.gradle.internal.ImmutableActionSet} instead of this.
 *
 * Implements {@link InternalListener} as components themselves should be decorated if appropriate.
 */
public class MutableActionSet<T> implements Action<T>, InternalListener {
    private ImmutableActionSet<T> actions = ImmutableActionSet.empty();

    public void add(Action<? super T> action) {

        buildFile << """
            // prevent windows resource and cpp compile tasks from running in parallel
            // this is because we don't want the cpp compile tasks to accidentally use 
            // the decorated tool provider we set up for testing the parallelism
            tasks.withType(CppCompile) { mustRunAfter tasks.withType(WindowsResourceCompile) }
        """

        when:
        succeeds("assemble", "parallelTask")

class Composite(object):
  """A decorator to register a function as a composition for an TF operator.

  The argument to the decorator must be the name of a TF raw operator the
  function composites for. Decorated function must take positional arguments
  which corresponds to the input and attributes in OpDef of the TF operation.
  # TODO(fengliuai): more documents here.

  Example:
    @composite.Composite('AddN')