}

    @Test
    @TestMetadata("innerType_constructor.kt")
    public void testInnerType_constructor() {
      runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/nameReference/innerType_constructor.kt");
    }

    @Test
    @TestMetadata("innerType_constructor_invalid.kt")
    public void testInnerType_constructor_invalid() {

            return if (indexOfParameterizedType < 0 || innerTypesAsList.size == 1) {
                val classifier = type.constructor.declarationDescriptor as? ClassifierDescriptorWithTypeParameters
                    ?: throw IllegalArgumentException(type.toString())

                NestedType(PossiblyInnerType(classifier, type.arguments, null), emptyList())

  }

  @Test
  @TestMetadata("class_object_constructor.kt")
  public void testClass_object_constructor() {
    runTest("analysis/analysis-api/testData/components/psiTypeProvider/psiType/forExpression/class_object_constructor.kt");
  }

  @Test
  @TestMetadata("errorType.kt")
  public void testErrorType() {

    private fun <T> visitValueParameterReference(
        valueParameterReference: ConeValueParameterReference,
        constructor: (KtParameterSymbol) -> T
    ): T = constructor(
        if (valueParameterReference.parameterIndex == -1) firFunctionSymbol.receiverParameter
            ?: errorWithAttachment("${firFunctionSymbol::class} should contain a receiver") {

internal val MemberDescriptor.ktSymbolKind: KtSymbolKind
    get() {
        return when (this) {
            is PropertyAccessorDescriptor -> KtSymbolKind.ACCESSOR
            is SamConstructorDescriptor -> KtSymbolKind.SAM_CONSTRUCTOR
            else -> when (containingDeclaration) {
                is PackageFragmentDescriptor -> KtSymbolKind.TOP_LEVEL
                is ClassDescriptor -> KtSymbolKind.CLASS_MEMBER

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

internal class KtDiagnosticConverterBuilder private constructor() {
    private val conversions = mutableMapOf<AbstractKtDiagnosticFactory, KtFirDiagnosticCreator>()

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

 * for more information.
 */
@OptIn(KtAnalysisApiInternals::class, KtAnalysisNonPublicApi::class)
@Suppress("AnalysisApiMissingLifetimeCheck")
internal class KtFirAnalysisSession
private constructor(
    val project: Project,
    val firResolveSession: LLFirResolveSession,
    token: KtLifetimeToken,
) : KtAnalysisSession(token) {

    }

    @Test
    @TestMetadata("constructor.kt")
    public void testConstructor() {
      runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/callableReferences/constructor.kt");
    }

    @Test
    @TestMetadata("genericParameterType.kt")
    public void testGenericParameterType() {

                when (val typeConstructor = unwrappedType.constructor) {
                    is NewTypeVariableConstructor -> renderTypeVariableType(typeConstructor, printer)
                    is IntersectionTypeConstructor -> renderIntersectionType(typeConstructor, printer)
                    else -> {
                        val descriptor = unwrappedType.constructor.declarationDescriptor

    private fun <T> visitVariableReference(
        variableReference: VariableReference,
        constructor: (KtParameterSymbol) -> T
    ): T = constructor(variableReference.descriptor.toKtSymbol(analysisContext) as KtParameterSymbol)