is FirAbstractSimpleImportingScope -> EXPLICIT
                else -> LOCAL
            }
        }

        fun fromShortenOption(option: ShortenStrategy): ImportKind? = when (option) {
            ShortenStrategy.SHORTEN_AND_IMPORT -> EXPLICIT
            ShortenStrategy.SHORTEN_AND_STAR_IMPORT -> STAR
            else -> null
        }
    }
}

private data class AvailableSymbol<out T>(

    is KtFakeSourceElement -> if (source.kind in allowedFakeElementKinds) psi else null
    else -> null
}

fun FirElement.findPsi(): PsiElement? =
    getAllowedPsi()

fun FirBasedSymbol<*>.findPsi(): PsiElement? {
    return if (this is FirCallableSymbol<*>) {
        fir.unwrapFakeOverridesOrDelegated().findPsi()
    } else {
        fir.findPsi()
    } ?: FirSyntheticFunctionInterfaceSourceProvider.findPsi(fir)
}

                    else -> {
                        val descriptor = unwrappedType.constructor.declarationDescriptor
                        if (descriptor is TypeParameterDescriptor) {
                            renderTypeParameterType(descriptor, printer)
                        } else if (descriptor is ClassifierDescriptorWithTypeParameters) {

                when (firDeclaration) {
                    is FirSimpleFunction -> firDeclaration.name
                    is FirProperty -> firDeclaration.name
                    else -> null
                }
            }

        result
    }

    override fun getPossibleCallableNames(): Set<Name> = withValidityAssertion { _callableNames }

                        BooleanConstantReference.FALSE -> KtContractConstantType.FALSE
                        else -> error("Can't convert $value to the Analysis API")
                    },
                    analysisContext.token
                )
            )
            else -> error("Can't convert $returnsEffect to the Analysis API")
        }

        with(analysisSession) {
            referenceTargetSymbols.flatMap { symbol ->
                when (symbol) {
                    is KtFirSymbol<*> -> getPsiDeclarations(symbol)
                    else -> listOfNotNull(symbol.psi)
                }
            }
        }

    fun getResolvedToPsi(analysisSession: KtAnalysisSession): Collection<PsiElement> =
        with(analysisSession) {

        return if (resolveResult.receiverClassReference != null) {
            findParentSymbol(resolveResult.receiverClassReference, goBackSteps - 1, selectedFqName)
        } else {
            findParentSymbol(resolveResult.symbol, goBackSteps, selectedFqName)
        }
    }

    /**

            }
        }


        private fun DeclarationDescriptor.isDeclaredInOwner() = when (this) {
            is CallableDescriptor -> dispatchReceiverParameter?.containingDeclaration == owner
            else -> containingDeclaration == owner
        }
    }

    override fun getEmptyScope(): KtScope {
        return KtEmptyScope(token)
    }

    override fun getFileScope(fileSymbol: KtFileSymbol): KtScope {

            analysisContext.resolveSession.moduleDescriptor.findClassAcrossModuleDependencies(outerClassId)
                ?.unsubstitutedMemberScope
                ?: MemberScope.Empty
        } else {
            analysisContext.resolveSession.moduleDescriptor.getPackage(callableId.packageName).memberScope
        }

        @Suppress("UNCHECKED_CAST")
        return memberScope

        }

    override val backingFieldSymbol: KtBackingFieldSymbol?
        get() = withValidityAssertion {
            if (psi.isLocal) null
            else KtFe10PsiDefaultBackingFieldSymbol(propertyPsi = psi, owningProperty = this, analysisContext)
        }

    override val hasBackingField: Boolean
        get() = withValidityAssertion {