collect(result, c)
        return result
    }

    private void collect(Set<CtMethod> result, CtClass c) {
        if (c == null) {
            return
        }

        result.addAll(c.declaredMethods.findAll { isPublicApi(it) })

        collect(result, c.superclass)
    }

    private boolean isPublicApi(CtMethod method) {

                }
        }
        return versionsToIncubating
    }

    private
    fun CompilationUnit.findAllIncubating() =
        findAll(Node::class.java).filter { it.isIncubating }

    private
    val Node.isIncubating: Boolean
        get() = (this as? NodeWithAnnotations<*>)?.annotations?.any { it.nameAsString == "Incubating" } ?: false

    def transformWebsiteLinks(Document doc) {
        findAll(doc, 'ulink').each { Element element ->
            String url = element.'@url'
            if (url.startsWith('website:')) {
                url = url.substring(8)
                url = "${websiteUrl.get()}/${url}"
                element.setAttribute('url', url)
            }
        }
    }

    static def findAll(Document doc, String byName) {

     */
    public Set<String> getPropertyNames() {
        Set<String> propertyNames = new TreeSet<String>();
        propertyNames.addAll(declaredProperties.keySet());
        ClassMetaData superClass = getSuperClass();
        if (superClass != null) {
            propertyNames.addAll(superClass.getPropertyNames());
        }
        return propertyNames;
    }

    private PropertyMetaData getProperty(String name) {

    }

    Map<String, String> get() {
        if (acceptedViolations == null) {
            acceptedViolations = AcceptedApiChanges.parse(
                acceptedViolationsDir.listFiles()
                    .findAll { it.name.endsWith(".json") }
                    .collect { it.text }
            ).toAcceptedChangesMap()
        }
        return acceptedViolations
    }

        }
        val prs: MutableList<GitHubPullRequest> = mutableListOf()
        for (page in 1..10) {
            val prPage = getMergedContributorPullRequests(page)
            prs.addAll(prPage)
            if (prPage.size < PAGE_SIZE) {
                break
            }
        }
        return prs
            .filter { it.milestone?.title?.startsWith(milestone.get()) == true }

            for (File jsonFile : jsonFiles) {
                getLogger().info("Verifying documentation for file: {}", jsonFile.getName());
                allErrors.addAll(findMissingAdocFiles(jsonFile, directoryPath));
                allErrors.addAll(findMissingAnchors(jsonFile, allExistingAnchors));
            }

            if (!allErrors.isEmpty()) {

    compilerOptions {
        allWarningsAsErrors = true
        apiVersion = KotlinVersion.KOTLIN_2_2
        languageVersion = KotlinVersion.KOTLIN_2_2
        freeCompilerArgs.addAll(
            "-Xjsr305=strict",
            "-Xjspecify-annotations=strict",
            "-java-parameters",
            "-Xsam-conversions=class",
        )
    }
}

                    JvmTarget.fromTarget(if (it < 9) "1.${it}" else it.toString())
                }

                // TODO KT-49746: Use the DSL to set the release version
                freeCompilerArgs.addAll(useRelease().zip(jvmTarget) { doUseRelease, targetVersion ->
                    if (doUseRelease) {
                        listOf("-Xjdk-release=${targetVersion.target}")
                    } else {

    val seen = mutableSetOf<ResolvedVariantResult>()
    val queue = ArrayDeque<DependencyResult>()

    val rootDependencies = rootComponent.getDependenciesForVariant(rootVariant)
    seen.add(rootVariant)
    queue.addAll(rootDependencies)

    while (queue.isNotEmpty()) {
        val dependency = when (val result = queue.removeFirst()) {
            is ResolvedDependencyResult -> result