[FIR] Approximate all integer literals which resolved in independent mode

#KT-42016

compiler/fir/analysis-tests/testData/resolve/arguments/operatorsOverLiterals.kt

@@ -31,33 +31,33 @@ fun test_3() {
 fun takeByte(b: Byte) {}
 
 fun test_4() {
-    takeByte(1 + 1)
+    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1 + 1)
     <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1 + 127)
-    takeByte(1 - 1)
+    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1 - 1)
     <!INAPPLICABLE_CANDIDATE!>takeByte<!>(-100 - 100)
-    takeByte(10 * 10)
+    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(10 * 10)
     <!INAPPLICABLE_CANDIDATE!>takeByte<!>(100 * 100)
     <!UNRESOLVED_REFERENCE!>taleByte<!>(10 / 10)
-    takeByte(100 % 10)
+    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(100 % 10)
-    takeByte(1000 % 10)
+    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1000 % 10)
-    takeByte(1000 and 100)
+    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1000 and 100)
     <!INAPPLICABLE_CANDIDATE!>takeByte<!>(128 and 511)
-    takeByte(100 or 100)
+    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(100 or 100)
     <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1000 or 0)
-    takeByte(511 xor 511)
+    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(511 xor 511)
     <!INAPPLICABLE_CANDIDATE!>takeByte<!>(512 xor 511)
 }
 
 fun test_5() {
     takeByte(-1)
     takeByte(+1)
-    takeByte(1.inv())
+    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1.inv())
 }
 
 fun test_6() {
     <!INAPPLICABLE_CANDIDATE!>takeByte<!>(run { 127 + 1 })
     <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1 + run { 1 })
-    takeByte(run { 1 + 1 })
+    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(run { 1 + 1 })
     1 + 1
     run { 1 }
     1 + run { 1 }

compiler/fir/analysis-tests/testData/resolve/arguments/operatorsOverLiterals.txt

@@ -29,37 +29,37 @@ FILE: operatorsOverLiterals.kt
     public final fun takeByte(b: R|kotlin/Byte|): R|kotlin/Unit| {
     }
     public final fun test_4(): R|kotlin/Unit| {
-        R|/takeByte|(Byte(1).R|kotlin/Byte.plus|(Byte(1)))
+        <Inapplicable(INAPPLICABLE): /takeByte>#(Int(1).R|kotlin/Int.plus|(Int(1)))
         <Inapplicable(INAPPLICABLE): /takeByte>#(Int(1).R|kotlin/Int.plus|(Int(127)))
-        R|/takeByte|(Byte(1).R|kotlin/Byte.minus|(Byte(1)))
+        <Inapplicable(INAPPLICABLE): /takeByte>#(Int(1).R|kotlin/Int.minus|(Int(1)))
         <Inapplicable(INAPPLICABLE): /takeByte>#(Int(-100).R|kotlin/Int.minus|(Int(100)))
-        R|/takeByte|(Byte(10).R|kotlin/Byte.times|(Byte(10)))
+        <Inapplicable(INAPPLICABLE): /takeByte>#(Int(10).R|kotlin/Int.times|(Int(10)))
         <Inapplicable(INAPPLICABLE): /takeByte>#(Int(100).R|kotlin/Int.times|(Int(100)))
         <Unresolved name: taleByte>#(Int(10).R|kotlin/Int.div|(Int(10)))
-        R|/takeByte|(Byte(100).R|kotlin/Byte.rem|(Byte(10)))
+        <Inapplicable(INAPPLICABLE): /takeByte>#(Int(100).R|kotlin/Int.rem|(Int(10)))
-        R|/takeByte|(Int(1000).R|kotlin/Int.rem|(Byte(10)))
+        <Inapplicable(INAPPLICABLE): /takeByte>#(Int(1000).R|kotlin/Int.rem|(Int(10)))
-        R|/takeByte|(Int(1000).R|<local>/and|(Byte(100)))
+        <Inapplicable(INAPPLICABLE): /takeByte>#(Int(1000).R|kotlin/Int.and|(Int(100)))
         <Inapplicable(INAPPLICABLE): /takeByte>#(Int(128).R|kotlin/Int.and|(Int(511)))
-        R|/takeByte|(Byte(100).R|<local>/or|(Byte(100)))
+        <Inapplicable(INAPPLICABLE): /takeByte>#(Int(100).R|kotlin/Int.or|(Int(100)))
         <Inapplicable(INAPPLICABLE): /takeByte>#(Int(1000).R|kotlin/Int.or|(Int(0)))
-        R|/takeByte|(Int(511).R|kotlin/Int.xor|(Int(511)))
+        <Inapplicable(INAPPLICABLE): /takeByte>#(Int(511).R|kotlin/Int.xor|(Int(511)))
         <Inapplicable(INAPPLICABLE): /takeByte>#(Int(512).R|kotlin/Int.xor|(Int(511)))
     }
     public final fun test_5(): R|kotlin/Unit| {
         R|/takeByte|(Byte(-1))
         R|/takeByte|(Byte(1))
-        R|/takeByte|(Byte(1).R|<local>/inv|())
+        <Inapplicable(INAPPLICABLE): /takeByte>#(Int(1).R|kotlin/Int.inv|())
     }
     public final fun test_6(): R|kotlin/Unit| {
         <Inapplicable(INAPPLICABLE): /takeByte>#(R|kotlin/run|<R|kotlin/Int|>(<L> = run@fun <anonymous>(): R|kotlin/Int| <kind=EXACTLY_ONCE>  {
             ^ Int(127).R|kotlin/Int.plus|(Int(1))
         }
         ))
