import org.jetbrains.kotlin.fir.types.ConeKotlinType
import org.jetbrains.kotlin.fir.types.customAnnotations
import org.jetbrains.kotlin.name.ClassId

internal class KaFirAnnotationListForType private constructor(
    val coneType: ConeKotlinType,
    private val builder: KaSymbolByFirBuilder,
) : AbstractList<KaAnnotation>(), KaAnnotationList {
    private val backingAnnotations: List<KaAnnotation> by lazy {

     */
    lazyArguments: Lazy<List<KaNamedAnnotationValue>>,
    index: Int?,

    /**
     * The constructor symbol into which this annotation resolves if the annotation is correctly resolved
     */
    constructorSymbol: KaConstructorSymbol?,
    override val token: KaLifetimeToken
) : KaAnnotation {

    extendsFrom(externalApi.get())
    outgoing.artifact(task)
    configureAsRuntimeElements(objects)
}

open class SoftwareComponentFactoryProvider @Inject constructor(val factory: SoftwareComponentFactory)
val softwareComponentFactory = project.objects.newInstance(SoftwareComponentFactoryProvider::class.java).factory
val gradleApiComponent = softwareComponentFactory.adhoc("gradleApi")

    override val descriptor: ConstructorDescriptor? by cached {
        val bindingContext = analysisContext.analyze(psi, AnalysisMode.PARTIAL)
        bindingContext[BindingContext.CONSTRUCTOR, psi]
    }

    override val isPrimary: Boolean
        get() = withValidityAssertion { psi is KtPrimaryConstructor }

    override val containingClassId: ClassId?

        val ktPropertySymbol = builder.variableLikeBuilder.buildPropertySymbol(propertySymbol)
        check(ktPropertySymbol is KaKotlinPropertySymbol) {
            "Unexpected symbol for primary constructor property ${ktPropertySymbol.javaClass} for fir: ${firSymbol.fir.renderWithType()}"
        }

        ktPropertySymbol
    }

                    convertArgument(it.c, this),
                    convertArgument(it.d, this)
                )
            }
        }
    }
}

internal class KaDiagnosticConverterBuilder private constructor() {
    private val conversions = mutableMapOf<AbstractKtDiagnosticFactory, KaFirDiagnosticCreator>()

    fun add(diagnostic: KtDiagnosticFactory0, creator: KaFirDiagnostic0Creator) {

import org.jetbrains.kotlin.fir.types.FirTypeRef

/**
 * **Note**: the signature doesn't contain a name. This check should be done externally.
 */
internal class FirCallableSignature private constructor(
    private val receiverType: String?,
    private val contextReceiverTypes: List<String>,
    private val parameters: List<String>?,
    private val typeParametersCount: Int,
    private val returnType: String,
) {

import org.gradle.internal.service.scopes.ServiceScope
import java.util.Optional
import javax.inject.Inject


@NonExtensible
@ServiceScope(Scope.Build::class)
open class BuildFlowScope @Inject internal constructor(
    private val flowScheduler: FlowScheduler,
    private val flowProviders: FlowProviders,
    private val flowParametersInstantiator: FlowParametersInstantiator,
    instantiatorFactory: InstantiatorFactory,

        config = configFile("codenarc-integtests.xml")
    }
}

val SourceSet.allGroovy: SourceDirectorySet
    get() = the<GroovySourceDirectorySet>()

abstract class CodeNarcRule @Inject constructor(
    private val groovyVersion: String
) : ComponentMetadataRule {
    override fun execute(context: ComponentMetadataContext) {
        context.details.allVariants {
            withDependencies {

import org.jetbrains.kotlin.analysis.api.symbols.KaTypeAliasSymbol
import org.jetbrains.kotlin.analysis.api.types.*
import org.jetbrains.kotlin.analysis.utils.printer.PrettyPrinter

public class KaTypeRenderer private constructor(
    public val expandedTypeRenderingMode: KaExpandedTypeRenderingMode,

    public val capturedTypeRenderer: KaCapturedTypeRenderer,
    public val definitelyNotNullTypeRenderer: KaDefinitelyNotNullTypeRenderer,