return true
        }

        val aConstructor = a.constructor
        val bConstructor = b.constructor

        if (aConstructor is IntersectionTypeConstructor) {
            return aConstructor.supertypes.all { areTypesCompatible(it, b) }
        }

        if (bConstructor is IntersectionTypeConstructor) {
            return bConstructor.supertypes.all { areTypesCompatible(a, it) }
        }

        // If we are at a super-type constructor call, adjust the resolution expression so that we
        // get the constructor instead of the class.
        //
        // For the example:
        //
        // class A {
        //   constructor()
        // }
        // class B: <caret>A()
        //
        // We want to resolve to the secondary constructor in A. Therefore, we check that the caret is at a supertype

import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
import org.jetbrains.kotlin.name.ClassId

internal class KtFirAnnotationListForReceiverParameter private constructor(
    private val firCallableSymbol: FirCallableSymbol<*>,
    private val receiverParameter: FirAnnotationContainer,
    private val builder: KtSymbolByFirBuilder,
) : KtAnnotationsList() {

                scopeSession,
                stubBodyResolveTransformer,
                stubBodyResolveTransformer.context,
            )

        // TODO: this doesn't guarantee that the same synthetic function (as a SAM constructor) is created/returned
        fun getSamConstructor(firClass: FirRegularClass): FirSimpleFunction? {
            val samConstructor = bodyResolveComponents.samResolver.getSamConstructor(firClass) ?: return null

            val bindingContext = analysisContext.analyze(declaration)
            val kotlinType = bindingContext[BindingContext.CONSTRUCTOR, declaration]?.returnType
                ?: ErrorUtils.createErrorType(
                    ErrorTypeKind.RETURN_TYPE_FOR_CONSTRUCTOR, declaration.containingClass()?.name ?: "<unknown>"
                )
            return kotlinType.toKtType(analysisContext)
        }

    }

    @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() {

        require(this is SimpleType)
        val declaration = constructor.declarationDescriptor
        return declaration is FunctionClassDescriptor && declaration.functionTypeKind.isSuspendOrKSuspendFunction
    }

    override fun SimpleTypeMarker.isKClass(): Boolean {
        require(this is SimpleType)
        return constructor.declarationDescriptor == builtIns.kClass
    }

            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() {

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