-        <Inapplicable(INAPPLICABLE): /takeByte>#(Int(1).R|<local>/plus|(R|kotlin/run|<R|kotlin/Int|>(<L> = run@fun <anonymous>(): R|kotlin/Int| <kind=EXACTLY_ONCE>  {
+        <Inapplicable(INAPPLICABLE): /takeByte>#(Int(1).R|kotlin/Int.plus|(R|kotlin/run|<R|kotlin/Int|>(<L> = run@fun <anonymous>(): R|kotlin/Int| <kind=EXACTLY_ONCE>  {
             ^ Int(1)
         }
         )))
-        R|/takeByte|(R|kotlin/run|<R|kotlin/Byte|>(<L> = run@fun <anonymous>(): R|kotlin/Byte| <kind=EXACTLY_ONCE>  {
+        <Inapplicable(INAPPLICABLE): /takeByte>#(R|kotlin/run|<R|kotlin/Int|>(<L> = run@fun <anonymous>(): R|kotlin/Int| <kind=EXACTLY_ONCE>  {
             ^ Int(1).R|kotlin/Int.plus|(Int(1))
         }
         ))

compiler/fir/analysis-tests/testData/resolve/delegatingConstructorCall.kt

@@ -16,12 +16,12 @@ class B3_3 : A3("", true)
 class B3_4 : <!NONE_APPLICABLE!>A3<!>("", Unit)
 
 open class A4(val x: Byte)
-class B4 : A4( 1 + 1)
+class B4 : <!INAPPLICABLE_CANDIDATE!>A4<!>( 1 + 1)
 
 open class A5 {
     constructor(x: Byte)
     constructor(x: Short)
 }
 
-class B5_1 : A5(1 + 1)
+class B5_1 : <!NONE_APPLICABLE!>A5<!>(1 + 1)
-class B5_2 : A5(100 * 2)
+class B5_2 : <!NONE_APPLICABLE!>A5<!>(100 * 2)

compiler/fir/analysis-tests/testData/resolve/delegatingConstructorCall.txt

@@ -77,7 +77,7 @@ FILE: delegatingConstructorCall.kt
     }
     public final class B4 : R|A4| {
         public constructor(): R|B4| {
-            super<R|A4|>(Byte(1).R|kotlin/Byte.plus|(Byte(1)))
+            super<R|A4|>(Int(1).R|kotlin/Int.plus|(Int(1)))
         }
 
     }
@@ -93,13 +93,13 @@ FILE: delegatingConstructorCall.kt
     }
     public final class B5_1 : R|A5| {
         public constructor(): R|B5_1| {
-            super<R|A5|>(Short(1).R|kotlin/Short.plus|(Short(1)))
+            super<R|A5|>(Int(1).R|kotlin/Int.plus|(Int(1)))
         }
 
     }
     public final class B5_2 : R|A5| {
         public constructor(): R|B5_2| {
-            super<R|A5|>(Short(100).R|kotlin/Short.times|(Short(2)))
+            super<R|A5|>(Int(100).R|kotlin/Int.times|(Int(2)))
         }
 
     }

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

@@ -251,7 +251,9 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
             }
 
             (delegateProvider as? FirFunctionCall)?.let { dataFlowAnalyzer.dropSubgraphFromCall(it) }
