import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
import org.jetbrains.kotlin.analysis.api.types.KtSubstitutor
import org.jetbrains.kotlin.analysis.api.types.KtType

internal class KtFe10FunctionLikeSignature<out S : KtFunctionLikeSymbol>(
    private val backingSymbol: S,
    private val backingReturnType: KtType,
    private val backingReceiverType: KtType?,

                } else {
                    className += current.name.asString()
                }
            }
            is PropertyAccessorDescriptor -> {} // Filter out property accessors
            is CallableDescriptor -> {
                if (!allowLocal) {
                    return null
                }

                localName += current.name.asString()
            }

# Check-out https://www.jetbrains.com/help/space/code-owners.html#codeowners-file-syntax
# This file is checked by org.jetbrains.kotlin.code.SpaceCodeOwnersTest
# Directive OWNER_LIST specifies possible values for owner field
# Directive UNKNOWN specifies that path is unclaimed
# Ownership must be exhaustive modulo UNKNOWN

# OWNER_LIST: Kotlin
# OWNER_LIST: "Kotlin Libraries"
# OWNER_LIST: "Kotlin JVM" "Kotlin Native" "Kotlin Wasm" "Kotlin Common Backend"

                    Variance.IN_VARIANCE -> {
                        append("in ")
                        renderType(projection.type, printer)
                    }
                    Variance.OUT_VARIANCE -> {
                        append("out ")
                        renderType(projection.type, printer)
                    }
                }
            }
        }
    }

    }

    private fun KtAnalysisSession.getSymbolsFromImportingScope(
        scopeContext: KtScopeContext,
        fqName: FqName,
        acceptScopeKind: KClass<out KtScopeKind>,
    ): Collection<KtDeclarationSymbol> {
        val importingScope = scopeContext.getCompositeScope { acceptScopeKind.java.isAssignableFrom(it::class.java) }

            ShortenStrategy.SHORTEN_AND_IMPORT -> EXPLICIT
            ShortenStrategy.SHORTEN_AND_STAR_IMPORT -> STAR
            else -> null
        }
    }
}

private data class AvailableSymbol<out T>(
    val symbol: T,
    val importKind: ImportKind,
)

private class FirShorteningContext(val analysisSession: KtFirAnalysisSession) {
    private val firResolveSession = analysisSession.firResolveSession

        } ?: unexpectedElementError<PsiElement>(type)

        val ktTypeElementFromFirType = unwrapType(fir.psi)

        val classifiersToSkip = expression.parents.takeWhile { it != ktTypeElementFromFirType }.count()
        var classifier: FirClassLikeSymbol<*>? = fir.type.toRegularClassSymbol(session)
        repeat(classifiersToSkip) {
            classifier = classifier?.getContainingClassSymbol(session)
        }

            </array>
          </value>
        </entry>
        <entry key="$PROJECT_DIR$/js/js.translator/testData/lineNumbers">
          <value>
            <array>

            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }
    add(FirErrors.INT_LITERAL_OUT_OF_RANGE) { firDiagnostic ->
        IntLiteralOutOfRangeImpl(
            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }
    add(FirErrors.FLOAT_LITERAL_OUT_OF_RANGE) { firDiagnostic ->
        FloatLiteralOutOfRangeImpl(
            firDiagnostic as KtPsiDiagnostic,