if (!platform.has<JvmPlatform>()) return null

        val containingSymbolOrSelf = symbol.containingSymbolOrSelf as KtSymbolWithKind
        return when (val descriptor = containingSymbolOrSelf.getDescriptor()) {
            is DescriptorWithContainerSource -> {
                when (val containerSource = descriptor.containerSource) {
                    is FacadeClassSource -> containerSource.facadeClassName ?: containerSource.className

    override val token: KtLifetimeToken
) : KtTypeCreator(), KtFirAnalysisSessionComponent {

    override fun buildClassType(builder: KtClassTypeBuilder): KtClassType {
        val lookupTag = when (builder) {
            is KtClassTypeBuilder.ByClassId -> {
                val classSymbol = rootModuleSession.symbolProvider.getClassLikeSymbolByClassId(builder.classId)

            type.simpleName
        }
        return if (type.arguments.isEmpty()) simpleName + nullableSuffix
        else simpleName + type.arguments.joinToString(separator = ", ", prefix = "<", postfix = ">") {
            when (val typeArgument = it.type) {
                null -> "*"
                else -> typeConversion(typeArgument)
            } + nullableSuffix
        }
    }
    print(typeConversion(type))
}

) : KtScopeSubstitution(), KtFirAnalysisSessionComponent {

    @OptIn(KtAnalysisApiInternals::class)
    override fun getDeclarationScope(scope: KtTypeScope): KtScope {
        return when (scope) {
            is KtFirDelegatingTypeScope -> KtFirDelegatingNamesAwareScope(scope.firScope, analysisSession.firSymbolBuilder)

                check(ktType is KtFirType)
                put(ktTypeParameterSymbol.firSymbol, ktType.coneType)
            }
        }

        return when (val coneSubstitutor = ConeSubstitutorByMap.create(firSubstitution, analysisSession.useSiteSession)) {
            is ConeSubstitutorByMap -> KtFirMapBackedSubstitutor(coneSubstitutor, analysisSession.firSymbolBuilder)

//todo introduce LibraryModificationTracker based cache?
internal object FirSyntheticFunctionInterfaceSourceProvider {
    fun findPsi(fir: FirDeclaration): PsiElement? {
        return when (fir) {
            is FirSimpleFunction -> provideSourceForInvokeFunction(fir)
            is FirClass -> provideSourceForFunctionClass(fir)
            else -> null
        }
    }

    override fun getCallableSymbols(nameFilter: KtScopeNameFilter): Sequence<KtCallableSymbol> = withValidityAssertion {
        super.getCallableSymbols(nameFilter).filter { symbol ->
            when (symbol) {
                is KtFunctionSymbol -> !symbol.isStatic
                is KtPropertySymbol -> !symbol.isStatic
                else -> true
            }
        }
    }
}

                    ?: analysisSession.useSiteScopeDeclarationProvider.getTopLevelKotlinClassLikeDeclarationNamesInPackage(packageFqName)
            )

            when {
                analysisSession.targetPlatform.isJvm() -> {
                    val psiPackage = PsiPackageImpl(PsiManager.getInstance(analysisSession.project), packageFqName.asString())

          <package name="javax.swing" withSubpackages="false" static="false" />
        </value>
      </option>
    </JavaCodeStyleSettings>
    <JetCodeStyleSettings>
      <option name="LINE_BREAK_AFTER_MULTILINE_WHEN_ENTRY" value="false" />
      <option name="ALLOW_TRAILING_COMMA" value="true" />
      <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
    </JetCodeStyleSettings>
    <MarkdownNavigatorCodeStyleSettings>

repository for all Gradle builds. Gradle will check hashes (md5 and sha256) of used dependencies and will fail builds with
`Dependency verification failed` errors when local artifacts are absent or have different hashes listed in the
[verification-metadata.xml](https://github.com/JetBrains/kotlin/blob/master/gradle/verification-metadata.xml) file.