diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/SymbolTable.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/SymbolTable.kt
index b676d5994bc..1c48071232b 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/SymbolTable.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/SymbolTable.kt
@@ -72,7 +72,8 @@ open class SymbolTable(
     @Suppress("LeakingThis")
     val lazyWrapper = IrLazySymbolTable(this)
 
-    protected abstract class SymbolTableBase<D : DeclarationDescriptor, B : IrSymbolOwner, S : IrBindableSymbol<D, B>>(val lock: IrLock) {
+    @Suppress("DuplicatedCode")
+    private abstract class SymbolTableBase<D : DeclarationDescriptor, B : IrSymbolOwner, S : IrBindableSymbol<D, B>>(val lock: IrLock) {
         val unboundSymbols = linkedSetOf<S>()
 
         abstract fun get(d: D): S?
@@ -82,13 +83,9 @@ open class SymbolTable(
 
         inline fun declare(d: D, createSymbol: () -> S, createOwner: (S) -> B): B {
             synchronized(lock) {
-                @Suppress("UNCHECKED_CAST")
-                val d0 = d.original as D
-                assert(d0 === d) {
-                    "Non-original descriptor in declaration: $d\n\tExpected: $d0"
-                }
-                val existing = get(d0)
+                val existing = get(d)
                 val symbol = if (existing == null) {
+                    checkOriginal(d)
                     val new = createSymbol()
                     set(new)
                     new
@@ -100,7 +97,6 @@ open class SymbolTable(
             }
         }
 
-        @OptIn(ObsoleteDescriptorBasedAPI::class)
         inline fun declare(sig: IdSignature, createSymbol: () -> S, createOwner: (S) -> B): B {
             synchronized(lock) {
                 val existing = get(sig)
@@ -119,13 +115,9 @@ open class SymbolTable(
 
         inline fun declareIfNotExists(d: D, createSymbol: () -> S, createOwner: (S) -> B): B {
             synchronized(lock) {
-                @Suppress("UNCHECKED_CAST")
-                val d0 = d.original as D
-                assert(d0 === d) {
-                    "Non-original descriptor in declaration: $d\n\tExpected: $d0"
-                }
-                val existing = get(d0)
+                val existing = get(d)
                 val symbol = if (existing == null) {
+                    checkOriginal(d)
                     val new = createSymbol()
                     set(new)
                     new
@@ -139,13 +131,9 @@ open class SymbolTable(
 
         inline fun declare(sig: IdSignature, d: D?, createSymbol: () -> S, createOwner: (S) -> B): B {
             synchronized(lock) {
-                @Suppress("UNCHECKED_CAST")
-                val d0 = d?.original as D
-                assert(d0 === d) {
-                    "Non-original descriptor in declaration: $d\n\tExpected: $d0"
-                }
                 val existing = get(sig)
                 val symbol = if (existing == null) {
+                    checkOriginal(d)
                     val new = createSymbol()
                     set(new)
                     new
@@ -157,36 +145,11 @@ open class SymbolTable(
             }
         }
 
-        inline fun declareIfNotExists(sig: IdSignature, d: D?, createSymbol: () -> S, createOwner: (S) -> B): B {
-            synchronized(lock) {
-                @Suppress("UNCHECKED_CAST")
-                val d0 = d?.original as D
-                assert(d0 === d) {
-                    "Non-original descriptor in declaration: $d\n\tExpected: $d0"
-                }
-                val existing = get(sig)
-                val symbol = if (existing == null) {
-                    val new = createSymbol()
-                    set(new)
-                    new
-                } else {
-                    if (!existing.isBound) unboundSymbols.remove(existing)
-                    existing
-                }
-                return if (symbol.isBound) symbol.owner else createOwner(symbol)
-            }
-        }
-
-
         inline fun referenced(d: D, reg: Boolean = true, orElse: () -> S): S {
             synchronized(lock) {
-                @Suppress("UNCHECKED_CAST")
-                val d0 = d.original as D
-                assert(d0 === d) {
-                    "Non-original descriptor in declaration: $d\n\tExpected: $d0"
-                }
-                val s = get(d0)
+                val s = get(d)
                 if (s == null) {
+                    checkOriginal(d)
                     val new = orElse()
                     if (reg) {
                         assert(unboundSymbols.add(new)) {
@@ -200,7 +163,6 @@ open class SymbolTable(
             }
         }
 
-        @OptIn(ObsoleteDescriptorBasedAPI::class)
         inline fun referenced(sig: IdSignature, reg: Boolean = true, orElse: () -> S): S {
             synchronized(lock) {
                 return get(sig) ?: run {
@@ -215,6 +177,14 @@ open class SymbolTable(
                 }
             }
         }
+
+        private fun checkOriginal(d: D?) {
+            @Suppress("UNCHECKED_CAST")
+            val d0 = d?.original as D
+            assert(d0 === d) {
+                "Non-original descriptor in declaration: $d\n\tExpected: $d0"
+            }
+        }
     }
 
     private open inner class FlatSymbolTable<D : DeclarationDescriptor, B : IrSymbolOwner, S : IrBindableSymbol<D, B>> :
@@ -418,10 +388,6 @@ open class SymbolTable(
         )
     }
 
-    private fun createAnonymousInitializerSymbol(descriptor: ClassDescriptor): IrAnonymousInitializerSymbol {
-        return IrAnonymousInitializerSymbolImpl(descriptor)
-    }
-
     fun declareAnonymousInitializer(
         startOffset: Int,
         endOffset: Int,
@@ -554,7 +520,10 @@ open class SymbolTable(
         )
     }
 
-    fun declareConstructorIfNotExists(descriptor: ClassConstructorDescriptor, constructorFactory: (IrConstructorSymbol) -> IrConstructor): IrConstructor =
+    fun declareConstructorIfNotExists(
+        descriptor: ClassConstructorDescriptor,
+        constructorFactory: (IrConstructorSymbol) -> IrConstructor,
+    ): IrConstructor =
         constructorSymbolTable.declareIfNotExists(
             descriptor,
             { createConstructorSymbol(descriptor) },
@@ -807,20 +776,6 @@ open class SymbolTable(
     override fun referenceTypeAlias(descriptor: TypeAliasDescriptor): IrTypeAliasSymbol =
         typeAliasSymbolTable.referenced(descriptor) { createTypeAliasSymbol(descriptor) }
 
-    fun declareTypeAliasFromLinker(
-        descriptor: TypeAliasDescriptor,
-        sig: IdSignature,
-        factory: (IrTypeAliasSymbol) -> IrTypeAlias
-    ): IrTypeAlias {
-        return typeAliasSymbolTable.run {
-            if (sig.isPubliclyVisible) {
-                declare(sig, descriptor, { IrTypeAliasPublicSymbolImpl(sig, descriptor) }, factory)
-            } else {
-                declare(descriptor, { IrTypeAliasSymbolImpl(descriptor) }, factory)
-            }
-        }
-    }
-
     override fun referenceTypeAliasFromLinker(sig: IdSignature) =
         typeAliasSymbolTable.run {
             if (sig.isPubliclyVisible) referenced(sig, false) { IrTypeAliasPublicSymbolImpl(sig) }
@@ -942,18 +897,6 @@ open class SymbolTable(
         return globalTypeParameterSymbolTable.declare(sig, symbolFactory, typeParameterFactory)
     }
 
-    fun declareGlobalTypeParameterFromLinker(
-        descriptor: TypeParameterDescriptor,
-        sig: IdSignature,
-        typeParameterFactory: (IrTypeParameterSymbol) -> IrTypeParameter
-    ): IrTypeParameter {
-        return globalTypeParameterSymbolTable.declare(
-            descriptor,
-            { if (sig.isPubliclyVisible) IrTypeParameterPublicSymbolImpl(sig, descriptor) else IrTypeParameterSymbolImpl(descriptor) },
-            typeParameterFactory
-        )
-    }
-
     @OptIn(ObsoleteDescriptorBasedAPI::class)
     fun declareScopedTypeParameter(
         startOffset: Int,
@@ -987,7 +930,13 @@ open class SymbolTable(
         sig: IdSignature,
         typeParameterFactory: (IrTypeParameterSymbol) -> IrTypeParameter
     ): IrTypeParameter {
-        return scopedTypeParameterSymbolTable.declare(descriptor, { if (sig.isPubliclyVisible) IrTypeParameterPublicSymbolImpl(sig, descriptor) else IrTypeParameterSymbolImpl(descriptor) }, typeParameterFactory)
+        return scopedTypeParameterSymbolTable.declare(
+            descriptor,
+            {
+                if (sig.isPubliclyVisible) IrTypeParameterPublicSymbolImpl(sig, descriptor)
+                else IrTypeParameterSymbolImpl(descriptor)
+            }, typeParameterFactory
+        )
     }
 
     val unboundTypeParameters: Set<IrTypeParameterSymbol> get() = globalTypeParameterSymbolTable.unboundSymbols