val bindingContext = analysisContext.analyze(declaration)
            val kotlinType = bindingContext[BindingContext.PROPERTY_ACCESSOR, declaration]?.returnType
                ?: ErrorUtils.createErrorType(
                    ErrorTypeKind.IMPLICIT_RETURN_TYPE_FOR_PROPERTY_ACCESSOR, declaration.property.name ?: "<unknown>"
                )

            return kotlinType.toKtType(analysisContext)
        }

    // One of the compiler lowerings, namely `PropertyReferenceLowering`,
    // optimizes usages of property references in some cases,
    // and if a containing delegated property accessor is inline,
    // it might need this accessor's bytecode.
    //
    // If an accessor function is defined in a different module,
    // IDE tries to acquire its bytecode via the index, however,
    // the index doesn't cover classfiles from compiler output,

        if (jvmNameFromProperty != null) {
            return jvmNameFromProperty
        }

        val accessor = if (isSetter) property.setter else property.getter
        val jvmNameFromAccessor = accessor?.getJvmNameFromAnnotation(analysisSession.useSiteSession)
        if (jvmNameFromAccessor != null) {
            return jvmNameFromAccessor
        }

            Modality.OPEN
        }
        else -> null
    }

internal val KtElement.ktSymbolKind: KtSymbolKind
    get() {
        if (this is KtPropertyAccessor) {
            return KtSymbolKind.ACCESSOR
        }

        if (this is KtDeclaration) {
            return when (this.getParentOfType<KtDeclaration>(strict = true)) {
                null -> KtSymbolKind.TOP_LEVEL

         * asking.
         */
        override fun isAccessorWithExplicitImplementation(accessor: IrSimpleFunction): Boolean {
            if (accessor is AbstractFir2IrLazyDeclaration<*>) {
                val fir = accessor.fir
                if (fir is FirFunction && fir.hasBody) {
                    return true
                }
            }
            return false

<component name="ProjectDictionaryState">
  <dictionary name="abreslav">
    <words>
      <w>accessor</w>
      <w>covariantly</w>
      <w>deserialized</w>
      <w>dominator</w>
      <w>inferrer</w>
      <w>iterable</w>
      <w>nondeterministic</w>
      <w>nullable</w>
      <w>overridable</w>
      <w>pseudocode</w>
      <w>substitutor</w>
      <w>subtyping</w>
      <w>supertype</w>
      <w>supertypes</w>

) : KtValueParameterSymbol(), KtFe10Symbol {
    val descriptor: VariableDescriptor? by cached {
        val bindingContext = analysisContext.analyze(accessorPsi, AnalysisMode.PARTIAL)
        bindingContext[BindingContext.PROPERTY_ACCESSOR, accessorPsi]?.valueParameters?.single()
    }

    override val origin: KtSymbolOrigin
        get() = withValidityAssertion { KtSymbolOrigin.SOURCE_MEMBER_GENERATED }

    override val hasDefaultValue: Boolean

import org.jetbrains.kotlin.types.error.ErrorUtils

internal val MemberDescriptor.ktSymbolKind: KtSymbolKind
    get() {
        return when (this) {
            is PropertyAccessorDescriptor -> KtSymbolKind.ACCESSOR
            is SamConstructorDescriptor -> KtSymbolKind.SAM_CONSTRUCTOR
            else -> when (containingDeclaration) {
                is PackageFragmentDescriptor -> KtSymbolKind.TOP_LEVEL

    override val descriptor: PropertyGetterDescriptor? by cached {
        val bindingContext = analysisContext.analyze(psi, AnalysisMode.PARTIAL)
        bindingContext[BindingContext.PROPERTY_ACCESSOR, psi] as? PropertyGetterDescriptor
    }

    override val modality: Modality
        get() = withValidityAssertion { psi.property.ktModality ?: descriptor?.ktModality ?: Modality.FINAL }

        if (descriptor is DeserializedSimpleFunctionDescriptor) return

        analyzeNextIfInline(descriptor)

        if (descriptor is PropertyDescriptor) {
            for (accessor in descriptor.accessors) {
                analyzeNextIfInline(accessor)
            }
        }
    }

    private fun analyzeNextIfInline(descriptor: CallableDescriptor) {