Alternatively, it is still possible to only provide required JDKs via environment variables 
(see [gradle.properties](./gradle.properties#L5) for supported variable names). To ensure Gradle uses only JDKs 
from environmental variables - disable Gradle toolchain auto-detection by passing `-Porg.gradle.java.installations.auto-detect=false` option

        else -> null
    }

    /**
     * It only makes sense to provide type for the references which reference some actual properties/variables.
     *
     * In cases when the name reference references a function (a REAL function, not a functional type variable), it does not
     * make sense to provide any type for it.
     *
     * ---
     *

        }

        if (declaration is KtProperty) {
            val bindingContext = analysisContext.analyze(declaration)
            val kotlinType = bindingContext[BindingContext.VARIABLE, declaration]?.returnType
                ?: ErrorUtils.createErrorType(ErrorTypeKind.IMPLICIT_RETURN_TYPE_FOR_PROPERTY, declaration.name ?: "<unknown>")

            return kotlinType.toKtType(analysisContext)
        }

/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"

  }

  @Test
  @TestMetadata("getClass_variable.kt")
  public void testGetClass_variable() {
    runTest("analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/getClass_variable.kt");
  }

  @Test
  @TestMetadata("methodReference_java.kt")
  public void testMethodReference_java() {

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

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

    override val psi: PsiElement?

        }
    }

    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) }

                    methods.singleOrNull { it.name.endsWith(JvmAbi.ANNOTATED_PROPERTY_METHOD_NAME_SUFFIX) }?.let {
                        bindings.put(
                            FirJvmSerializerExtension.SYNTHETIC_METHOD_FOR_FIR_VARIABLE,
                            fir,
                            Method(it.name, getAsmMethodSignatureWithCorrection(it))
                        )
                    }
                }
                else -> {}

    token: KtLifetimeToken,
) : KtAbstractFirDiagnostic<KtNamedDeclaration>(firDiagnostic, token), KtFirDiagnostic.PropertyTypeMismatchOnOverride

internal class VarTypeMismatchOnOverrideImpl(
    override val variable: KtCallableSymbol,
    override val superVariable: KtCallableSymbol,
    firDiagnostic: KtPsiDiagnostic,
    token: KtLifetimeToken,

            // Function parameter declarations use their default value expressions.
            is KtParameter ->
                parent.defaultValue == child

            // Variable declarations use their initializer.
            is KtVariableDeclaration ->
                parent.initializer == child

            // Binary expressions always use both operands.
            is KtBinaryExpression ->