val descriptor: PropertySetterDescriptor? by cached {
        val bindingContext = analysisContext.analyze(propertyPsi, Fe10AnalysisFacade.AnalysisMode.PARTIAL)
        (bindingContext[BindingContext.VARIABLE, propertyPsi] as? PropertyDescriptor)?.setter
    }

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

    override val psi: PsiElement?

            token,
        )
    }
    add(FirErrors.LOCAL_VARIABLE_WITH_TYPE_PARAMETERS_WARNING) { firDiagnostic ->
        LocalVariableWithTypeParametersWarningImpl(
            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }
    add(FirErrors.LOCAL_VARIABLE_WITH_TYPE_PARAMETERS) { firDiagnostic ->
        LocalVariableWithTypeParametersImpl(

    override val upperBounds: List<KtType>
        get() = withValidityAssertion { descriptor.upperBounds.filterNot { it.isNullableAny() }.map { it.toKtType(analysisContext) } }

    override val variance: Variance
        get() = withValidityAssertion { descriptor.variance }

    override val isReified: Boolean
        get() = withValidityAssertion { descriptor.isReified }

                when (arg) {
                    is KtStarTypeProjection -> StarProjectionImpl(typeParameters[index])
                    is KtTypeArgumentWithVariance -> TypeProjectionImpl(arg.variance, (arg.type as KtFe10Type).fe10Type)
                }
            }

            TypeUtils.substituteProjectionsForParameters(descriptor, projections)
        } else {
            descriptor.defaultType
        }

/compiler/testData/builtin-classes/ "Kotlin Libraries"
/compiler/testData/capturedTypeApproximation/ "Kotlin Compiler Core"
/compiler/testData/cfg/ "Kotlin Compiler Core"
/compiler/testData/cfg-variables/ "Kotlin Compiler Core"
/compiler/testData/cfgVariablesWithStdLib/ "Kotlin Compiler Core"
/compiler/testData/cfgWithStdLib/ "Kotlin Compiler Core"
/compiler/testData/checkLocalVariablesTable/ "Kotlin JVM"

        val bindingContext = analysisContext.analyze(psi)
        bindingContext[BindingContext.TYPE_PARAMETER, psi]
    }

    override val variance: Variance
        get() = withValidityAssertion { psi.variance }

    override val upperBounds: List<KtType>
        get() = withValidityAssertion {

            } else {
                when (projection.projectionKind) {
                    Variance.INVARIANT -> renderType(projection.type, printer)
                    Variance.IN_VARIANCE -> {
                        append("in ")
                        renderType(projection.type, printer)
                    }
                    Variance.OUT_VARIANCE -> {
                        append("out ")

        get() = when (this) {
            is KtStarTypeProjection -> ConeStarProjection
            is KtTypeArgumentWithVariance -> {
                typeContext.createTypeArgument(type.coneType, variance.convertVariance()) as ConeTypeProjection
            }
        }

    fun createTypeCheckerContext(): TypeCheckerState {
        // TODO use correct session here,

- [`KT-56682`](https://youtrack.jetbrains.com/issue/KT-56682) K2: False-negative UNINITIALIZED_VARIABLE on access to delegated property
- [`KT-56678`](https://youtrack.jetbrains.com/issue/KT-56678) K2: False-negative UNINITIALIZED_VARIABLE if corresponding variable has initializer

        }
    }

    override fun tryRenderAsNonErrorType(): String? = withValidityAssertion {
        when (fe10Type.kind) {
            ErrorTypeKind.UNINFERRED_TYPE_VARIABLE -> fe10Type.formatParams.first()
            else -> null
        }
    }


    override fun asStringForDebugging(): String = withValidityAssertion { fe10Type.asStringForDebugging(analysisContext) }