when (type) {
            is FlexibleType -> return getUpperBounds(type.upperBound)
            is DefinitelyNotNullType -> return getUpperBounds(type.original)
            is ErrorType -> return emptyList()
            is CapturedType -> return type.constructor.supertypes.flatMap { getUpperBounds(it) }
            is NewCapturedType -> return type.constructor.supertypes.flatMap { getUpperBounds(it) }

        val userType = expression.parent as? KtUserType ?: return expression
        val typeReference = userType.parent as? KtTypeReference ?: return expression
        val constructorCalleeExpression = typeReference.parent as? KtConstructorCalleeExpression ?: return expression
        return if (constructorCalleeExpression.parent is KtSuperTypeCallEntry) constructorCalleeExpression else expression
    }

        val ktFile = descriptor?.let(DescriptorToSourceUtils::getContainingFile) ?: return null
        with(analysisSession) {
            return ktFile.getFileSymbol()
        }
    }

    override fun getContainingJvmClassName(symbol: KtCallableSymbol): String? {
        val platform = getContainingModule(symbol).platform
        if (!platform.has<JvmPlatform>()) return null

        if (this === other) return true
        if (javaClass != other?.javaClass) return false

        other as KtFe10VariableLikeSignature<*>

        if (backingSymbol != other.backingSymbol) return false
        if (backingReturnType != other.backingReturnType) return false
        if (backingReceiverType != other.backingReceiverType) return false

        return true
    }

    override fun hashCode(): Int {

    fun addIfMatching(arg: FirExpression) {
        if (arg !is FirQualifiedAccessExpression) return
        val callableSymbol = arg.calleeReference.toResolvedCallableSymbol() ?: return
        if (callableSymbol.containingClassLookupTag()?.classId != expectedEnumClass) return
        val identifier = callableSymbol.callableId.callableName.identifier
        transformer(identifier)?.let(::add)
    }

internal object DeclarationsInPackageProvider {
    internal fun getTopLevelClassifierNamesInPackageProvider(packageFqName: FqName, analysisSession: KtFirAnalysisSession): Set<Name> {
        return buildSet {
            addAll(
                analysisSession.symbolNamesProvider.getTopLevelClassifierNamesInPackage(packageFqName)

) : KtSubstitutorFactory(), KtFirAnalysisSessionComponent {

    override fun buildSubstitutor(builder: KtSubstitutorBuilder): KtSubstitutor {
        if (builder.mappings.isEmpty()) return KtSubstitutor.Empty(token)

        val firSubstitution = buildMap {
            builder.mappings.forEach { (ktTypeParameterSymbol, ktType) ->
                check(ktTypeParameterSymbol is KtFirTypeParameterSymbol)

  }

  @Test
  @TestMetadata("return_inside_if.kt")
  public void testReturn_inside_if() {
    runTest("analysis/analysis-api/testData/components/expressionInfoProvider/isUsedAsExpression/return_inside_if.kt");
  }

  @Test
  @TestMetadata("return_value.kt")
  public void testReturn_value() {

    companion object {
        fun create(firCallableSymbol: FirCallableSymbol<*>, builder: KtSymbolByFirBuilder): KtAnnotationsList {
            val receiverParameter = firCallableSymbol.receiverParameter
            return if (receiverParameter?.annotations?.isEmpty() != false) {
                KtEmptyAnnotationsList(builder.token)
            } else {

        // Compiler implementation does nothing.
        // Descriptor-based shortening is implemented on the IDE plugin side.
        val ktFilePointer = SmartPointerManager.createPointer(file)

        return object : ShortenCommand {
            override val targetFile: SmartPsiElementPointer<KtFile> get() = ktFilePointer
            override val importsToAdd: Set<FqName> get() = emptySet()