}
        else -> arguments.any { typeProjection ->
            // A star projection type (lazily) built by type parameter will be yet another type with a star projection,
            // resulting in stack overflow if we keep checking allowed type parameter descriptors
            !typeProjection.isStarProjection &&
                    typeProjection.type.hasReferenceOtherThan(allowedTypeParameterDescriptors)
        }
    }
}

/**

    override val analysisContext: Fe10AnalysisContext,
) : KtReceiverParameterSymbol(), KtFe10DescSymbol<ReceiverParameterDescriptor> {

    override val type: KtType
        get() = withValidityAssertion {
            descriptor.returnType?.toKtType(analysisContext) ?: error("expect return type for $descriptor")
        }

    override val owningCallableSymbol: KtCallableSymbol

internal class MissingDependencyClassImpl(
    override val type: KtType,
    firDiagnostic: KtPsiDiagnostic,
    token: KtLifetimeToken,
) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.MissingDependencyClass

internal class MissingDependencyClassInExpressionTypeImpl(
    override val type: KtType,
    firDiagnostic: KtPsiDiagnostic,
    token: KtLifetimeToken,

    override val isVal: Boolean
        get() = withValidityAssertion { !descriptor.isVar }

    override val returnType: KtType
        get() = withValidityAssertion { descriptor.type.toKtType(analysisContext) }

    override val symbolKind: KtSymbolKind
        get() = withValidityAssertion { KtSymbolKind.LOCAL }

    override val isImplicitLambdaParameter: Boolean
        get() = withValidityAssertion { false }

    override val returnType: KtType
        get() = withValidityAssertion { descriptor?.type?.toKtType(analysisContext) ?: createErrorType() }

    override val psi: PsiElement?
        get() = withValidityAssertion { null }

    override val name: Name

/compiler/testData/serialization/klib/ "Kotlin Common Backend"
/compiler/testData/type/ "Kotlin Compiler Core"
/compiler/testData/typeQualifierNickname/ "Kotlin Compiler Core"
/compiler/testData/versionRequirement/ "Kotlin JVM"
/compiler/testData/writeFlags/ "Kotlin JVM"
/compiler/testData/writeSignature/ "Kotlin JVM"
/compiler/testData/type-checker-test.kt "Kotlin Compiler Core"
/compiler/testData/type-substitutor.kt "Kotlin Compiler Core"

        const val ERROR_TYPE_TEXT = "ERROR_TYPE"
    }

    fun render(analysisContext: Fe10AnalysisContext, type: KotlinType, printer: PrettyPrinter) {
        with(analysisContext) {
            renderType(type, printer)
        }
    }

    private fun Fe10AnalysisContext.renderType(type: KotlinType, printer: PrettyPrinter) {
        renderTypeAnnotationsDebug(type, printer)

        if (actualReceiverType is KtTypeParameterType) return false

        if (type is KtTypeParameterType) {
            return type.symbol.upperBounds.all { isPossiblySuperTypeOf(it, actualReceiverType) }
        }

        val receiverExpanded = actualReceiverType.expandedClassSymbol
        val expectedExpanded = type.expandedClassSymbol

        return KtCompositeScope.create(subScopes, token)
    }

    override fun getTypeScope(type: KtType): KtTypeScope {
        require(type is KtFe10Type)
        TODO()
    }

    override fun getSyntheticJavaPropertiesScope(type: KtType): KtTypeScope {
        require(type is KtFe10Type)
        TODO()
    }

                 * arguments to the resolver, the resolver considers it has some explicit type arguments. Therefore, it reports that the
                 * only function matching the signature is A, because B does not have type parameters. However, actually B also matches the