}
        '''
    }

    /**
     * Helper method to setup a custom task wired to the test in two ways:
     * <ol>
     *     <li>A direct dependency via dependsOn declarartion</li>
     *     <li>Via Test#binaryResultsDirectory output wired to customTask#customInput</li>
     * </ol>
     *
     * This intentional redundancy is to test automatic exclusion of direct dependsOn relationships.

// bother setting up test-ASTs manually)
import (
	`fmt`
	"math"
)

// at least one empty line between declarations of different kind
import _ "io"
var _ int

// at least one empty line between declarations of the same kind
// if there is associated documentation (was issue 2570)
type T1 struct{}
// T2 comment
type T2 struct {
} // should be a two-line struct

// bother setting up test-ASTs manually)
import (
	"fmt"
	"math"
)

// at least one empty line between declarations of different kind
import _ "io"

var _ int

// at least one empty line between declarations of the same kind
// if there is associated documentation (was issue 2570)
type T1 struct{}

// T2 comment
type T2 struct {

    /**
     * Create a Kotlin/Native declaration provider for [ktModule].
     *
     * Generally, only Kotlin/Native KLIB libraries can declare forward declarations.
     * For other types of [KtModule]s the provider normally shouldn't be created.
     *
     * @return a declaration provider for [ktModule] or `null` if the module cannot contain forward declarations
     */

    }
}

/**
 * While the main declaration provider created via [createDeclarationProvider] is scope-based, there are other declaration providers which
 * are not, such as file-based declaration providers. Not all declarations provided by such declaration providers can be provided by the
 * main declaration provider, even if the correct scope is provided (such as a file-based scope). For example, the main declaration provider

        if (kotlinFile.packageFqName != packageFqName) {
            return emptyList()
        }

        return buildList {
            for (declaration in topLevelDeclarations) {
                if (declaration is T && declaration.nameAsName == name) {
                    add(declaration)
                }
            }
        }
    }

        val context = analysisContext.analyze(ktFile)

        sequence {
            for (declaration in ktFile.declarations) {
                if (declaration is KtCallableDeclaration) {
                    val descriptor = context[BindingContext.DECLARATION_TO_DESCRIPTOR, declaration] as? CallableDescriptor ?: continue

    private fun collectDesignationPathForLocal(declaration: FirClassLikeDeclaration): List<FirClassLikeDeclaration> {
        checkWithAttachment(
            declaration.isLocal,
            message = { "${declaration::class} is not local" }
        ) {
            withFirEntry("firDeclaration", declaration)
        }
        return when (declaration) {
            is FirAnonymousObject -> listOf(declaration)

    private val returnType: String,
) {
    fun hasTheSameSignature(declaration: FirCallableSymbol<*>): Boolean = hasTheSameSignature(declaration.fir)

    fun hasTheSameSignature(declaration: FirCallableDeclaration): Boolean {
        if ((receiverType == null) != (declaration.receiverParameter == null)) return false
        if (contextReceiverTypes.size != declaration.contextReceivers.size) return false

                }
            }
        }

        val actual = executeOnPooledThreadInReadAction {
            buildString {
                mainFile.declarations.forEach { declaration ->
                    analyseForTest(declaration) {
                        append(declaration.getSymbol().render(renderer))
                        appendLine()
                        appendLine()
                    }
                }
            }