<component name="ProjectRunConfigurationManager">
  <configuration default="false" name="Symbol Light Classes Tests" type="GradleRunConfiguration" factoryName="Gradle" folderName="Analysis">
    <ExternalSystemSettings>
      <option name="executionName" />
      <option name="externalProjectPath" value="$PROJECT_DIR$" />
      <option name="externalSystemIdString" value="GRADLE" />
      <option name="scriptParameters" value="" />
      <option name="taskDescriptions">

    override fun getContainingDeclaration(symbol: KtSymbol): KtDeclarationSymbol? {
        if (symbol is KtSymbolWithKind && symbol.symbolKind == KtSymbolKind.TOP_LEVEL) {
            return null
        }

        return when (symbol) {
            is KtBackingFieldSymbol -> symbol.owningProperty
            is KtPropertyAccessorSymbol -> {

                classSymbol.toLookupTag()
            }
            is KtClassTypeBuilder.BySymbol -> {
                val symbol = builder.symbol
                check(symbol is KtFirSymbol<*>)
                (symbol.firSymbol as FirClassLikeSymbol<*>).toLookupTag()
            }
        }

        val typeContext = rootModuleSession.typeContext

        } else {
            findParentSymbol(resolveResult.symbol, goBackSteps, selectedFqName)
        }
    }

    /**
     * Finds the parent symbol of the given KtSymbol by traversing back up the symbol hierarchy a certain number of steps,
     * or until the containing class or object symbol is found.
     *
     * @param symbol The KtSymbol whose parent symbol needs to be found.

    override fun getDeprecation(symbol: KtSymbol): DeprecationInfo? {
        if (symbol is KtFirPackageSymbol || symbol is KtReceiverParameterSymbol) return null
        require(symbol is KtFirSymbol<*>) { "${this::class}" }

        // Optimization: Avoid building `firSymbol` of `KtFirPsiJavaClassSymbol` if it definitely isn't deprecated.
        if (symbol is KtFirPsiJavaClassSymbol && !symbol.mayHaveDeprecation()) {
            return null

}

internal fun KtAnalysisSession.getPsiDeclarations(symbol: KtFirSymbol<*>): Collection<PsiElement> {
    val intersectionOverriddenSymbolsOrSingle = when {
        symbol.origin == KtSymbolOrigin.INTERSECTION_OVERRIDE && symbol is KtCallableSymbol -> symbol.getIntersectionOverriddenSymbols()
        else -> listOf(symbol)
    }

    }

    override fun unwrapFakeOverrides(symbol: KtCallableSymbol): KtCallableSymbol {
        val callableDescriptor = getSymbolDescriptor(symbol) as? CallableMemberDescriptor ?: return symbol
        val originalCallableDescriptor = callableDescriptor.findOriginalTopMostOverriddenDescriptors().firstOrNull() ?: return symbol
        return originalCallableDescriptor.toKtCallableSymbol(analysisContext) ?: symbol
    }

        val platform = getContainingModule(symbol).platform
        if (!platform.has<JvmPlatform>()) return null

        val containingSymbolOrSelf = when (symbol) {
            is KtValueParameterSymbol -> {
                getContainingDeclaration(symbol) as? KtFunctionLikeSymbol ?: symbol
            }
            is KtPropertyAccessorSymbol -> {

            }
        }

    private val KtFunctionCall<*>.descriptor: DeclarationDescriptor?
        get() = when (val symbol = symbol) {
            is KtFe10PsiSymbol<*, *> -> symbol.descriptor
            is KtFe10DescSymbol<*> -> symbol.descriptor
            else -> null
        }

    private fun KtCallInfo?.toKtCallCandidateInfos(): List<KtCallCandidateInfo> {
        return when (this) {

   /* To figure out the load address we use the definition that for any symbol:
      dynamic_addr(symbol) = static_addr(symbol) + load_addr
 
-     The choice of symbol is arbitrary. The static address we obtain
-     by constructing a non GOT reference to the symbol, the dynamic
-     address of the symbol we compute using adrp/add to compute the
-     symbol's address relative to the PC. */
-
-  ElfW(Addr) static_addr;