}
        }

    private
    suspend fun WriteContext.writeBeanOf(beanType: Class<*>, value: Any) {
        writeClass(beanType)
        // TODO - should collect the details of the decoration (eg enabled annotations, etc), and also carry this information with the serialized class reference
        //  instead of separately for each bean
        val generated = value is GeneratedSubclass
        writeBoolean(generated)

    public void addPhaseOperation(IPrimaryClassNodeOperation op, int phase) {
        if (phase != Phases.CLASS_GENERATION) {
            super.addPhaseOperation(op, phase);
        }
    }

    // this is using a decoration of the existing classgen implementation
    // it can't be implemented as a phase as our customVerifier needs to visit closures as well

            plugins.withId("$detectedBy") {
                operations << 'withId for ' + it.class.simpleName
            }
            pluginManager.withPlugin("$detectedBy") {
                // assert we are using our closure decoration and not closure coercion
                assert delegate instanceof $AppliedPlugin.name
                operations << 'withPlugin'
            }
            operations << "applying"
            apply plugin: '$appliedBy'

    def "For every boolean is getter there is a get Getter"() {
        given:
        executer.requireDaemon().requireIsolatedDaemons() // We need to fork - if we do not fork Class-Decoration does not happen

        when:
        def convertedClasses = this.getClass().getResource( '/org/gradle/initialization/converted-types.txt' ).readLines()
        buildFile << """
            task checkHasGetters {

 *
 * The semantics of each method is completely up to the implementation. For example, {@link BeanDynamicObject}
 * provides a dynamic view of the functionality of an object and does not provide any decoration or extra functionality.
 * The {@link org.gradle.internal.extensibility.ExtensibleDynamicObject} implementation on the other hand does provide extra functionality.
 */

import org.gradle.internal.resource.ResourceLocation;
import org.gradle.internal.resource.TextResource;

import javax.annotation.Nullable;
import java.io.File;
import java.net.URI;

/**
 * A decorating {@link ScriptPlugin} implementation that delegates to a given
 * delegatee implementation, but wraps the apply() execution in a
 * {@link org.gradle.internal.operations.BuildOperation}.
 */

}

ul.tabLinks li.selected {
    background-color: #c5f0f5;
    border-color: #c5f0f5;
}

ul.tabLinks a {
    font-size: 120%;
    display: block;
    outline: none;
    text-decoration: none;
    margin: 0;
    padding: 0;
}

ul.tabLinks li h2 {
    margin: 0;
    padding: 0;
}

div.tab {
}

div.selected {
    display: block;
}

div.deselected {

        cache.attachRootBuild(targetBuild.gradle.services.get())

        cache.initializeCacheEntry()

        // Currently, apply the decoration only to the root build, as the cache implementation is still scoped to the root build (that is, it assumes it is only applied to the root build)
        return createController(true, targetBuild, workExecutor, finishExecutor)
    }

     * @param closure the closure to decorate
     */
    <T> Closure<T> decorate(String registrationPoint, Closure<T> closure);

    /**
     * Decorates a listener type object.
     * <p>
     * Supports decorating {@link BuildListener}, {@link ProjectEvaluationListener} and {@link TaskExecutionGraphListener} listeners
     * <p>
     * Does not decorate any action that implements {@link InternalListener}.

/**
 * Used as the superclass for views for types that extend {@link org.gradle.model.ModelMap}. Mixes in Groovy DSL support.
 */
// TODO - mix in Groovy support using bytecode decoration instead
// TODO - validate closure parameters to check they are within bounds
public abstract class ModelMapGroovyView<I> extends GroovyObjectSupport implements ModelMap<I> {
    @Override
    public String toString() {