-            return wrappedDelegateExpression.expression.transform(transformer, ResolutionMode.ContextDependent)
+            return wrappedDelegateExpression.expression
+                .transformSingle(transformer, ResolutionMode.ContextDependent)
+                .transform(integerLiteralTypeApproximator, null)
         } finally {
             dataFlowAnalyzer.exitDelegateExpression()
         }

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

@@ -714,20 +714,9 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform
             FirConstKind.IntegerLiteral, FirConstKind.UnsignedIntegerLiteral -> {
                 val integerLiteralType =
                     ConeIntegerLiteralTypeImpl(constExpression.value as Long, isUnsigned = kind == FirConstKind.UnsignedIntegerLiteral)
-                val expectedType = data.expectedType?.coneTypeSafe<ConeKotlinType>()
+                if (data.expectedType != null) {
-                if (expectedType != null) {
+                    val approximatedType = integerLiteralType.getApproximatedType(data.expectedType?.coneTypeSafe())
-                    val approximatedType = integerLiteralType.getApproximatedType(expectedType)
                     val newConstKind = approximatedType.toConstKind()
-                    if (newConstKind == null) {
-                        @Suppress("UNCHECKED_CAST")
-                        constExpression.replaceKind(FirConstKind.Int as FirConstKind<T>)
-                        dataFlowAnalyzer.exitConstExpression(constExpression as FirConstExpression<*>)
-                        constExpression.resultType = buildErrorTypeRef {
-                            source = constExpression.source
-                            diagnostic = ConeTypeMismatchError(expectedType, integerLiteralType.getApproximatedType())
-                        }
-                        return constExpression.compose()
-                    }
                     @Suppress("UNCHECKED_CAST")
                     constExpression.replaceKind(newConstKind as FirConstKind<T>)
                     approximatedType

compiler/testData/codegen/box/casts/literalExpressionAsGenericArgument/binaryExpressionCast.kt

@@ -1,7 +1,7 @@
 class Box<T>(val value: T)
 
 fun box() : String {
-    val b = Box<Long>(2 * 3)
+    val b = Box<Long>(2l * 3)
     val expected: Long? = 6L
     return if (b.value == expected) "OK" else "fail"
 }

compiler/testData/codegen/box/casts/literalExpressionAsGenericArgument/labeledExpressionCast.kt

@@ -1,7 +1,7 @@
 class Box<T>(val value: T)
 
 fun box() : String {
-    val b = Box<Long>(x@ (1 + 2))
+    val b = Box<Long>(x@ (1l + 2))
     val expected: Long? = 3L
     return if (b.value == expected) "OK" else "fail"
 }

compiler/testData/codegen/box/evaluate/intrinsics.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND_FIR: JVM_IR
 // TARGET_BACKEND: JVM
 
 // WITH_RUNTIME

compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/propertyMetadataCache.fir.kt

@@ -5,9 +5,9 @@ import kotlin.reflect.KProperty
 operator fun Any.getValue(x: Any?, y: Any): Any = null!!
 
 class C {
-    val x by <!UNRESOLVED_REFERENCE!>1<!>
+    val x by 1
     val `$$delegatedProperties`: Array<KProperty<*>> = null!!
 }
 
-val x by <!UNRESOLVED_REFERENCE!>1<!>
+val x by 1
 val `$$delegatedProperties`: Array<KProperty<*>> = null!!

compiler/testData/diagnostics/tests/evaluate/binaryMinusDepOnExpType.fir.kt

@@ -10,19 +10,19 @@ fun test() {
     <!INAPPLICABLE_CANDIDATE!>fooInt<!>(1 - 1.toLong())
     fooInt(1 - 1.toShort())
 
-    fooByte(1 - 1)
+    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1 - 1)
     <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1 - 1.toInt())
     <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1 - 1.toByte())
     <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1 - 1.toLong())
     <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1 - 1.toShort())
 
-    fooLong(1 - 1)
+    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(1 - 1)
     <!INAPPLICABLE_CANDIDATE!>fooLong<!>(1 - 1.toInt())
     <!INAPPLICABLE_CANDIDATE!>fooLong<!>(1 - 1.toByte())
     fooLong(1 - 1.toLong())
     <!INAPPLICABLE_CANDIDATE!>fooLong<!>(1 - 1.toShort())
 
