Adapt to removal of WrappedDescriptors in master

(cherry picked from commit 2fe4105acfa0487f49b31ef90cb01249f8c9a137)

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/Boxing.kt

@@ -14,8 +14,6 @@ import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.impl.IrFunctionImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrValueParameterImpl
 import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
-import org.jetbrains.kotlin.ir.descriptors.WrappedSimpleFunctionDescriptor
-import org.jetbrains.kotlin.ir.descriptors.WrappedValueParameterDescriptor
 import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
 import org.jetbrains.kotlin.ir.symbols.impl.IrSimpleFunctionSymbolImpl
 import org.jetbrains.kotlin.ir.symbols.impl.IrValueParameterSymbolImpl
@@ -59,11 +57,10 @@ internal val Context.getBoxFunction: (IrClass) -> IrSimpleFunction by Context.la
     val startOffset = inlinedClass.startOffset
     val endOffset = inlinedClass.endOffset
 
-    val descriptor = WrappedSimpleFunctionDescriptor()
     IrFunctionImpl(
             startOffset, endOffset,
             DECLARATION_ORIGIN_INLINE_CLASS_SPECIAL_FUNCTION,
-            IrSimpleFunctionSymbolImpl(descriptor),
+            IrSimpleFunctionSymbolImpl(),
             Name.special("<${inlinedClass.name}-box>"),
             DescriptorVisibilities.PUBLIC,
             Modality.FINAL,
@@ -77,11 +74,11 @@ internal val Context.getBoxFunction: (IrClass) -> IrSimpleFunction by Context.la
             isOperator = false,
             isInfix = false
     ).also { function ->
-        function.valueParameters = listOf(WrappedValueParameterDescriptor().let {
+        function.valueParameters = listOf(
             IrValueParameterImpl(
                     startOffset, endOffset,
                     IrDeclarationOrigin.DEFINED,
-                    IrValueParameterSymbolImpl(it),
+                    IrValueParameterSymbolImpl(),
                     Name.identifier("value"),
                     index = 0,
                     varargElementType = null,
@@ -91,11 +88,8 @@ internal val Context.getBoxFunction: (IrClass) -> IrSimpleFunction by Context.la
                     isHidden = false,
                     isAssignable = false
             ).apply {
-                it.bind(this)
                 parent = function
-            }
-        })
-        descriptor.bind(function)
+            })
         function.parent = inlinedClass.getContainingFile()!!
     }
 }
@@ -116,11 +110,10 @@ internal val Context.getUnboxFunction: (IrClass) -> IrSimpleFunction by Context.
     val startOffset = inlinedClass.startOffset
     val endOffset = inlinedClass.endOffset
 
-    val descriptor = WrappedSimpleFunctionDescriptor()
     IrFunctionImpl(
             startOffset, endOffset,
             DECLARATION_ORIGIN_INLINE_CLASS_SPECIAL_FUNCTION,
-            IrSimpleFunctionSymbolImpl(descriptor),
+            IrSimpleFunctionSymbolImpl(),
             Name.special("<${inlinedClass.name}-unbox>"),
             DescriptorVisibilities.PUBLIC,
             Modality.FINAL,
@@ -134,11 +127,11 @@ internal val Context.getUnboxFunction: (IrClass) -> IrSimpleFunction by Context.
             isOperator = false,
             isInfix = false
     ).also { function ->
-        function.valueParameters = listOf(WrappedValueParameterDescriptor().let {
+        function.valueParameters = listOf(
             IrValueParameterImpl(
                     startOffset, endOffset,
                     IrDeclarationOrigin.DEFINED,
-                    IrValueParameterSymbolImpl(it),
+                    IrValueParameterSymbolImpl(),
                     Name.identifier("value"),
                     index = 0,
                     varargElementType = null,
@@ -148,11 +141,8 @@ internal val Context.getUnboxFunction: (IrClass) -> IrSimpleFunction by Context.
                     isHidden = false,
                     isAssignable = false
             ).apply {
-                it.bind(this)
                 parent = function
-            }
-        })
-        descriptor.bind(function)
+            })
         function.parent = inlinedClass.getContainingFile()!!
     }
 }

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/Context.kt

@@ -41,7 +41,6 @@ import org.jetbrains.kotlin.backend.common.ir.copyToWithoutSuperTypes
 import org.jetbrains.kotlin.backend.konan.objcexport.ObjCExport
 import org.jetbrains.kotlin.backend.konan.llvm.coverage.CoverageManager
 import org.jetbrains.kotlin.ir.declarations.lazy.IrLazyClass
-import org.jetbrains.kotlin.ir.descriptors.WrappedSimpleFunctionDescriptor
 import org.jetbrains.kotlin.ir.symbols.IrSymbol
 import org.jetbrains.kotlin.ir.symbols.impl.IrFieldSymbolImpl
 import org.jetbrains.kotlin.name.FqName
@@ -138,7 +137,7 @@ internal class SpecialDeclarationsFactory(val context: Context) {
         return bridges.getOrPut(key) { createBridge(key) }
     }
 
