[JS IR BE] Lower property accessors in PrimitiveCompanionLowering

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/PrimitiveCompanionLowering.kt

@@ -9,27 +9,73 @@ import org.jetbrains.kotlin.backend.common.FileLoweringPass
 import org.jetbrains.kotlin.ir.backend.js.JsIrBackendContext
 import org.jetbrains.kotlin.ir.declarations.IrClass
 import org.jetbrains.kotlin.ir.declarations.IrFile
+import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
+import org.jetbrains.kotlin.ir.expressions.IrCall
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.IrGetObjectValue
 import org.jetbrains.kotlin.ir.expressions.impl.IrGetObjectValueImpl
 import org.jetbrains.kotlin.ir.types.isPrimitiveType
 import org.jetbrains.kotlin.ir.types.isString
 import org.jetbrains.kotlin.ir.util.defaultType
+import org.jetbrains.kotlin.ir.util.irCall
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid
 import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid
 
 class PrimitiveCompanionLowering(val context: JsIrBackendContext) : FileLoweringPass {
+
+    private fun getActualPrimitiveCompanion(irClass: IrClass): IrClass? {
+        if (!irClass.isCompanion)
+            return null
+
+        val parent = irClass.parent as IrClass
+
+        if (!parent.defaultType.isPrimitiveType() && !parent.defaultType.isString())
+            return null
+
+        return context.primitiveCompanionObjects[parent.name]?.owner
+    }
+
+    private fun getActualPrimitiveCompanionPropertyAccessor(function: IrSimpleFunction): IrSimpleFunction? {
+        val property = function.correspondingPropertySymbol?.owner
+            ?: return null
+
+        val companion = property.parent as? IrClass
+            ?: return null
+
+        val actualCompanion = getActualPrimitiveCompanion(companion)
+            ?: return null
+
+        val actualFunction =
+            actualCompanion.declarations
+                .filterIsInstance<IrSimpleFunction>()
+                .find { it.name == function.name }
+
+        return actualFunction!!
+    }
+
     override fun lower(irFile: IrFile) {
         irFile.transformChildrenVoid(object : IrElementTransformerVoid() {
             override fun visitGetObjectValue(expression: IrGetObjectValue): IrExpression {
-                val symbol = expression.symbol
+                val irClass = expression.symbol.owner
-                if (!symbol.isBound) return expression
+                val actualCompanion = getActualPrimitiveCompanion(irClass) ?: return expression
-                val declaration = symbol.owner
+                return IrGetObjectValueImpl(
-                if (!declaration.isCompanion) return expression
+                    expression.startOffset,
-                val parent = declaration.parent as IrClass
+                    expression.endOffset,
-                if (!parent.defaultType.isPrimitiveType() && !parent.defaultType.isString()) return expression
+                    actualCompanion.defaultType,
-                val actualCompanion = context.primitiveCompanionObjects[parent.name] ?: return expression
+                    actualCompanion.symbol
-                return expression.run { IrGetObjectValueImpl(startOffset, endOffset, actualCompanion.owner.defaultType, actualCompanion) }
+                )
+            }
+
+            override fun visitCall(expression: IrCall): IrExpression {
+                val newCall = super.visitCall(expression) as IrCall
+
+                val function = expression.symbol.owner as? IrSimpleFunction
+                    ?: return newCall
+
+                val actualFunction = getActualPrimitiveCompanionPropertyAccessor(function)
+                    ?: return newCall
+
+                return irCall(newCall, actualFunction)
             }
         })
     }