return null;
        }

        @Override
        public List<Throwable> getFailures() {
            return failures;
        }

        @Override
        public RuntimeException getFailureOrNull() {
            return getFailure();
        }

        @Override
        public RuntimeException getFailure() {
            if (failures.size() == 1 && failures.get(0) instanceof RuntimeException) {

        }
        finishFailures.addAll(finishResult.getFailures());
        boolean failed = reportableFailure != null;

        // These should run concurrently
        buildStateRegistry.visitBuilds(buildState -> {
            ExecutionResult<Void> result = buildState.beforeModelDiscarded(failed);
            finishFailures.addAll(result.getFailures());
        });

        artifactSetResolver.visitArtifacts(getSelectedArtifacts().getArtifacts(), visitor, resolutionHost);
        resolutionHost.rethrowFailure("files", visitor.getFailures());
        return visitor.files;
    }

    @Override
    @Deprecated
    public Set<File> getFiles(Spec<? super Dependency> dependencySpec) {

        visitedArtifacts.select(configuration.getImplicitSelectionSpec()).visitArtifacts(visitor, false);
        resolutionHost.rethrowFailure("files", visitor.getFailures());
        return visitor.getFiles();
    }

    @Override
    @Deprecated
    public Set<File> getFiles(final Spec<? super Dependency> dependencySpec) throws ResolveException {

        selected.visitDependencies(collectingContext);
        if (!lenient) {
            resolutionHost.mapFailure("dependencies", collectingContext.getFailures()).ifPresent(context::visitFailure);
        }
    }

    @Override
    public String getDisplayName() {
        return resolutionHost.displayName("files").getDisplayName();
    }

    @Override

            fileCollection.getSelectedArtifacts().visitArtifacts(visitor, lenient);

            Set<ResolvedArtifactResult> artifactResults = visitor.getArtifacts();
            Set<Throwable> failures = visitor.getFailures();

            if (!lenient) {
                resolutionHost.rethrowFailure("artifacts", failures);
            }
            return new ArtifactSetResult(artifactResults, failures);
        });
    }

        if (matches.empty) {
            return new MeasuredOperationList(name: displayName)
        }
        assert matches.size() == 1
        buildResult(matches.first())
    }

    List<Exception> getFailures() {
        List.cast(buildResults.values().collect() {
            it.exception
        }.flatten().findAll())
    }

            modelCreator.beforeTasks(action);
            if (runTasks && isEligibleToRunTasks()) {
                ExecutionResult<Void> result = workController.scheduleAndRunRequestedTasks(null);
                if (!result.getFailures().isEmpty()) {
                    return result.asFailure();
                }
            }
            T model = modelCreator.fromBuildModel(action);
            return ExecutionResult.succeeded(model);
        });

        public ExecutionResult<Void> call(BuildOperationContext context) throws Exception {
            ExecutionResult<Void> result = delegate.execute(gradle, plan);
            if (!result.getFailures().isEmpty()) {
                context.failed(result.getFailure());
            }
            return result;
        }

        @Override
        public BuildOperationDescriptor.Builder description() {

    public long getStartTime() {
        return startTime;
    }

    @Override
    public long getEndTime() {
        return endTime;
    }

    @Override
    public List<? extends Failure> getFailures() {
        return failures;
    }