//
// Pool's purpose is to cache allocated but unused items for later reuse,
// relieving pressure on the garbage collector. That is, it makes it easy to
// build efficient, thread-safe free lists. However, it is not suitable for all
// free lists.
//
// An appropriate use of a Pool is to manage a group of temporary items
// silently shared among and potentially reused by concurrent independent

        private final List<DefaultExcludesLocation> locations

        private final ScriptLanguage scriptLanguage

        private final List<TestFile> excludedFiles = new ArrayList<>()

        private final List<TestFile> excludedFilesCopies = new ArrayList<>()

        private final List<TestFile> includedFiles = new ArrayList<>()

        private final List<TestFile> includedFilesCopies = new ArrayList<>()

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

public class FetchParameterizedCustomModelForEachProject implements BuildAction<Map<String, List<SomeToolingModel>>> {

    private final List<String> parameters;

    public FetchParameterizedCustomModelForEachProject(List<String> parameters) {
        this.parameters = parameters;
    }

    @Override

			return n.Pos()
		}
	}
}

func lastDecl(list []Decl) Decl {
	if l := len(list); l > 0 {
		return list[l-1]
	}
	return nil
}

func lastExpr(list []Expr) Expr {
	if l := len(list); l > 0 {
		return list[l-1]
	}
	return nil
}

func lastStmt(list []Stmt) Stmt {
	if l := len(list); l > 0 {
		return list[l-1]
	}
	return nil
}

import java.util.List;
import java.util.Set;

class RootNode extends NodeState implements RootGraphNode {
    private final ResolveOptimizations resolveOptimizations;
    private final List<? extends DependencyMetadata> syntheticDependencies;

import org.gradle.tooling.model.gradle.GradleBuild;

import java.util.ArrayList;
import java.util.List;

public class FetchPartialCustomModelForEachProject implements BuildAction<List<String>> {
    @Override
    public List<String> execute(BuildController controller) {
        List<String> result = new ArrayList<>();
        GradleBuild buildModel = controller.getBuildModel();

    }

    private fun <L> MutableList<List<L>>.combinations(list: List<L>, state: PersistentList<L>, size: Int) {
        if (size == 0) {
            add(state)
        } else {
            for (e in list) {
                combinations(list, state.add(e), size - 1)
            }
        }
    }

import org.gradle.internal.cc.impl.AbstractConfigurationCacheIntegrationTest

abstract class SystemPropertyInjection extends BuildInputInjection {
    List<String> getGradleArgs() {
        return []
    }

    static List<SystemPropertyInjection> all(String prop, String value) {
        return [
            commandLine(prop, value),
            gradleProperties(prop, value),

            ?: errorWithFirSpecificEntries("Class was not found", coneType = coneType)
    }
    override val typeArguments: List<KaTypeProjection> get() = withValidityAssertion { qualifiers.last().typeArguments }

    override val qualifiers: List<KaClassTypeQualifier.KaResolvedClassTypeQualifier> by cached {
        UsualClassTypeQualifierBuilder.buildQualifiers(coneType, builder)
    }

    identityPath: Path,
    val rootProjectName: String,
    val projects: List<CachedProjectState>
) : CachedBuildState(identityPath)


/**
 * A build in the tree with work scheduled.
 */
internal
class BuildWithWork(
    identityPath: Path,
    val build: ConfigurationCacheBuild,
    rootProjectName: String,
    projects: List<CachedProjectState>,
    val workGraph: ScheduledWork