// 	  "import", "let", "loop", "package", "namespace", "return".
  // Examples:
  //   - Expression accessing a property named "namespace": {"Expression": "object.__namespace__ > 0"}
  //   - Expression accessing a property named "x-prop": {"Expression": "object.x__dash__prop > 0"}
  //   - Expression accessing a property named "redact__d": {"Expression": "object.redact__underscores__d > 0"}
  //

        }
    }

    override fun isDefinitelyNull(expression: KtExpression): Boolean {
        val unwrapped = expression.unwrapParenthesesLabelsAndAnnotations() as? KtElement ?: return false
        val bindingContext = analysisContext.analyze(expression, AnalysisMode.PARTIAL)

        if (bindingContext[BindingContext.SMARTCAST_NULL, expression] == true) {
            return true
        }

            // "named" functions can be expressions.
            is KtNamedFunction ->
                doesParentUseChild(psiElement.parent, psiElement)

            // No other declarations are considered expressions
            is KtDeclaration ->
                false

            /**
             * EXPRESSIONS
             */
            // A handful of expression are never considered used:

 */

package org.jetbrains.kotlin.idea.references

import org.jetbrains.kotlin.fir.declarations.FirProperty
import org.jetbrains.kotlin.fir.expressions.FirComponentCall
import org.jetbrains.kotlin.analysis.api.fir.getCalleeSymbol
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirSafe
import org.jetbrains.kotlin.analysis.api.KtAnalysisSession

Container Enhancements

* ExpressionEvaluator

  Currently, the expression evaluator used to resolve configuration values
  is the DefaultExpressionEvaluator, which is a local variable within the
  implementation of the BasicComponentConfigurator. This ExpressionEvaluator
  simply returns the expression itself as the resolved value, which adds
  very little value to the container. Things like ${project.build.resources}

    override fun evaluate(
        expression: KtExpression,
        mode: KtConstantEvaluationMode,
    ): KtConstantValue? {
        val bindingContext = analysisContext.analyze(expression)

        val constant = ConstantExpressionEvaluator.getPossiblyErrorConstant(expression, bindingContext)
        if (mode == KtConstantEvaluationMode.CONSTANT_EXPRESSION_EVALUATION) {

import org.jetbrains.kotlin.fir.FirAnnotationContainer
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.containingClassLookupTag
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.expressions.*
import org.jetbrains.kotlin.fir.references.toResolvedCallableSymbol
import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
import org.jetbrains.kotlin.fir.symbols.resolvedAnnotationsWithArguments

import org.jetbrains.kotlin.fir.expressions.FirLoopJump
import org.jetbrains.kotlin.fir.psi
import org.jetbrains.kotlin.psi.*

internal class KtFirSimpleNameReference(
    expression: KtSimpleNameExpression,
    val isRead: Boolean,
) : KtSimpleNameReference(expression), KtFirReference {

    private val isAnnotationCall: Boolean
        get() {
            val ktUserType = expression.parent as? KtUserType ?: return false

        // call entry and if so we resolve the constructor callee expression.
        val userType = expression.parent as? KtUserType ?: return expression
        val typeReference = userType.parent as? KtTypeReference ?: return expression
        val constructorCalleeExpression = typeReference.parent as? KtConstructorCalleeExpression ?: return expression

import org.jetbrains.kotlin.fir.declarations.toAnnotationClassId
import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
import org.jetbrains.kotlin.fir.diagnostics.ConeUnreportedDuplicateDiagnostic
import org.jetbrains.kotlin.fir.expressions.*
import org.jetbrains.kotlin.fir.psi
import org.jetbrains.kotlin.fir.references.*
import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeDiagnosticWithCandidates