if (!model.getRepositories().isEmpty()) {
                List<String> oldRepos = request.getModelRepositoryHolder().getRepositories().stream()
                        .map(Object::toString)
                        .toList();
                request.getModelRepositoryHolder().merge(model.getRepositories(), false);
                List<String> newRepos = request.getModelRepositoryHolder().getRepositories().stream()

        final List<String> args = new ArrayList<>();
        // JVM args that must be used for the build JVM
        final List<String> buildJvmArgs = new ArrayList<>();
        // JVM args that must be used to fork a JVM
        final List<String> launcherJvmArgs = new ArrayList<>();
        // Implicit JVM args that should be used to fork a JVM
        final List<String> implicitLauncherJvmArgs = new ArrayList<>();

            memberRequiredPhase = null,
        )
            .getConstructors(analysisSession.firSymbolBuilder)
            .toList()
    }

    private fun FirResolvedQualifier.toKtCalls(constructors: List<KaConstructorSymbol>): List<KaCall> {
        analysisSession.apply {
            return constructors.map { constructor ->

    override val starImportsToAdd: Set<FqName>,
    override val listOfTypeToShortenInfo: List<TypeToShortenInfo>,
    override val listOfQualifierToShortenInfo: List<QualifierToShortenInfo>,
    override val thisLabelsToShorten: List<ThisLabelToShortenInfo>,
    override val kDocQualifiersToShorten: List<SmartPsiElementPointer<KDocName>>,
) : ShortenCommand

private fun KtUserType.hasFakeRootPrefix(): Boolean =

                shouldCount.set(false)
                doLast {
                    println("Service not used")
                }
            }
        """

        when:
        run("unused")

        then:
        output.count("service:") == 0
        output.count("Service not used") == 1
    }

    def "can use service from task doFirst() or doLast() action"() {
        serviceImplementation()

        def configurationCache = newConfigurationCacheFixture()

        buildFile << """
            task broken {
                doLast {
                    println("project = " + project.name)
                }
            }
            task anotherBroken {
                doLast {
                    println("configurations = " + project.configurations.all)
                }
            }

            }.files

            task resolveFilesWhenSerialized {
                def input = provider { files2*.name }
                doLast {
                    println input.get()
                }
            }

            task usesFiles2 {
                doLast {
                    println files2*.name
                }
            }
        """

        when:

import org.apache.maven.model.v4.MavenTransformer;

/**
 */
@Named
@Singleton
public class DefaultModelValidator implements ModelValidator {

    public static final List<String> VALID_MODEL_VERSIONS =
            Collections.unmodifiableList(Arrays.asList("4.0.0", "4.1.0"));

    private static final Pattern EXPRESSION_NAME_PATTERN = Pattern.compile("\\$\\{(.+?)}");

Method <org.gradle.api.DefaultTask.doLast(groovy.lang.Closure)> has arguments/return type groovy.lang.Closure that is not Gradle public API or primitive or built-in JDK classes or Kotlin classes in (DefaultTask.java:0)