return isVisible(
                explicitReceiver,
                targetDescriptor,
                useSiteDescriptor,
                analysisContext.languageVersionSettings
            )
        } else {
            val bindingContext = analysisContext.analyze(useSiteDeclaration, AnalysisMode.FULL)

            val lexicalScope = position.getResolutionScope(bindingContext)
            if (lexicalScope != null) {

        super.getCallableSymbols(nameFilter).filter { symbol ->
            when (symbol) {
                is KtFunctionSymbol -> !symbol.isStatic
                is KtPropertySymbol -> !symbol.isStatic
                else -> true
            }
        }
    }
}

internal class KtFe10ScopeImporting(
    override val scope: ImportingScope,
    override val analysisContext: Fe10AnalysisContext
) : KtFe10ScopeResolution() {

      <option name="BLOCK_COMMENT_AT_FIRST_COLUMN" value="false" />
      <option name="KEEP_FIRST_COLUMN_COMMENT" value="false" />
      <option name="KEEP_BLANK_LINES_BEFORE_RBRACE" value="0" />
      <option name="ELSE_ON_NEW_LINE" value="true" />
      <option name="WHILE_ON_NEW_LINE" value="true" />
      <option name="CATCH_ON_NEW_LINE" value="true" />
      <option name="FINALLY_ON_NEW_LINE" value="true" />

  }

  @Test
  @TestMetadata("boolean_else.kt")
  public void testBoolean_else() {
    runTest("analysis/analysis-api/testData/components/expressionInfoProvider/whenMissingCases/boolean_else.kt");
  }

  @Test
  @TestMetadata("boolean_empty.kt")
  public void testBoolean_empty() {

                            is FirPropertyAccessExpression -> fir.explicitReceiver?.toKtReceiverValue()
                            else -> null
                        }
                    } else {
                        extensionReceiver?.toKtReceiverValue()
                    }
                }

                ExplicitReceiverKind.EXTENSION_RECEIVER -> {

            else -> KtFe10PsiValueParameterSymbol(psi, analysisContext)
        }
    }

    override fun getFunctionLikeSymbol(psi: KtNamedFunction): KtFunctionLikeSymbol {
        return if (psi.hasBody() && (psi.funKeyword == null || psi.nameIdentifier == null)) {
            getAnonymousFunctionSymbol(psi)
        } else {
            KtFe10PsiFunctionSymbol(psi, analysisContext)
        }

        is FirSimpleFunction -> processFunctionsByName(declaration.name) { }
        is FirProperty -> processPropertiesByName(declaration.name) { }
        else -> Unit
    }

    private fun FirTypeScope.processAllOverriddenDeclarations(
        declaration: FirDeclaration,
        processor: (FirCallableDeclaration) -> Unit
    ) = when (declaration) {

                return false
            }

            is KtScriptSymbol -> {
                // Scripts are always top-level
                return false
            }

            else -> {}
        }

        if (symbol is KtSymbolWithKind && symbol.symbolKind == KtSymbolKind.TOP_LEVEL) {
            val containingFile = (symbol.firSymbol.fir as? FirElementWithResolveState)?.getContainingFile()

            if (import.relativeClassName == null) { // top level callable
                DeclarationsInPackageProvider.getTopLevelCallableNamesInPackageProvider(import.packageFqName, analysisSession)
            } else { //member
                val classId = import.resolvedClassId ?: error("Class id should not be null as relativeClassName is not null")
                firScope.getStaticsScope(classId)?.getCallableNames().orEmpty()
            }

        get() = withValidityAssertion {
            val initializer = when (val psi = psi) {
                is KtProperty -> psi.initializer
                is KtParameter -> psi
                else -> null
            }

            createKtInitializerValue(initializer, descriptor, analysisContext)
        }

    override val getter: KtPropertyGetterSymbol?
        get() = withValidityAssertion {