-    private fun createBridge(key: BridgeKey): IrSimpleFunction = WrappedSimpleFunctionDescriptor().let { descriptor ->
+    private fun createBridge(key: BridgeKey): IrSimpleFunction {
         val (function, bridgeDirections) = key
         val startOffset = function.startOffset
         val endOffset = function.endOffset
@@ -148,10 +147,10 @@ internal class SpecialDeclarationsFactory(val context: Context) {
                     null
                 else this.irClass?.defaultType ?: context.irBuiltIns.anyNType
 
-        IrFunctionImpl(
+        return IrFunctionImpl(
                 startOffset, endOffset,
                 DECLARATION_ORIGIN_BRIDGE_METHOD(function),
-                IrSimpleFunctionSymbolImpl(descriptor),
+                IrSimpleFunctionSymbolImpl(),
                 "<bridge-$bridgeDirections>${function.computeFunctionName()}".synthesizedName,
                 function.visibility,
                 function.modality,
@@ -166,7 +165,6 @@ internal class SpecialDeclarationsFactory(val context: Context) {
                 isInfix = false
         ).apply {
             val bridge = this
-            descriptor.bind(bridge)
             parent = function.parent
 
             dispatchReceiverParameter = function.dispatchReceiverParameter?.let {

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/EntryPoint.kt

@@ -15,8 +15,6 @@ import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
 import org.jetbrains.kotlin.ir.declarations.IrFunction
 import org.jetbrains.kotlin.ir.declarations.impl.IrFunctionImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrValueParameterImpl
-import org.jetbrains.kotlin.ir.descriptors.WrappedSimpleFunctionDescriptor
-import org.jetbrains.kotlin.ir.descriptors.WrappedValueParameterDescriptor
 import org.jetbrains.kotlin.ir.expressions.impl.IrTryImpl
 import org.jetbrains.kotlin.ir.symbols.impl.IrSimpleFunctionSymbolImpl
 import org.jetbrains.kotlin.ir.symbols.impl.IrValueParameterSymbolImpl
@@ -25,13 +23,12 @@ import org.jetbrains.kotlin.ir.util.irCatch
 import org.jetbrains.kotlin.name.Name
 
 internal fun makeEntryPoint(context: Context): IrFunction {
-    val entryPointDescriptor = WrappedSimpleFunctionDescriptor()
     val actualMain = context.ir.symbols.entryPoint!!.owner
     val entryPoint = IrFunctionImpl(
             actualMain.startOffset,
             actualMain.startOffset,
             IrDeclarationOrigin.DEFINED,
-            IrSimpleFunctionSymbolImpl(entryPointDescriptor),
+            IrSimpleFunctionSymbolImpl(),
             Name.identifier("Konan_start"),
             DescriptorVisibilities.PRIVATE,
             Modality.FINAL,
@@ -45,11 +42,11 @@ internal fun makeEntryPoint(context: Context): IrFunction {
             isOperator = false,
             isInfix = false
     ).also { function ->
-        function.valueParameters = listOf(WrappedValueParameterDescriptor().let {
+        function.valueParameters = listOf(
             IrValueParameterImpl(
                     actualMain.startOffset, actualMain.startOffset,
                     IrDeclarationOrigin.DEFINED,
-                    IrValueParameterSymbolImpl(it),
+                    IrValueParameterSymbolImpl(),
                     Name.identifier("args"),
                     index = 0,
                     varargElementType = null,
@@ -59,12 +56,9 @@ internal fun makeEntryPoint(context: Context): IrFunction {
                     isHidden = false,
                     isAssignable = false
             ).apply {
-                it.bind(this)
                 parent = function
-            }
-        })
+            })
     }
-    entryPointDescriptor.bind(entryPoint)
     entryPoint.annotations += buildSimpleAnnotation(context.irBuiltIns,
             actualMain.startOffset, actualMain.startOffset,
             context.ir.symbols.exportForCppRuntime.owner, "Konan_start")

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/EnumSpecialDescriptorsFactory.kt

@@ -22,9 +22,6 @@ import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.impl.IrClassImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrFieldImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrFunctionImpl
-import org.jetbrains.kotlin.ir.descriptors.WrappedClassDescriptor
-import org.jetbrains.kotlin.ir.descriptors.WrappedFieldDescriptor
-import org.jetbrains.kotlin.ir.descriptors.WrappedSimpleFunctionDescriptor
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrGetFieldImpl
@@ -135,11 +132,11 @@ internal class EnumSpecialDeclarationsFactory(val context: Context) {
         val startOffset = enumClass.startOffset
         val endOffset = enumClass.endOffset
 
-        val implObject = WrappedClassDescriptor().let {
+        val implObject =
             IrClassImpl(
                     startOffset, endOffset,
                     DECLARATION_ORIGIN_ENUM,
-                    IrClassSymbolImpl(it),
+                    IrClassSymbolImpl(),
                     "OBJECT".synthesizedName,
                     ClassKind.OBJECT,
                     DescriptorVisibilities.PUBLIC,
@@ -152,18 +149,16 @@ internal class EnumSpecialDeclarationsFactory(val context: Context) {
                     isExpect = false,
                     isFun = false
             ).apply {
-                it.bind(this)
                 parent = enumClass
                 createParameterDeclarations()
             }
-        }
 
         val valuesType = valuesArrayType(enumClass)
-        val valuesField = WrappedFieldDescriptor().let {
+        val valuesField =
             IrFieldImpl(
                     startOffset, endOffset,
                     DECLARATION_ORIGIN_ENUM,
-                    IrFieldSymbolImpl(it),
+                    IrFieldSymbolImpl(),
                     "VALUES".synthesizedName,
                     valuesType,
                     DescriptorVisibilities.PRIVATE,
@@ -171,16 +166,14 @@ internal class EnumSpecialDeclarationsFactory(val context: Context) {
                     isExternal = false,
                     isStatic = false,
             ).apply {
-                it.bind(this)
                 parent = implObject
             }
-        }
 
-        val valuesGetter = WrappedSimpleFunctionDescriptor().let {
+        val valuesGetter =
             IrFunctionImpl(
                     startOffset, endOffset,
                     DECLARATION_ORIGIN_ENUM,
-                    IrSimpleFunctionSymbolImpl(it),
+                    IrSimpleFunctionSymbolImpl(),
                     "get-VALUES".synthesizedName,
                     DescriptorVisibilities.PUBLIC,
                     Modality.FINAL,
@@ -194,10 +187,8 @@ internal class EnumSpecialDeclarationsFactory(val context: Context) {
                     isOperator = false,
                     isInfix = false
             ).apply {
-                it.bind(this)
                 parent = implObject
             }
-        }
 
         val constructorOfAny = context.irBuiltIns.anyClass.owner.constructors.first()
         implObject.addSimpleDelegatingConstructor(

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/cgen/CBridgeGen.kt

@@ -549,12 +549,11 @@ private fun KotlinStubs.createFakeKotlinExternalFunction(
         cFunctionName: String,
         isObjCMethod: Boolean
 ): IrSimpleFunction {
-    val bridgeDescriptor = WrappedSimpleFunctionDescriptor()
     val bridge = IrFunctionImpl(
             UNDEFINED_OFFSET,
             UNDEFINED_OFFSET,
             IrDeclarationOrigin.DEFINED,
-            IrSimpleFunctionSymbolImpl(bridgeDescriptor),
+            IrSimpleFunctionSymbolImpl(),
             Name.identifier(cFunctionName),
             DescriptorVisibilities.PRIVATE,
             Modality.FINAL,
@@ -568,7 +567,6 @@ private fun KotlinStubs.createFakeKotlinExternalFunction(
             isOperator = false,
             isInfix = false
     )
-    bridgeDescriptor.bind(bridge)
 
     bridge.annotations += buildSimpleAnnotation(irBuiltIns, UNDEFINED_OFFSET, UNDEFINED_OFFSET,
             symbols.symbolName.owner, cFunctionName)
@@ -1098,16 +1096,14 @@ private class ObjCBlockPointerValuePassing(
     private fun IrBuilderWithScope.generateKotlinFunctionClass(): IrConstructor {
         val symbols = stubs.symbols
 
-        val classDescriptor = WrappedClassDescriptor()
         val irClass = IrClassImpl(
                 startOffset, endOffset,
-                OBJC_BLOCK_FUNCTION_IMPL, IrClassSymbolImpl(classDescriptor),
+                OBJC_BLOCK_FUNCTION_IMPL, IrClassSymbolImpl(),
                 Name.identifier(stubs.getUniqueKotlinFunctionReferenceClassName("BlockFunctionImpl")),
                 ClassKind.CLASS, DescriptorVisibilities.PRIVATE, Modality.FINAL,
                 isCompanion = false, isInner = false, isData = false, isExternal = false,
                 isInline = false, isExpect = false, isFun = false
         )
-        classDescriptor.bind(irClass)
         irClass.createParameterDeclarations()
 
         irClass.superTypes += stubs.irBuiltIns.anyType
@@ -1121,24 +1117,21 @@ private class ObjCBlockPointerValuePassing(
                 isMutable = false, owner = irClass
         )
 
-        val constructorDescriptor = WrappedClassConstructorDescriptor()
         val constructor = IrConstructorImpl(
                 startOffset, endOffset,
                 OBJC_BLOCK_FUNCTION_IMPL,
-                IrConstructorSymbolImpl(constructorDescriptor),
+                IrConstructorSymbolImpl(),
                 Name.special("<init>"),
                 DescriptorVisibilities.PUBLIC,
                 irClass.defaultType,
                 isInline = false, isExternal = false, isPrimary = true, isExpect = false
         )
-        constructorDescriptor.bind(constructor)
         irClass.addChild(constructor)
 
-        val constructorParameterDescriptor = WrappedValueParameterDescriptor()
         val constructorParameter = IrValueParameterImpl(
                 startOffset, endOffset,
                 OBJC_BLOCK_FUNCTION_IMPL,
-                IrValueParameterSymbolImpl(constructorParameterDescriptor),
+                IrValueParameterSymbolImpl(),
                 Name.identifier("blockPointer"),
                 0,
                 symbols.nativePtrType,
@@ -1148,7 +1141,6 @@ private class ObjCBlockPointerValuePassing(
                 isHidden = false,
                 isAssignable = false
         )
-        constructorParameterDescriptor.bind(constructorParameter)
         constructor.valueParameters += constructorParameter
         constructorParameter.parent = constructor
 
@@ -1166,28 +1158,25 @@ private class ObjCBlockPointerValuePassing(
         val overriddenInvokeMethod = (functionType.classifier.owner as IrClass).simpleFunctions()
                 .single { it.name == OperatorNameConventions.INVOKE }
 
-        val invokeMethodDescriptor = WrappedSimpleFunctionDescriptor()
         val invokeMethod = IrFunctionImpl(
                 startOffset, endOffset,
                 OBJC_BLOCK_FUNCTION_IMPL,
-                IrSimpleFunctionSymbolImpl(invokeMethodDescriptor),
+                IrSimpleFunctionSymbolImpl(),
                 overriddenInvokeMethod.name,
                 DescriptorVisibilities.PUBLIC, Modality.FINAL,
                 returnType = functionType.arguments.last().typeOrNull!!,
                 isInline = false, isExternal = false, isTailrec = false, isSuspend = false, isExpect = false,
                 isFakeOverride = false, isOperator = false, isInfix = false
         )
-        invokeMethodDescriptor.bind(invokeMethod)
         invokeMethod.overriddenSymbols += overriddenInvokeMethod.symbol
         irClass.addChild(invokeMethod)
         invokeMethod.createDispatchReceiverParameter()
 
         invokeMethod.valueParameters += (0 until parameterCount).map { index ->
-            val parameterDescriptor = WrappedValueParameterDescriptor()
             val parameter = IrValueParameterImpl(
                     startOffset, endOffset,
                     OBJC_BLOCK_FUNCTION_IMPL,
-                    IrValueParameterSymbolImpl(parameterDescriptor),
+                    IrValueParameterSymbolImpl(),
                     Name.identifier("p$index"),
                     index,
                     functionType.arguments[index].typeOrNull!!,
@@ -1197,7 +1186,6 @@ private class ObjCBlockPointerValuePassing(
                     isHidden = false,
                     isAssignable = false
             )
-            parameterDescriptor.bind(parameter)
             parameter.parent = invokeMethod
             parameter
         }

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/cgen/CBridgeGenUtils.kt

@@ -15,8 +15,6 @@ import org.jetbrains.kotlin.ir.declarations.IrValueParameter
 import org.jetbrains.kotlin.ir.declarations.IrVariable
 import org.jetbrains.kotlin.ir.declarations.impl.IrFunctionImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrValueParameterImpl
-import org.jetbrains.kotlin.ir.descriptors.WrappedSimpleFunctionDescriptor
-import org.jetbrains.kotlin.ir.descriptors.WrappedValueParameterDescriptor
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression
 import org.jetbrains.kotlin.ir.expressions.impl.IrTryImpl
@@ -81,11 +79,10 @@ internal class KotlinBridgeBuilder(
 
     fun addParameter(type: IrType): IrValueParameter {
         val index = counter++
-        val descriptor = WrappedValueParameterDescriptor()
 
         return IrValueParameterImpl(
                 bridge.startOffset, bridge.endOffset, bridge.origin,
-                IrValueParameterSymbolImpl(descriptor),
+                IrValueParameterSymbolImpl(),
                 Name.identifier("p$index"), index, type,
                 null,
                 isCrossinline = false,
@@ -93,7 +90,6 @@ internal class KotlinBridgeBuilder(
                 isHidden = false,
                 isAssignable = false
         ).apply {
-            descriptor.bind(this)
             parent = bridge
             bridge.valueParameters += this
         }
@@ -114,12 +110,11 @@ private fun createKotlinBridge(
         isExternal: Boolean,
         foreignExceptionMode: ForeignExceptionMode.Mode
 ): IrFunction {
-    val bridgeDescriptor = WrappedSimpleFunctionDescriptor()
     val bridge = IrFunctionImpl(
             startOffset,
             endOffset,
             IrDeclarationOrigin.DEFINED,
-            IrSimpleFunctionSymbolImpl(bridgeDescriptor),
+            IrSimpleFunctionSymbolImpl(),
             Name.identifier(cBridgeName),
             DescriptorVisibilities.PRIVATE,
             Modality.FINAL,
@@ -133,7 +128,6 @@ private fun createKotlinBridge(
             isOperator = false,
             isInfix = false
     )
-    bridgeDescriptor.bind(bridge)
     if (isExternal) {
         bridge.annotations += buildSimpleAnnotation(stubs.irBuiltIns, startOffset, endOffset,
                 stubs.symbols.symbolName.owner, cBridgeName)

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/descriptors/KonanSharedVariablesManager.kt

@@ -12,7 +12,6 @@ import org.jetbrains.kotlin.ir.IrStatement
 import org.jetbrains.kotlin.ir.declarations.IrProperty
 import org.jetbrains.kotlin.ir.declarations.IrVariable
 import org.jetbrains.kotlin.ir.declarations.impl.IrVariableImpl
-import org.jetbrains.kotlin.ir.descriptors.WrappedVariableDescriptor
 import org.jetbrains.kotlin.ir.expressions.IrGetValue
 import org.jetbrains.kotlin.ir.expressions.IrSetValue
 import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl
@@ -44,17 +43,14 @@ internal class KonanSharedVariablesManager(val context: KonanBackendContext) : S
         }
 
         return with(originalDeclaration) {
-            WrappedVariableDescriptor().let {
-                IrVariableImpl(
-                        startOffset, endOffset, origin,
-                        IrVariableSymbolImpl(it), name, refConstructorCall.type,
-                        isVar = false,
-                        isConst = false,
-                        isLateinit = false
-                ).apply {
-                    it.bind(this)
-                    initializer = refConstructorCall
-                }
+            IrVariableImpl(
+                    startOffset, endOffset, origin,
+                    IrVariableSymbolImpl(), name, refConstructorCall.type,
+                    isVar = false,
+                    isConst = false,
+                    isLateinit = false
+            ).apply {
+                initializer = refConstructorCall
             }
         }
     }

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/interop/DescriptorToIrTranslationUtils.kt

@@ -60,7 +60,7 @@ internal interface DescriptorToIrTranslationMixin {
                     SYNTHETIC_OFFSET, SYNTHETIC_OFFSET, IrDeclarationOrigin.IR_EXTERNAL_DECLARATION_STUB, it, descriptor
                 )
             }.also { irClass ->
-                symbolTable.withScope(descriptor) {
+                symbolTable.withScope(irClass) {
                     irClass.superTypes += descriptor.typeConstructor.supertypes.map {
                         it.toIrType()
                     }
@@ -133,7 +133,7 @@ internal interface DescriptorToIrTranslationMixin {
             origin: IrDeclarationOrigin = IrDeclarationOrigin.IR_EXTERNAL_DECLARATION_STUB
     ): IrSimpleFunction {
         val irFunction = symbolTable.declareSimpleFunctionWithOverrides(SYNTHETIC_OFFSET, SYNTHETIC_OFFSET, origin, functionDescriptor)
-        symbolTable.withScope(functionDescriptor) {
+        symbolTable.withScope(irFunction) {
             irFunction.returnType = functionDescriptor.returnType!!.toIrType()
             irFunction.valueParameters +=  functionDescriptor.valueParameters.map {
                 symbolTable.declareValueParameter(SYNTHETIC_OFFSET, SYNTHETIC_OFFSET, IrDeclarationOrigin.DEFINED, it, it.type.toIrType())

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/interop/cenum/CEnumClassGenerator.kt

@@ -93,7 +93,7 @@ internal class CEnumClassGenerator(
                 .findDeclarationByName<PropertyDescriptor>("value")
                 ?: error("No `value` property in ${irClass.name}")
         val irProperty = createProperty(propertyDescriptor)
-        symbolTable.withScope(propertyDescriptor) {
+        symbolTable.withScope(irProperty) {
             irProperty.backingField = symbolTable.declareField(
                     SYNTHETIC_OFFSET, SYNTHETIC_OFFSET, IrDeclarationOrigin.PROPERTY_BACKING_FIELD,
                     propertyDescriptor, propertyDescriptor.type.toIrType(), DescriptorVisibilities.PRIVATE

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/Autoboxing.kt

@@ -20,8 +20,6 @@ import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.impl.IrFieldImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrFunctionImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrPropertyImpl
-import org.jetbrains.kotlin.ir.descriptors.WrappedPropertyDescriptor
-import org.jetbrains.kotlin.ir.descriptors.WrappedSimpleFunctionDescriptor
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl
 import org.jetbrains.kotlin.ir.symbols.*
@@ -414,13 +412,12 @@ private class InlineClassTransformer(private val context: Context) : IrBuildingT
     private fun buildBoxField(declaration: IrClass) {
         val startOffset = declaration.startOffset
         val endOffset = declaration.endOffset
-        val descriptor = WrappedPropertyDescriptor()
 
         val irField = IrFieldImpl(
                 startOffset,
                 endOffset,
                 IrDeclarationOrigin.DEFINED,
-                IrFieldSymbolImpl(descriptor),
+                IrFieldSymbolImpl(),
                 Name.identifier("value"),
                 declaration.defaultType,
                 DescriptorVisibilities.PRIVATE,
@@ -434,7 +431,7 @@ private class InlineClassTransformer(private val context: Context) : IrBuildingT
                 startOffset,
                 endOffset,
                 IrDeclarationOrigin.DEFINED,
-                IrPropertySymbolImpl(descriptor),
+                IrPropertySymbolImpl(),
                 irField.name,
                 irField.visibility,
                 Modality.FINAL,
@@ -444,7 +441,6 @@ private class InlineClassTransformer(private val context: Context) : IrBuildingT
                 isDelegated = false,
                 isExternal = false
         )
-        descriptor.bind(irProperty)
         irProperty.backingField = irField
 
         declaration.addChild(irProperty)
@@ -553,11 +549,10 @@ private val Context.getLoweredInlineClassConstructor: (IrConstructor) -> IrSimpl
         irConstructor.returnType
     }
 
-    val descriptor = WrappedSimpleFunctionDescriptor()
     IrFunctionImpl(
             irConstructor.startOffset, irConstructor.endOffset,
             IrDeclarationOrigin.DEFINED,
-            IrSimpleFunctionSymbolImpl(descriptor),
+            IrSimpleFunctionSymbolImpl(),
             Name.special("<constructor>"),
             irConstructor.visibility,
             Modality.FINAL,
@@ -571,7 +566,6 @@ private val Context.getLoweredInlineClassConstructor: (IrConstructor) -> IrSimpl
             isOperator = false,
             isInfix = false
     ).apply {
-        descriptor.bind(this)
         parent = irConstructor.parent
 
         // Note: technically speaking, this function doesn't have access to class type parameters (since it is "static").

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/BridgesBuilding.kt

@@ -19,8 +19,6 @@ import org.jetbrains.kotlin.ir.builders.*
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.impl.IrFunctionImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrValueParameterImpl
-import org.jetbrains.kotlin.ir.descriptors.WrappedSimpleFunctionDescriptor
-import org.jetbrains.kotlin.ir.descriptors.WrappedValueParameterDescriptor
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.*
 import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
@@ -71,11 +69,11 @@ internal class WorkersBridgesBuilding(val context: Context) : DeclarationContain
                     val arg = jobFunction.valueParameters[0]
                     val startOffset = jobFunction.startOffset
                     val endOffset = jobFunction.endOffset
-                    runtimeJobFunction = WrappedSimpleFunctionDescriptor().let {
+                    runtimeJobFunction =
                         IrFunctionImpl(
                                 startOffset, endOffset,
                                 IrDeclarationOrigin.DEFINED,
-                                IrSimpleFunctionSymbolImpl(it),
+                                IrSimpleFunctionSymbolImpl(),
                                 jobFunction.name,
                                 jobFunction.visibility,
                                 jobFunction.modality,
@@ -88,16 +86,13 @@ internal class WorkersBridgesBuilding(val context: Context) : DeclarationContain
                                 isFakeOverride = false,
                                 isOperator = false,
                                 isInfix = false
-                    ).apply {
-                            it.bind(this)
-                        }
-                    }
+                    )
 
-                    runtimeJobFunction.valueParameters += WrappedValueParameterDescriptor().let {
+                    runtimeJobFunction.valueParameters +=
                         IrValueParameterImpl(
                                 startOffset, endOffset,
                                 IrDeclarationOrigin.DEFINED,
-                                IrValueParameterSymbolImpl(it),
+                                IrValueParameterSymbolImpl(),
                                 arg.name,
                                 arg.index,
                                 type = context.irBuiltIns.anyNType,
@@ -106,8 +101,7 @@ internal class WorkersBridgesBuilding(val context: Context) : DeclarationContain
                                 isNoinline = arg.isNoinline,
                                 isHidden = arg.isHidden,
                                 isAssignable = arg.isAssignable
-                        ).apply { it.bind(this) }
-                    }
+                        )
                 }
                 val overriddenJobDescriptor = OverriddenFunctionInfo(jobFunction, runtimeJobFunction)
                 if (!overriddenJobDescriptor.needBridge) return expression

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/DelegationLowering.kt

@@ -16,7 +16,6 @@ import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.ir.builders.*
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.impl.IrFieldImpl
-import org.jetbrains.kotlin.ir.descriptors.WrappedFieldDescriptor
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.IrLocalDelegatedPropertyReference
 import org.jetbrains.kotlin.ir.expressions.IrPropertyReference
@@ -84,11 +83,11 @@ internal class PropertyDelegationLowering(val context: Context) : FileLoweringPa
 
         val kPropertiesFieldType: IrType = context.ir.symbols.array.typeWith(kPropertyImplType)
 
-        val kPropertiesField = WrappedFieldDescriptor().let {
+        val kPropertiesField =
             IrFieldImpl(
                     SYNTHETIC_OFFSET, SYNTHETIC_OFFSET,
                     DECLARATION_ORIGIN_KPROPERTIES_FOR_DELEGATION,
-                    IrFieldSymbolImpl(it),
+                    IrFieldSymbolImpl(),
                     "KPROPERTIES".synthesizedName,
                     kPropertiesFieldType,
                     DescriptorVisibilities.PRIVATE,
@@ -96,11 +95,9 @@ internal class PropertyDelegationLowering(val context: Context) : FileLoweringPa
                     isExternal = false,
                     isStatic = true,
             ).apply {
-                it.bind(this)
                 parent = irFile
                 annotations += buildSimpleAnnotation(context.irBuiltIns, startOffset, endOffset, context.ir.symbols.sharedImmutable.owner)
             }
-        }
 
         irFile.transformChildrenVoid(object : IrElementTransformerVoidWithContext() {
 

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/EnumConstructorsLowering.kt

@@ -16,8 +16,6 @@ import org.jetbrains.kotlin.ir.IrStatement
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.impl.IrConstructorImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrValueParameterImpl
-import org.jetbrains.kotlin.ir.descriptors.WrappedClassConstructorDescriptor
-import org.jetbrains.kotlin.ir.descriptors.WrappedValueParameterDescriptor
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.*
 import org.jetbrains.kotlin.ir.symbols.IrConstructorSymbol
@@ -109,11 +107,11 @@ internal class EnumConstructorsLowering(val context: Context) : ClassLoweringPas
         private fun lowerEnumConstructor(constructor: IrConstructor): IrConstructor {
             val startOffset = constructor.startOffset
             val endOffset = constructor.endOffset
-            val loweredConstructor = WrappedClassConstructorDescriptor().let {
+            val loweredConstructor =
                 IrConstructorImpl(
                         startOffset, endOffset,
                         constructor.origin,
-                        IrConstructorSymbolImpl(it),
+                        IrConstructorSymbolImpl(),
                         constructor.name,
                         DescriptorVisibilities.PROTECTED,
                         constructor.returnType,
@@ -122,32 +120,27 @@ internal class EnumConstructorsLowering(val context: Context) : ClassLoweringPas
                         isPrimary = constructor.isPrimary,
                         isExpect = false
                 ).apply {
-                    it.bind(this)
                     parent = constructor.parent
                     val body = constructor.body!!
                     this.body = body // Will be transformed later.
                     body.setDeclarationsParent(this)
                 }
-            }
 
             fun createSynthesizedValueParameter(index: Int, name: String, type: IrType): IrValueParameter =
-                    WrappedValueParameterDescriptor().let {
-                        IrValueParameterImpl(
-                                startOffset, endOffset,
-                                DECLARATION_ORIGIN_ENUM,
-                                IrValueParameterSymbolImpl(it),
-                                Name.identifier(name),
-                                index,
-                                type,
-                                varargElementType = null,
-                                isCrossinline = false,
-                                isNoinline = false,
-                                isHidden = false,
-                                isAssignable = false
-                        ).apply {
-                            it.bind(this)
-                            parent = loweredConstructor
-                        }
+                    IrValueParameterImpl(
+                            startOffset, endOffset,
+                            DECLARATION_ORIGIN_ENUM,
+                            IrValueParameterSymbolImpl(),
+                            Name.identifier(name),
+                            index,
+                            type,
+                            varargElementType = null,
+                            isCrossinline = false,
+                            isNoinline = false,
+                            isHidden = false,
+                            isAssignable = false
+                    ).apply {
+                        parent = loweredConstructor
                     }
 
             loweredConstructor.valueParameters += createSynthesizedValueParameter(0, "name", context.irBuiltIns.stringType)

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/FinallyBlocksLowering.kt

@@ -9,8 +9,8 @@ import org.jetbrains.kotlin.backend.common.lower.*
 import org.jetbrains.kotlin.backend.common.*
 import org.jetbrains.kotlin.backend.konan.Context
 import org.jetbrains.kotlin.descriptors.Modality
-import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor
 import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
+import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.IrStatement
 import org.jetbrains.kotlin.ir.builders.*
@@ -24,8 +24,6 @@ import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.builders.irGet
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.impl.IrFunctionImpl
-import org.jetbrains.kotlin.ir.descriptors.WrappedSimpleFunctionDescriptor
-import org.jetbrains.kotlin.ir.descriptors.WrappedVariableDescriptor
 import org.jetbrains.kotlin.ir.symbols.impl.IrSimpleFunctionSymbolImpl
 import org.jetbrains.kotlin.ir.symbols.impl.IrVariableSymbolImpl
 import org.jetbrains.kotlin.ir.types.IrSimpleType
@@ -173,27 +171,6 @@ internal class FinallyBlocksLowering(val context: Context): FileLoweringPass, Ir
             else -> error("Unknown ReturnTarget: $this")
         }
 
-    private fun createSyntheticFunctionDescriptor(name: String): SimpleFunctionDescriptor {
-        val descriptor = WrappedSimpleFunctionDescriptor()
-        descriptor.bind(IrFunctionImpl(
-                SYNTHETIC_OFFSET, SYNTHETIC_OFFSET,
-                IrDeclarationOrigin.DEFINED,
-                IrSimpleFunctionSymbolImpl(descriptor),
-                Name.identifier(name),
-                DescriptorVisibilities.PUBLIC,
-                Modality.FINAL,
-                context.irBuiltIns.unitType,
-                false,
-                false,
-                false,
-                false,
-                false,
-                false,
-                false)
-        )
-        return descriptor
-    }
-
     private fun performHighLevelJump(tryScopes: List<TryScope>,
                                      index: Int,
                                      jump: HighLevelJump,
@@ -206,7 +183,7 @@ internal class FinallyBlocksLowering(val context: Context): FileLoweringPass, Ir
         val currentTryScope = tryScopes[index]
         currentTryScope.jumps.getOrPut(jump) {
             val type = (jump as? Return)?.target?.owner?.returnType ?: value.type
-            val symbol = IrReturnableBlockSymbolImpl(createSyntheticFunctionDescriptor("\$Finally$index"))
+            val symbol = IrReturnableBlockSymbolImpl()
             with(currentTryScope) {
                 irBuilder.run {
                     val inlinedFinally = irInlineFinally(symbol, type, expression, finallyExpression)
@@ -245,21 +222,19 @@ internal class FinallyBlocksLowering(val context: Context): FileLoweringPass, Ir
                     type        = context.irBuiltIns.nothingType
             )
             val transformedFinallyExpression = finallyExpression.transform(transformer, null)
-            val catchParameter = WrappedVariableDescriptor().let {
+            val catchParameter =
                 IrVariableImpl(
                         startOffset, endOffset,
                         IrDeclarationOrigin.CATCH_PARAMETER,
-                        IrVariableSymbolImpl(it),
+                        IrVariableSymbolImpl(),
                         Name.identifier("t"),
                         symbols.throwable.owner.defaultType,
                         isVar = false,
                         isConst = false,
                         isLateinit = false
                 ).apply {
-                    it.bind(this)
                     parent = this@run.parent
                 }
-            }
 
             val syntheticTry = IrTryImpl(
                     startOffset       = startOffset,
@@ -276,7 +251,7 @@ internal class FinallyBlocksLowering(val context: Context): FileLoweringPass, Ir
             )
             using(TryScope(syntheticTry, transformedFinallyExpression, this)) {
                 val fallThroughType = aTry.type
-                val fallThroughSymbol = IrReturnableBlockSymbolImpl(createSyntheticFunctionDescriptor("\$Fallthrough"))
+                val fallThroughSymbol = IrReturnableBlockSymbolImpl()
                 val transformedResult = aTry.tryResult.transform(transformer, null)
                 transformedTry.tryResult = irReturn(fallThroughSymbol, transformedResult)
                 for (aCatch in aTry.catches) {

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/FunctionReferenceLowering.kt

@@ -25,9 +25,6 @@ import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.impl.IrClassImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrConstructorImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrFunctionImpl
-import org.jetbrains.kotlin.ir.descriptors.WrappedClassConstructorDescriptor
-import org.jetbrains.kotlin.ir.descriptors.WrappedClassDescriptor
-import org.jetbrains.kotlin.ir.descriptors.WrappedSimpleFunctionDescriptor
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.IrInstanceInitializerCallImpl
 import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
@@ -224,11 +221,11 @@ internal class FunctionReferenceLowering(val context: Context): FileLoweringPass
         private val adaptedReferenceOriginalTarget: IrFunction? = adapteeCall?.symbol?.owner
         private val functionReferenceTarget = adaptedReferenceOriginalTarget ?: referencedFunction
 
-        private val functionReferenceClass: IrClass = WrappedClassDescriptor().let {
+        private val functionReferenceClass: IrClass =
             IrClassImpl(
                     startOffset,endOffset,
                     DECLARATION_ORIGIN_FUNCTION_REFERENCE_IMPL,
-                    IrClassSymbolImpl(it),
+                    IrClassSymbolImpl(),
                     "${functionReferenceTarget.name}\$FUNCTION_REFERENCE\$${context.functionReferenceCount++}".synthesizedName,
                     ClassKind.CLASS,
                     DescriptorVisibilities.PRIVATE,
@@ -241,11 +238,9 @@ internal class FunctionReferenceLowering(val context: Context): FileLoweringPass
                     isExpect = false,
                     isFun = false
             ).apply {
-                it.bind(this)
                 parent = this@FunctionReferenceBuilder.parent
                 createParameterDeclarations()
             }
-        }
 
         private val functionReferenceThis = functionReferenceClass.thisReceiver!!
 
@@ -337,11 +332,11 @@ internal class FunctionReferenceLowering(val context: Context): FileLoweringPass
             return BuiltFunctionReference(functionReferenceClass, constructor)
         }
 
-        private fun buildConstructor(): IrConstructor = WrappedClassConstructorDescriptor().let {
+        private fun buildConstructor(): IrConstructor =
             IrConstructorImpl(
                     startOffset, endOffset,
                     DECLARATION_ORIGIN_FUNCTION_REFERENCE_IMPL,
-                    IrConstructorSymbolImpl(it),
+                    IrConstructorSymbolImpl(),
                     Name.special("<init>"),
                     DescriptorVisibilities.PUBLIC,
                     functionReferenceClass.defaultType,
@@ -350,7 +345,6 @@ internal class FunctionReferenceLowering(val context: Context): FileLoweringPass
                     isPrimary = true,
                     isExpect = false
             ).apply {
-                it.bind(this)
                 parent = functionReferenceClass
                 functionReferenceClass.declarations += this
 
@@ -387,7 +381,6 @@ internal class FunctionReferenceLowering(val context: Context): FileLoweringPass
                     }
                 }
             }
-        }
 
         private fun getFlags() =
                 (if (referencedFunction.isSuspend) 1 else 0) + getAdaptedCallableReferenceFlags() shl 1
@@ -418,11 +411,11 @@ internal class FunctionReferenceLowering(val context: Context): FileLoweringPass
             return false
         }
 
-        private fun buildInvokeMethod(superFunction: IrSimpleFunction): IrSimpleFunction = WrappedSimpleFunctionDescriptor().let {
+        private fun buildInvokeMethod(superFunction: IrSimpleFunction): IrSimpleFunction =
             IrFunctionImpl(
                     startOffset, endOffset,
                     DECLARATION_ORIGIN_FUNCTION_REFERENCE_IMPL,
-                    IrSimpleFunctionSymbolImpl(it),
+                    IrSimpleFunctionSymbolImpl(),
                     superFunction.name,
                     DescriptorVisibilities.PRIVATE,
                     Modality.FINAL,
@@ -436,7 +429,6 @@ internal class FunctionReferenceLowering(val context: Context): FileLoweringPass
                     isOperator = false,
                     isInfix = false
             ).apply {
-                it.bind(this)
                 val function = this
                 parent = functionReferenceClass
                 functionReferenceClass.declarations += function
@@ -486,6 +478,5 @@ internal class FunctionReferenceLowering(val context: Context): FileLoweringPass
                     )
                 }
             }
-        }
     }
 }

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/InitializersLowering.kt

@@ -17,7 +17,6 @@ import org.jetbrains.kotlin.ir.IrStatement
 import org.jetbrains.kotlin.ir.builders.irDelegatingConstructorCall
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.impl.IrFunctionImpl
-import org.jetbrains.kotlin.ir.descriptors.WrappedSimpleFunctionDescriptor
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.*
 import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
@@ -108,11 +107,11 @@ internal class InitializersLowering(val context: CommonBackendContext) : ClassLo
 
             val startOffset = irClass.startOffset
             val endOffset = irClass.endOffset
-            val initializeFun = WrappedSimpleFunctionDescriptor().let {
+            val initializeFun =
                 IrFunctionImpl(
                         startOffset, endOffset,
                         DECLARATION_ORIGIN_ANONYMOUS_INITIALIZER,
-                        IrSimpleFunctionSymbolImpl(it),
+                        IrSimpleFunctionSymbolImpl(),
                         "INITIALIZER".synthesizedName,
                         DescriptorVisibilities.PRIVATE,
                         Modality.FINAL,
@@ -126,7 +125,6 @@ internal class InitializersLowering(val context: CommonBackendContext) : ClassLo
                         isOperator = false,
                         isInfix = false
                 ).apply {
-                    it.bind(this)
                     parent = irClass
                     irClass.declarations.add(this)
 
@@ -134,7 +132,6 @@ internal class InitializersLowering(val context: CommonBackendContext) : ClassLo
 
                     body = IrBlockBodyImpl(startOffset, endOffset, initializers)
                 }
-            }
 
             for (initializer in initializers) {
                 initializer.transformChildrenVoid(object : IrElementTransformerVoid() {

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/InteropLowering.kt

@@ -27,8 +27,6 @@ import org.jetbrains.kotlin.ir.builders.*
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.impl.IrFunctionImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrValueParameterImpl
-import org.jetbrains.kotlin.ir.descriptors.WrappedSimpleFunctionDescriptor
-import org.jetbrains.kotlin.ir.descriptors.WrappedValueParameterDescriptor
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.IrConstImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrDelegatingConstructorCallImpl
@@ -225,11 +223,10 @@ private class InteropLoweringPart1(val context: Context) : BaseInteropIrTransfor
 
         // Generate `override fun init...(...) = this.initBy(...)`:
 
-        val resultDescriptor = WrappedSimpleFunctionDescriptor()
         return IrFunctionImpl(
                 constructor.startOffset, constructor.endOffset,
                 OVERRIDING_INITIALIZER_BY_CONSTRUCTOR,
-                IrSimpleFunctionSymbolImpl(resultDescriptor),
+                IrSimpleFunctionSymbolImpl(),
                 initMethod.name,
                 DescriptorVisibilities.PUBLIC,
                 Modality.OPEN,
@@ -243,7 +240,6 @@ private class InteropLoweringPart1(val context: Context) : BaseInteropIrTransfor
                 isOperator = false,
                 isInfix = false
         ).also { result ->
-            resultDescriptor.bind(result)
             result.parent = irClass
             result.createDispatchReceiverParameter()
             result.valueParameters += constructor.valueParameters.map { it.copyTo(result) }
@@ -323,11 +319,11 @@ private class InteropLoweringPart1(val context: Context) : BaseInteropIrTransfor
 
         function.valueParameters.mapTo(parameterTypes) { nativePtrType }
 
-        val newFunction = WrappedSimpleFunctionDescriptor().let {
+        val newFunction =
             IrFunctionImpl(
                     function.startOffset, function.endOffset,
                     IrDeclarationOrigin.DEFINED,
-                    IrSimpleFunctionSymbolImpl(it),
+                    IrSimpleFunctionSymbolImpl(),
                     ("imp:$selector").synthesizedName,
                     DescriptorVisibilities.PRIVATE,
                     Modality.FINAL,
@@ -340,29 +336,23 @@ private class InteropLoweringPart1(val context: Context) : BaseInteropIrTransfor
                     isFakeOverride = false,
                     isOperator = false,
                     isInfix = false
-            ).apply {
-                it.bind(this)
-            }
-        }
+            )
 
         newFunction.valueParameters += parameterTypes.mapIndexed { index, type ->
-            WrappedValueParameterDescriptor().let {
-                IrValueParameterImpl(
-                        function.startOffset, function.endOffset,
-                        IrDeclarationOrigin.DEFINED,
-                        IrValueParameterSymbolImpl(it),
-                        Name.identifier("p$index"),
-                        index,
-                        type,
-                        varargElementType = null,
-                        isCrossinline = false,
-                        isNoinline = false,
-                        isHidden = false,
-                        isAssignable = false
-                ).apply {
-                    it.bind(this)
-                    parent = newFunction
-                }
+            IrValueParameterImpl(
+                    function.startOffset, function.endOffset,
+                    IrDeclarationOrigin.DEFINED,
+                    IrValueParameterSymbolImpl(),
+                    Name.identifier("p$index"),
+                    index,
+                    type,
+                    varargElementType = null,
+                    isCrossinline = false,
+                    isNoinline = false,
+                    isHidden = false,
+                    isAssignable = false
+            ).apply {
+                parent = newFunction
             }
         }
 

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/NativeSuspendFunctionLowering.kt

@@ -14,8 +14,6 @@ import org.jetbrains.kotlin.ir.builders.irCall
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.impl.IrFunctionImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrVariableImpl
-import org.jetbrains.kotlin.ir.descriptors.WrappedSimpleFunctionDescriptor
-import org.jetbrains.kotlin.ir.descriptors.WrappedVariableDescriptor
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.IrGetValueImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrSetValueImpl
@@ -478,11 +476,11 @@ internal class NativeSuspendFunctionsLowering(ctx: Context): AbstractSuspendFunc
     }
 
     // These are marker functions to split up the lowering on two parts.
-    private val saveState = WrappedSimpleFunctionDescriptor().let {
+    private val saveState =
         IrFunctionImpl(
                 SYNTHETIC_OFFSET, SYNTHETIC_OFFSET,
                 IrDeclarationOrigin.DEFINED,
-                IrSimpleFunctionSymbolImpl(it),
+                IrSimpleFunctionSymbolImpl(),
                 "saveState".synthesizedName,
                 DescriptorVisibilities.PRIVATE,
                 Modality.ABSTRACT,
@@ -495,16 +493,13 @@ internal class NativeSuspendFunctionsLowering(ctx: Context): AbstractSuspendFunc
                 isFakeOverride = false,
                 isOperator = false,
                 isInfix = false
-        ).apply {
-            it.bind(this)
-        }
-    }
+        )
 
-    private val restoreState = WrappedSimpleFunctionDescriptor().let {
+    private val restoreState =
         IrFunctionImpl(
                 SYNTHETIC_OFFSET, SYNTHETIC_OFFSET,
                 IrDeclarationOrigin.DEFINED,
-                IrSimpleFunctionSymbolImpl(it),
+                IrSimpleFunctionSymbolImpl(),
                 "restoreState".synthesizedName,
                 DescriptorVisibilities.PRIVATE,
                 Modality.ABSTRACT,
@@ -517,29 +512,24 @@ internal class NativeSuspendFunctionsLowering(ctx: Context): AbstractSuspendFunc
                 isFakeOverride = false,
                 isOperator = false,
                 isInfix = false
-        ).apply {
-            it.bind(this)
-        }
-    }
+        )
 
     private fun IrBuilderWithScope.irVar(name: Name, type: IrType,
                                          isMutable: Boolean = false,
-                                         initializer: IrExpression? = null) = WrappedVariableDescriptor().let {
+                                         initializer: IrExpression? = null) =
         IrVariableImpl(
                 startOffset, endOffset,
                 DECLARATION_ORIGIN_COROUTINE_IMPL,
-                IrVariableSymbolImpl(it),
+                IrVariableSymbolImpl(),
                 name,
                 type,
                 isMutable,
                 isConst = false,
                 isLateinit = false
         ).apply {
-            it.bind(this)
             this.initializer = initializer
             this.parent = this@irVar.parent
         }
-    }
 
     private fun IrBuilderWithScope.irGetOrThrow(result: IrExpression): IrExpression =
             irCall(symbols.kotlinResultGetOrThrow.owner).apply {

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/RedundantCoercionsCleaner.kt

@@ -150,7 +150,7 @@ internal class RedundantCoercionsCleaner(val context: Context) : FileLoweringPas
                             expression
                         else {
                             val oldSymbol = expression.symbol
-                            val newSymbol = IrReturnableBlockSymbolImpl(expression.descriptor)
+                            val newSymbol = IrReturnableBlockSymbolImpl()
                             val transformedReturnableBlock = with(expression) {
                                 IrReturnableBlockImpl(
                                         startOffset = startOffset,

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/TestProcessor.kt

@@ -22,9 +22,6 @@ import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.impl.IrClassImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrConstructorImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrFunctionImpl
-import org.jetbrains.kotlin.ir.descriptors.WrappedClassConstructorDescriptor
-import org.jetbrains.kotlin.ir.descriptors.WrappedClassDescriptor
-import org.jetbrains.kotlin.ir.descriptors.WrappedSimpleFunctionDescriptor
 import org.jetbrains.kotlin.ir.expressions.impl.*
 import org.jetbrains.kotlin.ir.symbols.*
 import org.jetbrains.kotlin.ir.symbols.impl.IrClassSymbolImpl
@@ -335,11 +332,11 @@ internal class TestProcessor (val context: Context) {
      */
     private fun buildObjectGetter(objectSymbol: IrClassSymbol,
                                   owner: IrClass,
-                                  getterName: Name): IrSimpleFunction = WrappedSimpleFunctionDescriptor().let { descriptor ->
+                                  getterName: Name): IrSimpleFunction =
         IrFunctionImpl(
                 owner.startOffset, owner.endOffset,
                 TEST_SUITE_GENERATED_MEMBER,
-                IrSimpleFunctionSymbolImpl(descriptor),
+                IrSimpleFunctionSymbolImpl(),
                 getterName,
                 DescriptorVisibilities.PROTECTED,
                 Modality.FINAL,
@@ -353,7 +350,6 @@ internal class TestProcessor (val context: Context) {
                 isOperator = false,
                 isInfix = false
         ).apply {
-            descriptor.bind(this)
             parent = owner
 
             val superFunction = baseClassSuite.simpleFunctions()
@@ -367,7 +363,6 @@ internal class TestProcessor (val context: Context) {
                 )
             }
         }
-    }
 
     /**
      * Builds a method in `[testSuite]` class with name `[getterName]`
@@ -375,11 +370,11 @@ internal class TestProcessor (val context: Context) {
      */
     private fun buildInstanceGetter(classSymbol: IrClassSymbol,
                                     owner: IrClass,
-                                    getterName: Name): IrSimpleFunction = WrappedSimpleFunctionDescriptor().let { descriptor ->
+                                    getterName: Name): IrSimpleFunction =
         IrFunctionImpl(
                 owner.startOffset, owner.endOffset,
                 TEST_SUITE_GENERATED_MEMBER,
-                IrSimpleFunctionSymbolImpl(descriptor),
+                IrSimpleFunctionSymbolImpl(),
                 getterName,
                 DescriptorVisibilities.PROTECTED,
                 Modality.FINAL,
@@ -393,7 +388,6 @@ internal class TestProcessor (val context: Context) {
                 isOperator = false,
                 isInfix = false
         ).apply {
-            descriptor.bind(this)
             parent = owner
 
             val superFunction = baseClassSuite.simpleFunctions()
@@ -407,7 +401,6 @@ internal class TestProcessor (val context: Context) {
                 +irReturn(irCall(constructor))
             }
         }
-    }
 
     private val baseClassSuiteConstructor = baseClassSuite.constructors.single {
         it.valueParameters.size == 2
@@ -426,11 +419,11 @@ internal class TestProcessor (val context: Context) {
                                            testSuite: IrClassSymbol,
                                            owner: IrClass,
                                            functions: Collection<TestFunction>,
-                                           ignored: Boolean): IrConstructor = WrappedClassConstructorDescriptor().let { descriptor ->
+                                           ignored: Boolean): IrConstructor =
         IrConstructorImpl(
                 testSuite.owner.startOffset, testSuite.owner.endOffset,
                 TEST_SUITE_GENERATED_MEMBER,
-                IrConstructorSymbolImpl(descriptor),
+                IrConstructorSymbolImpl(),
                 Name.special("<init>"),
                 DescriptorVisibilities.PUBLIC,
                 testSuite.typeWithStarProjections,
@@ -439,7 +432,6 @@ internal class TestProcessor (val context: Context) {
                 isPrimary = true,
                 isExpect = false
         ).apply {
-            descriptor.bind(this)
             parent = owner
 
             fun IrClass.getFunction(name: String, predicate: (IrSimpleFunction) -> Boolean) =
@@ -469,7 +461,6 @@ internal class TestProcessor (val context: Context) {
                         registerTestCase, registerFunction, functions)
             }
         }
-    }
 
     private val IrClass.ignored: Boolean get() = annotations.hasAnnotation(IGNORE_FQ_NAME)
 
@@ -479,11 +470,11 @@ internal class TestProcessor (val context: Context) {
      */
     private fun buildClassSuite(testClass: IrClass,
                                 testCompanion: IrClass?,
-                                functions: Collection<TestFunction>): IrClass = WrappedClassDescriptor().let { descriptor ->
+                                functions: Collection<TestFunction>): IrClass =
         IrClassImpl(
                 testClass.startOffset, testClass.endOffset,
                 TEST_SUITE_CLASS,
-                IrClassSymbolImpl(descriptor),
+                IrClassSymbolImpl(),
                 testClass.name.synthesizeSuiteClassName(),
                 ClassKind.CLASS,
                 DescriptorVisibilities.PRIVATE,
@@ -496,7 +487,6 @@ internal class TestProcessor (val context: Context) {
                 isExpect = false,
                 isFun = false
         ).apply {
-            descriptor.bind(this)
             createParameterDeclarations()
 
             val testClassType = testClass.defaultType
@@ -531,7 +521,6 @@ internal class TestProcessor (val context: Context) {
             superTypes += symbols.baseClassSuite.typeWith(listOf(testClassType, testCompanionType))
             addFakeOverrides(context.irBuiltIns)
         }
-    }
     //endregion
 
     // region IR generation methods

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/optimizations/Devirtualization.kt

@@ -21,7 +21,6 @@ import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.builders.*
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.impl.IrVariableImpl
-import org.jetbrains.kotlin.ir.descriptors.WrappedVariableDescriptor
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.*
 import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
@@ -1318,13 +1317,10 @@ internal object Devirtualization {
         }
 
         fun <T : IrElement> IrStatementsBuilder<T>.irTemporary(value: IrExpression, tempName: String, type: IrType): IrVariable {
-            val descriptor = WrappedVariableDescriptor()
-
             val temporary = IrVariableImpl(
-                value.startOffset, value.endOffset, IrDeclarationOrigin.IR_TEMPORARY_VARIABLE, IrVariableSymbolImpl(descriptor),
+                value.startOffset, value.endOffset, IrDeclarationOrigin.IR_TEMPORARY_VARIABLE, IrVariableSymbolImpl(),
                 Name.identifier(tempName), type, isVar = false, isConst = false, isLateinit = false
             ).apply {
-                descriptor.bind(this)
                 this.initializer = value
             }
 

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/serialization/KonanIrlinker.kt

@@ -210,7 +210,7 @@ internal class KonanIrLinker(
             if (actualModule !== moduleDescriptor) {
                 val moduleDeserializer = deserializersForModules[actualModule] ?: error("No module deserializer for $actualModule")
                 moduleDeserializer.addModuleReachableTopLevel(idSig)
-                return symbolTable.referenceClassFromLinker(descriptor, idSig)
+                return symbolTable.referenceClassFromLinker(idSig)
             }
 
             return declaredDeclaration.getOrPut(idSig) { buildForwardDeclarationStub(descriptor) }.symbol

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/ir/util/IrUtils2.kt

@@ -25,8 +25,6 @@ import org.jetbrains.kotlin.ir.declarations.impl.IrFileImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrValueParameterImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrVariableImpl
 import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
-import org.jetbrains.kotlin.ir.descriptors.WrappedFieldDescriptor
-import org.jetbrains.kotlin.ir.descriptors.WrappedVariableDescriptor
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.*
 import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
@@ -69,11 +67,10 @@ internal fun IrExpression.isNullConst() = this is IrConst<*> && this.kind == IrC
 private var topLevelInitializersCounter = 0
 
 internal fun IrFile.addTopLevelInitializer(expression: IrExpression, context: KonanBackendContext, threadLocal: Boolean) {
-    val descriptor = WrappedFieldDescriptor()
     val irField = IrFieldImpl(
             expression.startOffset, expression.endOffset,
             IrDeclarationOrigin.DEFINED,
-            IrFieldSymbolImpl(descriptor),
+            IrFieldSymbolImpl(),
             "topLevelInitializer${topLevelInitializersCounter++}".synthesizedName,
             expression.type,
             DescriptorVisibilities.PRIVATE,
@@ -81,8 +78,6 @@ internal fun IrFile.addTopLevelInitializer(expression: IrExpression, context: Ko
             isExternal = false,
             isStatic = true,
     ).apply {
-        descriptor.bind(this)
-
         expression.setDeclarationsParent(this)
 
         if (threadLocal)
@@ -264,21 +259,18 @@ fun IrBuilderWithScope.irSetVar(variable: IrVariable, value: IrExpression) =
 fun IrBuilderWithScope.irCatch(type: IrType) =
         IrCatchImpl(
                 startOffset, endOffset,
-                WrappedVariableDescriptor().let { descriptor ->
-                    IrVariableImpl(
-                            startOffset,
-                            endOffset,
-                            IrDeclarationOrigin.IR_TEMPORARY_VARIABLE,
-                            IrVariableSymbolImpl(descriptor),
-                            Name.identifier("e"),
-                            type,
-                            false,
-                            false,
-                            false
-                    ).apply {
-                        descriptor.bind(this)
-                        parent = this@irCatch.parent
-                    }
+                IrVariableImpl(
+                        startOffset,
+                        endOffset,
+                        IrDeclarationOrigin.IR_TEMPORARY_VARIABLE,
+                        IrVariableSymbolImpl(),
+                        Name.identifier("e"),
+                        type,
+                        false,
+                        false,
+                        false
+                ).apply {
+                    parent = this@irCatch.parent
                 }
         )
 
@@ -345,11 +337,11 @@ fun createField(
         name: Name,
         isMutable: Boolean,
         owner: IrClass
-) = WrappedFieldDescriptor().let {
+) =
     IrFieldImpl(
             startOffset, endOffset,
             origin,
-            IrFieldSymbolImpl(it),
+            IrFieldSymbolImpl(),
             name,
             type,
             DescriptorVisibilities.PRIVATE,
@@ -357,14 +349,12 @@ fun createField(
             false,
             false,
     ).apply {
-        it.bind(this)
         owner.declarations += this
         parent = owner
     }
-}
 
 fun IrValueParameter.copy(newDescriptor: ParameterDescriptor): IrValueParameter {
-    // Aggressive use of WrappedDescriptors during deserialization
+    // Aggressive use of IrBasedDescriptors during deserialization
     // makes these types different.
     // Let's hope they not really used afterwards.
     //assert(this.descriptor.type == newDescriptor.type) {