forQualifiedType -> expression.parent?.takeIf { it is KtUserType && it.referenceExpression === expression }
            else -> expression.getQualifiedExpressionForSelector()
        }
        return when (qualified) {
            null -> FqName(expression.getReferencedName())
            else -> {
                val refs =

                    is KotlinJvmBinarySourceElement -> JvmClassName.byClassId(containerSource.binaryClass.classId)
                    else -> null
                }?.fqNameForClassNameWithoutDollars?.asString()
            }
            else -> {
                return if (containingSymbolOrSelf.symbolKind == KtSymbolKind.TOP_LEVEL) {
                    descriptor?.let(DescriptorToSourceUtils::getContainingFile)

    fun typeConversion(type: KType): String {
        val nullableSuffix = if (type.isMarkedNullable) "?" else ""
        val simpleName = if (shouldRenderFqName(type)) {
            type.qualifiedName
        } else {
            type.simpleName
        }
        return if (type.arguments.isEmpty()) simpleName + nullableSuffix
        else simpleName + type.arguments.joinToString(separator = ", ", prefix = "<", postfix = ">") {

        }

        val parameterCount = declaration.valueParameters.size + (if (declaration.isExtensionDeclaration()) 1 else 0)

        val function = when {
            declaration.hasModifier(KtTokens.SUSPEND_KEYWORD) -> analysisContext.builtIns.getSuspendFunction(parameterCount)
            else -> analysisContext.builtIns.getFunction(parameterCount)
        }

                    is IntersectionTypeConstructor -> typeConstructor.supertypes.flatMapTo(mutableSetOf()) { it.collectLowerBounds() }
                    else -> setOf(this)
                }

            }
            else -> return emptySet()
        }
    }

    private fun KotlinType.collectUpperBounds(): Set<KotlinType> {
        when (this) {

            .mapIndexedToAnnotationApplication(useSiteTargetFilter, builder.rootSession, classId) { index, annotation ->
                annotation.asKtAnnotationApplicationForTargetAnnotation(builder, index)
            }
    } else if (classId == JvmStandardClassIds.Annotations.Java.Target && firSymbol.fir.resolvePhase < FirResolvePhase.ANNOTATION_ARGUMENTS) {
        annotationContainer.resolvedAnnotationsWithClassIds(firSymbol)

            is KtCompositeTypeScope -> KtCompositeScope.create(scope.subScopes.map(::getDeclarationScope), token)
            else -> unexpectedElementError<KtTypeScope>(scope)
        }
    }

            is ConeSubstitutorByMap -> KtFirMapBackedSubstitutor(coneSubstitutor, analysisSession.firSymbolBuilder)
            else -> KtFirGenericSubstitutor(coneSubstitutor, analysisSession.firSymbolBuilder)
        }
    }

    fun findPsi(fir: FirDeclaration): PsiElement? {
        return when (fir) {
            is FirSimpleFunction -> provideSourceForInvokeFunction(fir)
            is FirClass -> provideSourceForFunctionClass(fir)
            else -> null
        }
    }

    private fun provideSourceForInvokeFunction(function: FirSimpleFunction): PsiElement? {
        val classId = function.containingClassLookupTag()?.classId ?: return null

            val receiverParameter = firCallableSymbol.receiverParameter
            return if (receiverParameter?.annotations?.isEmpty() != false) {
                KtEmptyAnnotationsList(builder.token)
            } else {
                KtFirAnnotationListForReceiverParameter(firCallableSymbol, receiverParameter, builder)
            }
        }
    }