return KtFe10PsiAnonymousObjectSymbol(psi.objectDeclaration, analysisContext)
    }

    override fun getClassOrObjectSymbol(psi: KtClassOrObject): KtClassOrObjectSymbol? {
        return if (psi is KtEnumEntry) {
            null
        } else if (psi is KtObjectDeclaration && psi.isObjectLiteral()) {
            KtFe10PsiAnonymousObjectSymbol(psi, analysisContext)
        } else {

        val bindingContext = analysisContext.analyze(ktFile)
        val result = mutableListOf<KtDiagnosticWithPsi<*>>()
        for (diagnostic in bindingContext.diagnostics) {
            if (diagnostic.psiFile == ktFile) {
                result += KtFe10Diagnostic(diagnostic, token)
            }
        }
        return result
    }
}

        require(callableSymbol is KtFirSymbol<*>)
        if (callableSymbol is KtFirBackingFieldSymbol) return emptyList()
        if (callableSymbol is KtValueParameterSymbol) {
            return callableSymbol.getDirectlyOverriddenSymbols()
        }
        if (callableSymbol is KtCallableSymbol && callableSymbol.firSymbol is FirIntersectionCallableSymbol) {

        get() = withValidityAssertion {
            if (descriptor.isDynamic()) return null
            val getter = descriptor.getter ?: return KtFe10DescDefaultPropertyGetterSymbol(descriptor, analysisContext)
            return KtFe10DescPropertyGetterSymbol(getter, analysisContext)
        }

    override val setter: KtPropertySetterSymbol?
        get() = withValidityAssertion {
            if (descriptor.isDynamic()) return null

        return if (nullable) {
            nullableTypeMapping[kClass] ?: typeMapping[kClass]
        } else {
            typeMapping[kClass]
        }
    }

    private fun tryMapAllowedType(kClass: KClass<*>): HLParameterConversion? {
        if (kClass in allowedTypesWithoutTypeParams) return HLIdParameterConversion
        return null
    }

                }
            }

            registerProvider provider@{ element: KtValueArgument ->
                if (element.isNamed()) return@provider null
                val annotationEntry = element.getParentOfTypeAndBranch<KtAnnotationEntry> { valueArgumentList } ?: return@provider null
                if (annotationEntry.valueArguments.size != 1) return@provider null

                KtDefaultAnnotationArgumentReference(element)

    // todo cache?
    override fun getPossibleCallableNames(): Set<Name> = withValidityAssertion {
        imports.flatMapTo(hashSetOf()) { import: Import ->
            if (import.relativeClassName == null) { // top level callable
                DeclarationsInPackageProvider.getTopLevelCallableNamesInPackageProvider(import.packageFqName, analysisSession)
            } else { //member

        require(type is KtFe10Type)
        return KotlinBuiltIns.isArrayOrPrimitiveArray(type.fe10Type)
    }

    override fun isNestedArray(type: KtType): Boolean {
        if (!isArrayOrPrimitiveArray(type)) return false
        require(type is KtFe10Type)
        val unwrappedType = type.fe10Type
        val elementType = unwrappedType.constructor.builtIns.getArrayElementType(unwrappedType)

            allowAnalysisFromWriteAction {
                val resolveToPsiElements = try {
                    analyze(ref.expression) { ref.getResolvedToPsi(this) }
                } catch (e: Exception) {
                    if (shouldIjPlatformExceptionBeRethrown(e)) throw e

                    errorWithAttachment("Unable to resolve reference ${ref.element::class}", cause = e) {
                        withPsiEntry("reference", ref.element)

- [`KT-56197`](https://youtrack.jetbrains.com/issue/KT-56197) If use classpathSnapshot, the invoke place of subclass's super function who has default parameters will not recompiled if it is incremental build
- [`KT-56886`](https://youtrack.jetbrains.com/issue/KT-56886) K2: Changes to Java sources used in Kotlin project do not trigger a rebuild if a previous build was successful

### Tools. JPS