-    fooShort(1 - 1)
+    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1 - 1)
     <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1 - 1.toInt())
     <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1 - 1.toByte())
     <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1 - 1.toLong())

compiler/testData/diagnostics/tests/evaluate/numberBinaryOperations.fir.kt

@@ -0,0 +1,26 @@
+fun fooInt(p: Int) = p
+fun fooLong(p: Long) = p
+fun fooByte(p: Byte) = p
+fun fooShort(p: Short) = p
+
+fun test() {
+    fooInt(1 + 1)
+    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1 + 1)
+    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(1 + 1)
+    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1 + 1)
+
+    fooInt(1 * 1)
+    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1 * 1)
+    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(1 * 1)
+    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1 * 1)
+
+    fooInt(1 / 1)
+    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1 / 1)
+    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(1 / 1)
+    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1 / 1)
+
+    fooInt(1 % 1)
+    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1 % 1)
+    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(1 % 1)
+    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1 % 1)
+}

compiler/testData/diagnostics/tests/evaluate/numberBinaryOperations.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 fun fooInt(p: Int) = p
 fun fooLong(p: Long) = p
 fun fooByte(p: Byte) = p

compiler/testData/diagnostics/tests/evaluate/numberBinaryOperationsCall.fir.kt

@@ -0,0 +1,26 @@
+fun fooInt(p: Int) = p
+fun fooLong(p: Long) = p
+fun fooByte(p: Byte) = p
+fun fooShort(p: Short) = p
+
+fun test() {
+    fooInt(1.plus(1))
+    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1.plus(1))
+    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(1.plus(1))
+    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1.plus(1))
+
+    fooInt(1.times(1))
+    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1.times(1))
+    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(1.times(1))
+    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1.times(1))
+
+    fooInt(1.div(1))
+    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1.div(1))
+    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(1.div(1))
+    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1.div(1))
+
+    fooInt(1.rem(1))
+    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1.rem(1))
+    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(1.rem(1))
+    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1.rem(1))
+}

compiler/testData/diagnostics/tests/evaluate/numberBinaryOperationsCall.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 fun fooInt(p: Int) = p
 fun fooLong(p: Long) = p
 fun fooByte(p: Byte) = p

compiler/testData/diagnostics/tests/evaluate/numberBinaryOperationsInfixCall.fir.kt

@@ -5,22 +5,22 @@ fun fooShort(p: Short) = p
 
 fun test() {
     fooInt(1 plus 1)
-    fooByte(1 plus 1)
+    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1 plus 1)
-    fooLong(1 plus 1)
+    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(1 plus 1)
-    fooShort(1 plus 1)
+    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1 plus 1)
 
     fooInt(1 times 1)
-    fooByte(1 times 1)
+    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1 times 1)
-    fooLong(1 times 1)
+    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(1 times 1)
-    fooShort(1 times 1)
+    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1 times 1)
 
     fooInt(1 div 1)
-    fooByte(1 div 1)
+    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1 div 1)
-    fooLong(1 div 1)
+    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(1 div 1)
-    fooShort(1 div 1)
+    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1 div 1)
 
     fooInt(1 rem 1)
-    fooByte(1 rem 1)
+    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1 rem 1)
-    fooLong(1 rem 1)
+    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(1 rem 1)
-    fooShort(1 rem 1)
+    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1 rem 1)
 }

compiler/testData/diagnostics/tests/inference/commonSystem/iltInsideSeveralCalls.kt

@@ -5,9 +5,9 @@ fun <T> consumeLongAndMaterialize(x: Long): T = null as T
 fun consumeAny(x: Any) = x
 
 fun main() {
-    consumeAny(consumeLongAndMaterialize(3 * 1000))
+    consumeAny(consumeLongAndMaterialize(3l * 1000))
 
     if (true) {
-        consumeLongAndMaterialize(3 * 1000)
+        consumeLongAndMaterialize(3l * 1000)
     } else true
 }

compiler/testData/diagnostics/tests/operatorRem/numberRemConversions.fir.kt

@@ -7,9 +7,9 @@ fun fooShort(p: Short) = p
 
 fun test() {
     fooInt(1 % 1)
-    fooByte(1 % 1)
+    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1 % 1)
-    fooLong(1 % 1)
+    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(1 % 1)
-    fooShort(1 % 1)
+    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1 % 1)
 }
 
 public operator fun Int.rem(other: Int): Int = 0

