}

    private fun collectVirtualFilesByRoots(): List<VirtualFile> {
        val localFileSystem = kotlinCoreProjectEnvironment.environment.localFileSystem
        return buildList {
            for (root in sourceRoots) {
                val files = when {
                    root.isDirectory() -> collectSourceFilePaths(root)
                    root.hasSuitableExtensionToAnalyse() -> listOf(root)
                    else -> emptyList()

    private
    fun gradleKotlinDslImports() =
        listOf(
            "org.gradle.kotlin.dsl.*",
            // TODO: let this be contributed by :plugins
            "org.gradle.kotlin.dsl.plugins.dsl.*",
            // TODO: infer list of types below at build time by inspecting the Gradle API
            "java.util.concurrent.Callable",

    }

    override fun collectImportsForDiagnosticParameter(diagnosticParameter: HLDiagnosticParameter): Collection<String> =
        diagnosticParameter.importsToAdd

    override val defaultImports = listOf(
        "org.jetbrains.kotlin.diagnostics.KtPsiDiagnostic",
        "org.jetbrains.kotlin.fir.builder.FirSyntaxErrors",
        "org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors",

    val intersectionOverriddenSymbolsOrSingle = when {
        symbol.origin == KaSymbolOrigin.INTERSECTION_OVERRIDE && symbol is KaCallableSymbol -> symbol.getIntersectionOverriddenSymbols()
        else -> listOf(symbol)
    }
    return intersectionOverriddenSymbolsOrSingle.mapNotNull { it.findPsiForReferenceResolve() }
}

private fun KaSymbol.findPsiForReferenceResolve(): PsiElement? {
    require(this is KaFirSymbol<*>)

 */
internal
class TypeDiscoveryFromRestrictedFunctions : AnalysisSchemaComponent {
    override fun typeDiscovery(): List<TypeDiscovery> = listOf(
        FunctionLambdaTypeDiscovery(isPublicAndRestricted, gradleConfigureLambdas),
        FunctionReturnTypeDiscovery(isPublicAndRestricted)
    )
}


private
class FunctionLambdaTypeDiscovery(

import org.junit.jupiter.api.Test
import kotlin.test.assertIs
import kotlin.test.assertNotNull
import kotlin.test.assertTrue


val schema = schemaFromTypes(
    topLevelReceiver = TopLevelScope::class,
    types = listOf(TopLevelScope::class, PluginsBlock::class, PluginDefinition::class)
)


fun main() {
    val result = schema.resolve(
        """
        plugins {
            val kotlinVersion = "1.9.20"

        assertEquals(1, (xAssigned.objectOrigin.originElement as Literal.IntLiteral).value)
    }

    val schema = schemaFromTypes(Receiver::class, listOf(Receiver::class))

    private
    interface Receiver {
        @get:Restricted
        var x: Int

        @get:Restricted
        var y: Int
    }

}
// end::enable-checkstyle-sarif-report[]
// end::customize-checkstyle-report[]

// tag::customize-pmd[]
pmd {
    isConsoleOutput = true
    toolVersion = "7.0.0"
    rulesMinimumPriority = 5
    ruleSets = listOf("category/java/errorprone.xml", "category/java/bestpractices.xml")
}
// end::customize-pmd[]

// tag::pmd-threads[]
pmd {
    threads = 4
}

    id: String,
    name: String,
    description: String,
    val testCoverage: TestCoverage,
    stage: Stage,
    parallelizationMethod: ParallelizationMethod = ParallelizationMethod.None,
    subprojects: List<String> = listOf(),
    extraParameters: String = "",
    maxParallelForks: String = "%maxParallelForks%",
    extraBuildSteps: BuildSteps.() -> Unit = {},
    preBuildSteps: BuildSteps.() -> Unit = {}

    settings: SettingsInternal,
    targetScope: ClassLoaderScope,
    scriptSource: ScriptSource,
    softwareTypeRegistry: SoftwareTypeRegistry
): InterpretationSequence =
    DefaultInterpretationSequence(
        listOf(
            SimpleInterpretationSequenceStepWithConversion("settingsPluginManagement", features = setOf(SettingsBlocksCheck.feature)) { pluginManagementEvaluationSchema() },