From 3afc37438e6bc068590946328bda385588496c00 Mon Sep 17 00:00:00 2001
From: Jinseong Jeon <jsjeon@google.com>
Date: Mon, 6 Jul 2020 23:43:00 -0700
Subject: [PATCH] FIR: handle getClassCall with integer literals

---
 .../FirExpressionsResolveTransformer.kt       | 40 +++++++++++++------
 .../classLiteralOnInlineClass.kt              |  1 -
 .../javaClassIntrinsicOnInlineClasses.kt      |  1 -
 3 files changed, 27 insertions(+), 15 deletions(-)

diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt
index f8f0a498e9d..4abc5844d1d 100644
--- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt
+++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt
@@ -565,7 +565,13 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform
     }
 
     override fun transformGetClassCall(getClassCall: FirGetClassCall, data: ResolutionMode): CompositeTransformResult<FirStatement> {
-        val transformedGetClassCall = transformExpression(getClassCall, data).single as FirGetClassCall
+        val arg = getClassCall.argument
+        val dataWithExpectedType = if (arg is FirConstExpression<*>) {
+            withExpectedType(arg.typeRef.resolvedTypeFromPrototype(arg.kind.expectedConeType()))
+        } else {
+            data
+        }
+        val transformedGetClassCall = transformExpression(getClassCall, dataWithExpectedType).single as FirGetClassCall
 
         val typeOfExpression = when (val lhs = transformedGetClassCall.argument) {
             is FirResolvedQualifier -> {
@@ -604,17 +610,12 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform
         return transformedGetClassCall.compose()
     }
 
-    override fun <T> transformConstExpression(
-        constExpression: FirConstExpression<T>,
-        data: ResolutionMode,
-    ): CompositeTransformResult<FirStatement> {
-        constExpression.annotations.forEach { it.accept(this, data) }
+    private fun FirConstKind<*>.expectedConeType(): ConeKotlinType {
         fun constructLiteralType(classId: ClassId, isNullable: Boolean = false): ConeKotlinType {
             val symbol = symbolProvider.getClassLikeSymbolByFqName(classId) ?: return ConeClassErrorType("Missing stdlib class: $classId")
             return symbol.toLookupTag().constructClassType(emptyArray(), isNullable)
         }
-
-        val type = when (val kind = constExpression.kind) {
+        return when (this) {
             FirConstKind.Null -> session.builtinTypes.nullableNothingType.type
             FirConstKind.Boolean -> session.builtinTypes.booleanType.type
             FirConstKind.Char -> constructLiteralType(StandardClassIds.Char)
@@ -626,6 +627,23 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform
             FirConstKind.Float -> constructLiteralType(StandardClassIds.Float)
             FirConstKind.Double -> constructLiteralType(StandardClassIds.Double)
 
+            FirConstKind.UnsignedByte -> constructLiteralType(StandardClassIds.UByte)
+            FirConstKind.UnsignedShort -> constructLiteralType(StandardClassIds.UShort)
+            FirConstKind.UnsignedInt -> constructLiteralType(StandardClassIds.UInt)
+            FirConstKind.UnsignedLong -> constructLiteralType(StandardClassIds.ULong)
+
+            FirConstKind.IntegerLiteral -> constructLiteralType(StandardClassIds.Int)
+            FirConstKind.UnsignedIntegerLiteral -> constructLiteralType(StandardClassIds.UInt)
+        }
+    }
+
+    override fun <T> transformConstExpression(
+        constExpression: FirConstExpression<T>,
+        data: ResolutionMode,
+    ): CompositeTransformResult<FirStatement> {
+        constExpression.annotations.forEach { it.accept(this, data) }
+
+        val type = when (val kind = constExpression.kind) {
             FirConstKind.IntegerLiteral, FirConstKind.UnsignedIntegerLiteral -> {
                 val integerLiteralType =
                     ConeIntegerLiteralTypeImpl(constExpression.value as Long, isUnsigned = kind == FirConstKind.UnsignedIntegerLiteral)
@@ -650,11 +668,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform
                     integerLiteralType
                 }
             }
-
-            FirConstKind.UnsignedByte -> constructLiteralType(StandardClassIds.UByte)
-            FirConstKind.UnsignedShort -> constructLiteralType(StandardClassIds.UShort)
-            FirConstKind.UnsignedInt -> constructLiteralType(StandardClassIds.UInt)
-            FirConstKind.UnsignedLong -> constructLiteralType(StandardClassIds.ULong)
+            else -> kind.expectedConeType()
         }
 
         dataFlowAnalyzer.exitConstExpresion(constExpression as FirConstExpression<*>)
diff --git a/compiler/testData/codegen/box/inlineClasses/classLiteralOnInlineClass.kt b/compiler/testData/codegen/box/inlineClasses/classLiteralOnInlineClass.kt
index 7273a3412d7..8122f6b490d 100644
--- a/compiler/testData/codegen/box/inlineClasses/classLiteralOnInlineClass.kt
+++ b/compiler/testData/codegen/box/inlineClasses/classLiteralOnInlineClass.kt
@@ -1,4 +1,3 @@
-// IGNORE_BACKEND_FIR: JVM_IR
 // WITH_REFLECT
 // TARGET_BACKEND: JVM
 
diff --git a/compiler/testData/codegen/box/inlineClasses/javaClassIntrinsicOnInlineClasses.kt b/compiler/testData/codegen/box/inlineClasses/javaClassIntrinsicOnInlineClasses.kt
index f7a97d96559..58684a82a0a 100644
--- a/compiler/testData/codegen/box/inlineClasses/javaClassIntrinsicOnInlineClasses.kt
+++ b/compiler/testData/codegen/box/inlineClasses/javaClassIntrinsicOnInlineClasses.kt
@@ -1,4 +1,3 @@
-// IGNORE_BACKEND_FIR: JVM_IR
 // WITH_RUNTIME
 // TARGET_BACKEND: JVM