return new RealisedConfigurationMetadata(
            getComponentId(),
            getName(),
            isTransitive(),
            isVisible(),
            getHierarchy(),
            getArtifacts(),
            getExcludes(),
            getAttributes(),
            getCapabilities(),
            dependencies,
            addedByRule,

                ?: findFirstUseSiteElement(mainFile)
                ?: error("Cannot find use-site element to check visibility at.")

            val useSiteFileSymbol = mainFile.getFileSymbol()

            val visible = isVisible(declarationSymbol, useSiteFileSymbol, null, useSiteElement)
            """
                Declaration: ${(declarationSymbol as KaDeclarationSymbol).render(KaDeclarationRendererForDebug.WITH_QUALIFIED_NAMES)}

                testResources.from(sourceSet.resources.srcDirs)
            }
        }
    }
}


private
fun Project.bucket(name: String, description: String) = configurations.create(name) {
    isVisible = false
    isCanBeResolved = false
    isCanBeConsumed = false
    this.description = description
}


private

internal class KaFirOverrideInfoProvider(
    override val analysisSession: KaFirSession,
    override val token: KaLifetimeToken,
) : KaOverrideInfoProvider(), KaFirSessionComponent {

    override fun isVisible(memberSymbol: KaCallableSymbol, classSymbol: KaClassOrObjectSymbol): Boolean {
        require(memberSymbol is KaFirSymbol<*>)
        require(classSymbol is KaFirSymbol<*>)

     * - Artifact exclusions apply to artifacts obtained from this configuration
     */
    ImmutableList<ExcludeMetadata> getExcludes();

    boolean isTransitive();

    boolean isVisible();

    boolean isCanBeConsumed();

    /**
     * Find the component artifact with the given IvyArtifactName, creating a new one if none matches.
     *

        encoder.writeBoolean(derivedVariant.isTransitive());
        encoder.writeBoolean(derivedVariant.isVisible());
        writeStringSet(encoder, derivedVariant.getHierarchy());
        writeMavenExcludeRules(encoder, derivedVariant.getExcludes());
        writeDependencies(encoder, derivedVariant, deduplicationDependencyCache);

            buildStatusArea.redraw(ansiContext);
            // When build output area is not visible, position the cursor at the end of the output area
            if (!buildStatusArea.isVisible()) {
                ansiContext.cursorAt(buildOutputArea.getWritePosition());
            }
        }
    };
    private final Flushable flushable;

    id("gradlebuild.kotlin-experimental-contracts")
}

description = "Configuration cache implementation"

val configurationCacheReportPath by configurations.creating {
    isVisible = false
    isCanBeConsumed = false
    attributes { attribute(DocsType.DOCS_TYPE_ATTRIBUTE, objects.named("configuration-cache-report")) }
}

                        metadata.getId(),
                        sourceVariant.getName(),
                        sourceVariant.isTransitive(),
                        sourceVariant.isVisible(),
                        sourceVariant.getHierarchy(),
                        Cast.uncheckedCast(sourceVariant.getArtifacts()),
                        sourceVariant.getExcludes(),

}

tasks.withType<Test>().configureEach {
    shouldRunAfter(codeQuality)
}
tasks.check {
    dependsOn(codeQuality)
}

val rules by configurations.creating {
    isVisible = false
    isCanBeConsumed = false

    attributes {
        attribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, objects.named(LibraryElements.RESOURCES))
    }
}