compiler/testData/ir/irText/expressions/genericConstructorCallWithTypeArguments.kt

@@ -1,4 +1,4 @@
-fun testSimple() = Box<Long>(2 * 3)
+fun testSimple() = Box<Long>(2l * 3)
 
 inline fun <reified T> testArray(n: Int, crossinline block: () -> T): Array<T> {
     return Array<T>(n) { block() }

compiler/testData/ir/irText/expressions/primitivesImplicitConversions.fir.txt

@@ -29,7 +29,7 @@ FILE fqName:<root> fileName:/primitivesImplicitConversions.kt
   PROPERTY name:test4 visibility:public modality:FINAL [val]
     FIELD PROPERTY_BACKING_FIELD name:test4 type:kotlin.Long visibility:private [final,static]
       EXPRESSION_BODY
-        CALL 'public final fun unaryMinus (): kotlin.Int [operator] declared in kotlin.Int' type=kotlin.Long origin=null
+        CALL 'public final fun unaryMinus (): kotlin.Int [operator] declared in kotlin.Int' type=kotlin.Int origin=null
           $this: CONST Int type=kotlin.Int value=42
     FUN DEFAULT_PROPERTY_ACCESSOR name:<get-test4> visibility:public modality:FINAL <> () returnType:kotlin.Long
       correspondingProperty: PROPERTY name:test4 visibility:public modality:FINAL [val]
@@ -39,7 +39,7 @@ FILE fqName:<root> fileName:/primitivesImplicitConversions.kt
   PROPERTY name:test5 visibility:public modality:FINAL [val]
     FIELD PROPERTY_BACKING_FIELD name:test5 type:kotlin.Short visibility:private [final,static]
       EXPRESSION_BODY
-        CALL 'public final fun unaryMinus (): kotlin.Int [operator] declared in kotlin.Int' type=kotlin.Short origin=null
+        CALL 'public final fun unaryMinus (): kotlin.Int [operator] declared in kotlin.Int' type=kotlin.Int origin=null
           $this: CONST Int type=kotlin.Int value=42
     FUN DEFAULT_PROPERTY_ACCESSOR name:<get-test5> visibility:public modality:FINAL <> () returnType:kotlin.Short
       correspondingProperty: PROPERTY name:test5 visibility:public modality:FINAL [val]
@@ -49,7 +49,7 @@ FILE fqName:<root> fileName:/primitivesImplicitConversions.kt
   PROPERTY name:test6 visibility:public modality:FINAL [val]
     FIELD PROPERTY_BACKING_FIELD name:test6 type:kotlin.Byte visibility:private [final,static]
       EXPRESSION_BODY
-        CALL 'public final fun unaryMinus (): kotlin.Int [operator] declared in kotlin.Int' type=kotlin.Byte origin=null
+        CALL 'public final fun unaryMinus (): kotlin.Int [operator] declared in kotlin.Int' type=kotlin.Int origin=null
           $this: CONST Int type=kotlin.Int value=42
     FUN DEFAULT_PROPERTY_ACCESSOR name:<get-test6> visibility:public modality:FINAL <> () returnType:kotlin.Byte
       correspondingProperty: PROPERTY name:test6 visibility:public modality:FINAL [val]

compiler/testData/ir/irText/stubs/simple.fir.txt

@@ -1,12 +0,0 @@
-FILE fqName:<root> fileName:/simple.kt
-  PROPERTY name:test visibility:public modality:FINAL [val]
-    FIELD PROPERTY_BACKING_FIELD name:test type:kotlin.Int visibility:private [final,static]
-      EXPRESSION_BODY
-        CALL 'public final fun plus (other: kotlin.Int): kotlin.Int [operator] declared in kotlin.Int' type=kotlin.Int origin=null
-          $this: CONST Int type=kotlin.Int value=2
-          other: CONST Int type=kotlin.Int value=2
-    FUN DEFAULT_PROPERTY_ACCESSOR name:<get-test> visibility:public modality:FINAL <> () returnType:kotlin.Int
-      correspondingProperty: PROPERTY name:test visibility:public modality:FINAL [val]
-      BLOCK_BODY
-        RETURN type=kotlin.Nothing from='public final fun <get-test> (): kotlin.Int declared in <root>'
-          GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:test type:kotlin.Int visibility:private [final,static]' type=kotlin.Int origin=null

compiler/testData/ir/irText/stubs/simple.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DUMP_DEPENDENCIES
 
 val test = 2 + 2