From 782d5e86f63ebd43f09f9e332dca544e4a97b886 Mon Sep 17 00:00:00 2001
From: Ivan Kylchik <ivan.kylchik@jetbrains.com>
Date: Wed, 2 Aug 2023 18:52:50 +0200
Subject: [PATCH] [IR] Replace `reference*` with `toIrSymbol` in
 `IrBuiltinsOverDescriptors`

This change is a minor refactoring that introduces `toIrSymbol`
method for function and property descriptors, like it is done for
class descriptor.
---
 .../descriptors/IrBuiltInsOverDescriptors.kt  | 30 ++++++++++++-------
 1 file changed, 19 insertions(+), 11 deletions(-)

diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/descriptors/IrBuiltInsOverDescriptors.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/descriptors/IrBuiltInsOverDescriptors.kt
index 013d08dd443..39bbc986924 100644
--- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/descriptors/IrBuiltInsOverDescriptors.kt
+++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/descriptors/IrBuiltInsOverDescriptors.kt
@@ -96,6 +96,14 @@ class IrBuiltInsOverDescriptors(
         return symbolTable.descriptorExtension.referenceClass(this)
     }
 
+    private fun FunctionDescriptor.toIrSymbol(): IrSimpleFunctionSymbol {
+        return symbolTable.descriptorExtension.referenceSimpleFunction(this)
+    }
+
+    private fun PropertyDescriptor.toIrSymbol(): IrPropertySymbol {
+        return symbolTable.descriptorExtension.referenceProperty(this)
+    }
+
     private fun KotlinType.toIrType() = typeTranslator.translateType(this)
 
     private fun defineOperator(
@@ -464,7 +472,7 @@ class IrBuiltInsOverDescriptors(
 
     val booleanNot =
         builtIns.boolean.unsubstitutedMemberScope.getContributedFunctions(Name.identifier("not"), NoLookupLocation.FROM_BACKEND).single()
-    override val booleanNotSymbol = symbolTable.descriptorExtension.referenceSimpleFunction(booleanNot)
+    override val booleanNotSymbol = booleanNot.toIrSymbol()
 
     override val eqeqeqSymbol = defineOperator(BuiltInOperatorNames.EQEQEQ, booleanType, listOf(anyNType, anyNType))
     override val eqeqSymbol = defineOperator(BuiltInOperatorNames.EQEQ, booleanType, listOf(anyNType, anyNType), isIntrinsicConst = true)
@@ -489,17 +497,17 @@ class IrBuiltInsOverDescriptors(
     override val intTimesSymbol: IrSimpleFunctionSymbol =
         builtIns.int.unsubstitutedMemberScope.findFirstFunction("times") {
             KotlinTypeChecker.DEFAULT.equalTypes(it.valueParameters[0].type, int)
-        }.let { symbolTable.descriptorExtension.referenceSimpleFunction(it) }
+        }.toIrSymbol()
 
     override val intXorSymbol: IrSimpleFunctionSymbol =
         builtIns.int.unsubstitutedMemberScope.findFirstFunction("xor") {
             KotlinTypeChecker.DEFAULT.equalTypes(it.valueParameters[0].type, int)
-        }.let { symbolTable.descriptorExtension.referenceSimpleFunction(it) }
+        }.toIrSymbol()
 
     override val intPlusSymbol: IrSimpleFunctionSymbol =
         builtIns.int.unsubstitutedMemberScope.findFirstFunction("plus") {
             KotlinTypeChecker.DEFAULT.equalTypes(it.valueParameters[0].type, int)
-        }.let { symbolTable.descriptorExtension.referenceSimpleFunction(it) }
+        }.toIrSymbol()
 
     override val arrayOf = findFunctions(Name.identifier("arrayOf")).first {
         it.descriptor.extensionReceiverParameter == null && it.descriptor.dispatchReceiverParameter == null &&
@@ -520,27 +528,27 @@ class IrBuiltInsOverDescriptors(
 
     override fun findFunctions(name: Name, vararg packageNameSegments: String): Iterable<IrSimpleFunctionSymbol> =
         builtInsPackage(*packageNameSegments).getContributedFunctions(name, NoLookupLocation.FROM_BACKEND).map {
-            symbolTable.descriptorExtension.referenceSimpleFunction(it)
+            it.toIrSymbol()
         }
 
     override fun findFunctions(name: Name, packageFqName: FqName): Iterable<IrSimpleFunctionSymbol> =
         builtIns.builtInsModule.getPackage(packageFqName).memberScope.getContributedFunctions(name, NoLookupLocation.FROM_BACKEND).map {
-            symbolTable.descriptorExtension.referenceSimpleFunction(it)
+            it.toIrSymbol()
         }
 
     override fun findProperties(name: Name, packageFqName: FqName): Iterable<IrPropertySymbol> =
         builtIns.builtInsModule.getPackage(packageFqName).memberScope.getContributedVariables(name, NoLookupLocation.FROM_BACKEND).map {
-            symbolTable.descriptorExtension.referenceProperty(it)
+            it.toIrSymbol()
         }
 
     override fun findClass(name: Name, vararg packageNameSegments: String): IrClassSymbol? =
         (builtInsPackage(*packageNameSegments).getContributedClassifier(
             name,
             NoLookupLocation.FROM_BACKEND
-        ) as? ClassDescriptor)?.let { symbolTable.descriptorExtension.referenceClass(it) }
+        ) as? ClassDescriptor)?.toIrSymbol()
 
     override fun findClass(name: Name, packageFqName: FqName): IrClassSymbol? =
-        findClassDescriptor(name, packageFqName)?.let { symbolTable.descriptorExtension.referenceClass(it) }
+        findClassDescriptor(name, packageFqName)?.toIrSymbol()
 
     fun findClassDescriptor(name: Name, packageFqName: FqName): ClassDescriptor? =
         builtIns.builtInsModule.getPackage(packageFqName).memberScope.getContributedClassifier(
@@ -551,7 +559,7 @@ class IrBuiltInsOverDescriptors(
     override fun findBuiltInClassMemberFunctions(builtInClass: IrClassSymbol, name: Name): Iterable<IrSimpleFunctionSymbol> =
         builtInClass.descriptor.unsubstitutedMemberScope
             .getContributedFunctions(name, NoLookupLocation.FROM_BACKEND)
-            .map { symbolTable.descriptorExtension.referenceSimpleFunction(it) }
+            .map { it.toIrSymbol() }
 
     private val binaryOperatorCache = mutableMapOf<Triple<Name, IrType, IrType>, IrSimpleFunctionSymbol>()
 
@@ -595,7 +603,7 @@ class IrBuiltInsOverDescriptors(
         val result = mutableMapOf<T, IrSimpleFunctionSymbol>()
         for (d in builtInsPackage(*packageNameSegments).getContributedFunctions(name, NoLookupLocation.FROM_BACKEND)) {
             makeKey(d)?.let { key ->
-                result[key] = symbolTable.descriptorExtension.referenceSimpleFunction(d)
+                result[key] = d.toIrSymbol()
             }
         }
         return result