FIR: Use more refined names instead of "safe"

^KT-38444 Fixed

compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/ExpressionsConverter.kt

@@ -432,13 +432,13 @@ class ExpressionsConverter(
      */
     private fun convertCallableReferenceExpression(callableReferenceExpression: LighterASTNode): FirExpression {
         var isReceiver = true
-        var safe = false
+        var hasQuestionMarkAtLHS = false
         var firReceiverExpression: FirExpression? = null
         lateinit var firCallableReference: FirQualifiedAccess
         callableReferenceExpression.forEachChildren {
             when (it.tokenType) {
                 COLONCOLON -> isReceiver = false
-                QUEST -> safe = true
+                QUEST -> hasQuestionMarkAtLHS = true
                 else -> if (it.isExpression()) {
                     if (isReceiver) {
                         firReceiverExpression = getAsFirExpression(it, "Incorrect receiver expression")
@@ -453,7 +453,7 @@ class ExpressionsConverter(
             source = callableReferenceExpression.toFirSourceElement()
             calleeReference = firCallableReference.calleeReference as FirNamedReference
             explicitReceiver = firReceiverExpression
-            this.safe = safe
+            this.hasQuestionMarkAtLHS = hasQuestionMarkAtLHS
         }
     }
 
@@ -487,7 +487,6 @@ class ExpressionsConverter(
                 return it.wrapWithSafeCall(firReceiver!!)
             }
 
-            it.safe = false
             it.explicitReceiver = firReceiver
         }
         return firSelector

compiler/fir/raw-fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt

@@ -1812,7 +1812,7 @@ class RawFirBuilder(
                     name = expression.callableReference.getReferencedNameAsName()
                 }
                 explicitReceiver = expression.receiverExpression?.toFirExpression("Incorrect receiver expression")
-                safe = expression.hasQuestionMarks
+                hasQuestionMarkAtLHS = expression.hasQuestionMarks
             }
         }
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirDoubleColonExpressionResolver.kt

@@ -71,7 +71,7 @@ class FirDoubleColonExpressionResolver(
 
     private fun shouldTryResolveLHSAsExpression(expression: FirCallableReferenceAccess): Boolean {
         val lhs = expression.explicitReceiver ?: return false
-        return lhs.canBeConsideredProperExpression() && !expression.safe
+        return lhs.canBeConsideredProperExpression() && !expression.hasQuestionMarkAtLHS
     }
 
     private fun shouldTryResolveLHSAsType(expression: FirCallableReferenceAccess): Boolean {
@@ -172,7 +172,7 @@ class FirDoubleColonExpressionResolver(
                     else -> ConeStarProjection
                 }
             },
-            isNullable = expression.safe
+            isNullable = resolvedExpression.isNullableLHSForCallableReference
         )
 
         return DoubleColonLHS.Type(type)

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt

@@ -511,8 +511,8 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
         callableReferenceAccess.annotations.forEach { it.accept(this, data) }
         val explicitReceiver = callableReferenceAccess.explicitReceiver
         val transformedLHS = explicitReceiver?.transformSingle(this, ResolutionMode.ContextIndependent)?.apply {
-            if (this is FirResolvedQualifier && callableReferenceAccess.safe) {
+            if (this is FirResolvedQualifier && callableReferenceAccess.hasQuestionMarkAtLHS) {
-                replaceSafe(true)
+                replaceIsNullableLHSForCallableReference(true)
             }
         }
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirCallableReferenceAccess.kt

@@ -21,12 +21,12 @@ abstract class FirCallableReferenceAccess : FirQualifiedAccessExpression() {
     abstract override val source: FirSourceElement?
     abstract override val typeRef: FirTypeRef
     abstract override val annotations: List<FirAnnotationCall>
-    abstract override val safe: Boolean
     abstract override val typeArguments: List<FirTypeProjection>
     abstract override val explicitReceiver: FirExpression?
     abstract override val dispatchReceiver: FirExpression
     abstract override val extensionReceiver: FirExpression
     abstract override val calleeReference: FirNamedReference
+    abstract val hasQuestionMarkAtLHS: Boolean
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitCallableReferenceAccess(this, data)
 
@@ -38,6 +38,8 @@ abstract class FirCallableReferenceAccess : FirQualifiedAccessExpression() {
 
     abstract override fun replaceCalleeReference(newCalleeReference: FirReference)
 
+    abstract fun replaceHasQuestionMarkAtLHS(newHasQuestionMarkAtLHS: Boolean)
+
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirCallableReferenceAccess
 
     abstract override fun <D> transformTypeArguments(transformer: FirTransformer<D>, data: D): FirCallableReferenceAccess

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirResolvedQualifier.kt

@@ -26,14 +26,14 @@ abstract class FirResolvedQualifier : FirExpression() {
     abstract val relativeClassFqName: FqName?
     abstract val classId: ClassId?
     abstract val symbol: FirClassLikeSymbol<*>?
-    abstract val safe: Boolean
+    abstract val isNullableLHSForCallableReference: Boolean
     abstract val typeArguments: List<FirTypeProjection>
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitResolvedQualifier(this, data)
 
     abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
 
-    abstract fun replaceSafe(newSafe: Boolean)
+    abstract fun replaceIsNullableLHSForCallableReference(newIsNullableLHSForCallableReference: Boolean)
 
     abstract fun replaceTypeArguments(newTypeArguments: List<FirTypeProjection>)
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirCallableReferenceAccessBuilder.kt

@@ -34,24 +34,24 @@ class FirCallableReferenceAccessBuilder : FirQualifiedAccessBuilder, FirAnnotati
     override var source: FirSourceElement? = null
     override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(null)
     override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
-    override var safe: Boolean = false
     override val typeArguments: MutableList<FirTypeProjection> = mutableListOf()
     override var explicitReceiver: FirExpression? = null
     override var dispatchReceiver: FirExpression = FirNoReceiverExpression
     override var extensionReceiver: FirExpression = FirNoReceiverExpression
     lateinit var calleeReference: FirNamedReference
+    var hasQuestionMarkAtLHS: Boolean = false
 
     override fun build(): FirCallableReferenceAccess {
         return FirCallableReferenceAccessImpl(
             source,
             typeRef,
             annotations,
-            safe,
             typeArguments,
             explicitReceiver,
             dispatchReceiver,
             extensionReceiver,
             calleeReference,
+            hasQuestionMarkAtLHS,
         )
     }
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirResolvedQualifierBuilder.kt

@@ -34,7 +34,7 @@ class FirResolvedQualifierBuilder : FirAnnotationContainerBuilder, FirExpression
     lateinit var packageFqName: FqName
     var relativeClassFqName: FqName? = null
     var symbol: FirClassLikeSymbol<*>? = null
-    var safe: Boolean by kotlin.properties.Delegates.notNull<Boolean>()
+    var isNullableLHSForCallableReference: Boolean = false
     val typeArguments: MutableList<FirTypeProjection> = mutableListOf()
 
     override fun build(): FirResolvedQualifier {
@@ -45,7 +45,7 @@ class FirResolvedQualifierBuilder : FirAnnotationContainerBuilder, FirExpression
             packageFqName,
             relativeClassFqName,
             symbol,
-            safe,
+            isNullableLHSForCallableReference,
             typeArguments,
         )
     }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirCallableReferenceAccessImpl.kt

@@ -25,12 +25,12 @@ internal class FirCallableReferenceAccessImpl(
     override val source: FirSourceElement?,
     override var typeRef: FirTypeRef,
     override val annotations: MutableList<FirAnnotationCall>,
-    override var safe: Boolean,
     override val typeArguments: MutableList<FirTypeProjection>,
     override var explicitReceiver: FirExpression?,
     override var dispatchReceiver: FirExpression,
     override var extensionReceiver: FirExpression,
     override var calleeReference: FirNamedReference,
+    override var hasQuestionMarkAtLHS: Boolean,
 ) : FirCallableReferenceAccess(), FirModifiableQualifiedAccess {
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         typeRef.accept(visitor, data)
@@ -108,4 +108,8 @@ internal class FirCallableReferenceAccessImpl(
         require(newCalleeReference is FirNamedReference)
         replaceCalleeReference(newCalleeReference)
     }
+
+    override fun replaceHasQuestionMarkAtLHS(newHasQuestionMarkAtLHS: Boolean) {
+        hasQuestionMarkAtLHS = newHasQuestionMarkAtLHS
+    }
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirResolvedQualifierImpl.kt

@@ -27,7 +27,7 @@ internal class FirResolvedQualifierImpl(
     override var packageFqName: FqName,
     override var relativeClassFqName: FqName?,
     override val symbol: FirClassLikeSymbol<*>?,
-    override var safe: Boolean,
+    override var isNullableLHSForCallableReference: Boolean,
     override val typeArguments: MutableList<FirTypeProjection>,
 ) : FirResolvedQualifier() {
     override val classId: ClassId? get() = relativeClassFqName?.let {
@@ -61,8 +61,8 @@ internal class FirResolvedQualifierImpl(
         typeRef = newTypeRef
     }
 
-    override fun replaceSafe(newSafe: Boolean) {
+    override fun replaceIsNullableLHSForCallableReference(newIsNullableLHSForCallableReference: Boolean) {
-        safe = newSafe
+        isNullableLHSForCallableReference = newIsNullableLHSForCallableReference
     }
 
     override fun replaceTypeArguments(newTypeArguments: List<FirTypeProjection>) {

compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt

@@ -1018,7 +1018,7 @@ class FirRenderer(builder: StringBuilder, private val mode: RenderMode = RenderM
     override fun visitCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess) {
         callableReferenceAccess.annotations.renderAnnotations()
         callableReferenceAccess.explicitReceiver?.accept(this)
-        if (callableReferenceAccess.safe && callableReferenceAccess.explicitReceiver !is FirResolvedQualifier) {
+        if (callableReferenceAccess.hasQuestionMarkAtLHS && callableReferenceAccess.explicitReceiver !is FirResolvedQualifier) {
             print("?")
         }
         print("::")
@@ -1127,7 +1127,7 @@ class FirRenderer(builder: StringBuilder, private val mode: RenderMode = RenderM
         } else {
             print(resolvedQualifier.packageFqName.asString().replace(".", "/"))
         }
-        if (resolvedQualifier.safe) {
+        if (resolvedQualifier.isNullableLHSForCallableReference) {
             print("?")
         }
         print("|")

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/BuilderConfigurator.kt

@@ -111,7 +111,7 @@ object BuilderConfigurator : AbstractBuilderConfigurator<FirTreeBuilder>(FirTree
             parents += qualifiedAccessBuilder
             defaultNull("explicitReceiver")
             defaultNoReceivers()
-            defaultFalse("safe")
+            defaultFalse("hasQuestionMarkAtLHS")
         }
 
         builder(componentCall) {
@@ -265,6 +265,10 @@ object BuilderConfigurator : AbstractBuilderConfigurator<FirTreeBuilder>(FirTree
             default("symbol", "FirAnonymousInitializerSymbol()")
         }
 
+        builder(resolvedQualifier) {
+            defaultFalse("isNullableLHSForCallableReference")
+        }
+
         val elementsWithDefaultTypeRef = listOf(
             thisReceiverExpression,
             callableReferenceAccess,

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/ImplementationConfigurator.kt

@@ -219,7 +219,7 @@ object ImplementationConfigurator : AbstractFirTreeImplementationConfigurator()
         impl(typeOperatorCall)
 
         impl(resolvedQualifier) {
-            isMutable("packageFqName", "relativeClassFqName", "safe")
+            isMutable("packageFqName", "relativeClassFqName", "isNullableLHSForCallableReference")
             default("classId") {
                 value = """
                     |relativeClassFqName?.let {

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt

@@ -452,6 +452,7 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
 
         callableReferenceAccess.configure {
             +field("calleeReference", namedReference, withReplace = true).withTransform()
+            +booleanField("hasQuestionMarkAtLHS", withReplace = true)
         }
 
         getClassCall.configure {
@@ -476,7 +477,7 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
             +field("relativeClassFqName", fqNameType, nullable = true)
             +field("classId", classIdType, nullable = true)
             +field("symbol", classLikeSymbolType, nullable = true)
-            +booleanField("safe", withReplace = true)
+            +booleanField("isNullableLHSForCallableReference", withReplace = true)
             +typeArguments.withTransform()
         }