return delegate.buildFile
        }

        override fun getDisplayName(): String {
            return delegate.displayName
        }

        override fun getDescription(): String? {
            onAccess("description")
            return delegate.description
        }

        override fun setDescription(description: String?) {
            onAccess("description")

        private final DslOriginDependencyMetadata delegate;

        private ClientModuleDependencyMetadataWrapper(DslOriginDependencyMetadata delegate) {
            super(delegate);
            this.delegate = delegate;
        }

        @Override
        public Dependency getSource() {
            return delegate.getSource();
        }
    }

    }

    class OwnerHost(override val delegate: HostServiceProvider) : IsolateOwners() {
        override fun <T> service(type: Class<T>): T = delegate.service(type)
    }

    class OwnerFlowScope(override val delegate: Gradle) : IsolateOwners() {
        override fun <T> service(type: Class<T>): T = (delegate as GradleInternal).services.get(type)
    }

        delegate.populate(plan)
    }

    override fun execute(plan: FinalizedExecutionPlan?): ExecutionResult<Void>? =
        delegate.execute(plan)

    override fun visitScheduledNodes(visitor: BiConsumer<List<Node>, Set<Node>>) =
        delegate.visitScheduledNodes(visitor)

    override fun size(): Int = delegate.size()

    @Deprecated("Deprecated in Java")

class ConfigurationCacheAwareBuildToolingModelController(
    private val delegate: BuildToolingModelController,
    private val cache: BuildTreeConfigurationCache
) : BuildToolingModelController {
    override fun getConfiguredModel(): GradleInternal = delegate.configuredModel

    override fun locateBuilderForTarget(modelName: String, param: Boolean): ToolingModelScope {
        return wrap(delegate.locateBuilderForTarget(modelName, param))
    }

        private final InputStream delegate;

        public EncodedInput(java.io.InputStream delegate) {
            this.delegate = delegate;
        }

        @Override
        public int read() throws IOException {
            int byte1 = delegate.read();
            if (byte1 < 0) {
                return -1;
            }
            int byte2 = delegate.read();
            if (byte2 < 0) {

        delegate.apply(action)

    override fun apply(options: MutableMap<String, *>) =
        delegate.apply(options)

    override fun getPluginManager(): PluginManagerInternal =
        delegate.pluginManager

    override fun getExtensions(): ExtensionContainer =
        delegate.extensions

    override fun getGradleVersion(): String =
        delegate.gradleVersion

        private final VersionScheme versionScheme;
        private final org.eclipse.aether.version.Version delegate;

        DefaultVersion(VersionScheme versionScheme, org.eclipse.aether.version.Version delegate) {
            this.versionScheme = versionScheme;
            this.delegate = delegate;
        }

        DefaultVersion(VersionScheme versionScheme, String delegateValue) {

    private final InternalProblemBuilder delegate;

    DelegatingProblemBuilder(InternalProblemBuilder delegate) {
        this.delegate = delegate;
    }

    @Override
    public Problem build() {
        return delegate.build();
    }

    @Override
    public InternalProblemBuilder id(String name, String displayName) {
        return validateDelegate(delegate).id(name, displayName);
    }

    @Override

    private final ErrorHandlingModuleComponentRepositoryAccess local;
    private final ErrorHandlingModuleComponentRepositoryAccess remote;

    public ErrorHandlingModuleComponentRepository(ModuleComponentRepository<ModuleComponentGraphResolveState> delegate, RepositoryDisabler remoteRepositoryDisabler) {
        this.delegate = delegate;