public CompositeBuildPluginResolverContributor(BuildIncluder buildIncluder) {
        this.resolver = new CompositeBuildPluginResolver(buildIncluder);
    }

    @Override
    public void discardAll() {
        resolver.discardAll();
    }

    @Override
    public void collectResolversInto(Collection<PluginResolver> resolvers) {
        resolvers.add(resolver);
    }

    private abstract static class PluginResult {

        WorkNodeAction action = (WorkNodeAction) node;
        ActionNode actionNode = actionNodeFor(action);
        resolveAction.execute(actionNode);
        return true;
    }

    @Override
    public void discardAll() {
        nodesForAction.clear();
    }

    private ActionNode actionNodeFor(WorkNodeAction action) {
        ActionNode actionNode = nodesForAction.get(action);
        if (actionNode == null) {

 * projects are discarded.
 */
public interface HoldsProjectState {
    /**
     * Discards any project state.
     */
    void discardAll();

        return provider;
    }

    @Override
    public void discardAll() {
        discardAll(false);
    }

    private void discardAll(boolean forceAll) {
        withRegistrations(registrations -> {
            List<DefaultServiceRegistration<?, ?>> preserved = new ArrayList<>();
            try {

        outputHierarchy = new ExecutionNodeAccessHierarchy(caseSensitivity, stat);
        destroyableHierarchy = new ExecutionNodeAccessHierarchy(caseSensitivity, stat);
    }

    @Override
    public void discardAll() {
        outputHierarchy.clear();
        destroyableHierarchy.clear();
    }

    /**
     * Create the input node access hierarchy.
     *

        synchronized (publicationsByProject) {
            publicationsByProject.put(project.getIdentityPath(), new ReferenceImpl(publication, project));
        }
    }

    @Override
    public void discardAll() {
        publicationsByProject.clear();
    }

    private static class ReferenceImpl implements Reference<ProjectPublication> {
        private final ProjectPublication publication;

    }

    public Iterable<? extends IdeProjectMetadata> get(ProjectComponentIdentifier project) {
        return metadata.get(project);
    }

    @Override
    public void discardAll() {
        metadata.clear();
    }

        if (resolvedPaths == null) {
            throw new GradleException("Build outputs have not been resolved yet");
        }
        return resolvedPaths;
    }

    @Override
    public void discardAll() {
        resolvedPaths = null;
        outputs.clear();
    }

            subProjects.get(loopProject.getPath()).remove(project);
            loopProject = loopProject.getParentIdentifier();
        }
        return project;
    }

    @Override
    public void discardAll() {
        projects.clear();
        subProjects.clear();
    }

    private void addProjectToParentSubProjects(T project) {
        ProjectIdentifier loopProject = project.getParentIdentifier();

        ProjectState projectState = projectStateRegistry.stateFor(projectId);
        return new ResolvingCalculator(projectState, projectArtifact);
    }

    @Override
    public void discardAll() {
        allResolvedArtifacts.clear();
    }

    private static class ResolvingCalculator implements ValueCalculator<File> {
        private final ProjectState projectState;