diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/descriptors/WrappedDescriptors.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/descriptors/WrappedDescriptors.kt index 12ab804f273..3d6cba5a824 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/descriptors/WrappedDescriptors.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/descriptors/WrappedDescriptors.kt @@ -221,7 +221,7 @@ open class WrappedSimpleFunctionDescriptor( val extensionReceiver by lazy { owner.extensionReceiverParameter?.let { - ReceiverParameterDescriptorImpl(this, ExtensionReceiver(it.descriptor, it.type.toKotlinType(), null)) + ReceiverParameterDescriptorImpl(this, ExtensionReceiver(it.descriptor, it.type.toKotlinType(), null), Annotations.EMPTY) } } @@ -294,6 +294,9 @@ open class WrappedClassConstructorDescriptor( ) : ClassConstructorDescriptor, WrappedCallableDescriptor(annotations, sourceElement) { override fun getContainingDeclaration() = (owner.parent as IrClass).descriptor + override fun getDispatchReceiverParameter() = owner.dispatchReceiverParameter?.run { + (containingDeclaration.containingDeclaration as ClassDescriptor).thisAsReceiverParameter + } override fun getTypeParameters() = owner.typeParameters.map { it.descriptor } override fun getValueParameters() = owner.valueParameters.asSequence() .mapNotNull { it.descriptor as? ValueParameterDescriptor } diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrUtils.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrUtils.kt index 20f43012e92..64dbdc83c59 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrUtils.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrUtils.kt @@ -158,6 +158,7 @@ fun IrValueParameter.copyTo(irFunction: IrFunction, shift: Int = 0): IrValuePara } fun IrTypeParameter.copyTo(irFunction: IrFunction, shift: Int = 0): IrTypeParameter { + // TODO: Copy IrTypeParameter with type remapping val descriptor = WrappedTypeParameterDescriptor(symbol.descriptor.annotations, symbol.descriptor.source) val symbol = IrTypeParameterSymbolImpl(descriptor) return IrTypeParameterImpl(startOffset, endOffset, origin, symbol, name, shift + index, isReified, variance).also { @@ -168,7 +169,12 @@ fun IrTypeParameter.copyTo(irFunction: IrFunction, shift: Int = 0): IrTypeParame fun IrFunction.copyParameterDeclarationsFrom(from: IrFunction) { - dispatchReceiverParameter = from.dispatchReceiverParameter?.copyTo(this) + // TODO: should dispatch receiver be copied? + dispatchReceiverParameter = from.dispatchReceiverParameter?.let { + IrValueParameterImpl(it.startOffset, it.endOffset, it.origin, it.descriptor, it.type, it.varargElementType).also { + it.parent = this + } + } extensionReceiverParameter = from.extensionReceiverParameter?.copyTo(this) val shift = valueParameters.size diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/DefaultArgumentStubGenerator.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/DefaultArgumentStubGenerator.kt index c80c82bf298..6c5627f5708 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/DefaultArgumentStubGenerator.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/DefaultArgumentStubGenerator.kt @@ -15,17 +15,16 @@ import org.jetbrains.kotlin.backend.common.descriptors.WrappedValueParameterDesc import org.jetbrains.kotlin.backend.common.descriptors.synthesizedName import org.jetbrains.kotlin.backend.common.ir.copyTo import org.jetbrains.kotlin.backend.common.ir.ir2string +import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.ir.IrElement +import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET import org.jetbrains.kotlin.ir.builders.* import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.declarations.impl.IrConstructorImpl import org.jetbrains.kotlin.ir.declarations.impl.IrFunctionImpl import org.jetbrains.kotlin.ir.declarations.impl.IrValueParameterImpl import org.jetbrains.kotlin.ir.expressions.* -import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl -import org.jetbrains.kotlin.ir.expressions.impl.IrConstImpl -import org.jetbrains.kotlin.ir.expressions.impl.IrDelegatingConstructorCallImpl -import org.jetbrains.kotlin.ir.expressions.impl.IrGetObjectValueImpl +import org.jetbrains.kotlin.ir.expressions.impl.* import org.jetbrains.kotlin.ir.symbols.IrConstructorSymbol import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol import org.jetbrains.kotlin.ir.symbols.impl.IrConstructorSymbolImpl @@ -142,9 +141,9 @@ open class DefaultArgumentStubGenerator constructor(val context: CommonBackendCo } } // Remove default argument initializers. -// irFunction.valueParameters.forEach { -// it.defaultValue = null -// } + irFunction.valueParameters.forEach { + it.defaultValue = IrExpressionBodyImpl(IrErrorExpressionImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, it.type, "Default Stub")) + } return listOf(irFunction, newIrFunction) } @@ -377,7 +376,9 @@ private fun IrFunction.generateDefaultsFunctionImpl(context: CommonBackendContex val newTypeParameters = typeParameters.map { it.copyTo(newFunction) } newFunction.returnType = returnType - newFunction.dispatchReceiverParameter = dispatchReceiverParameter?.copyTo(newFunction) + newFunction.dispatchReceiverParameter = dispatchReceiverParameter?.run { + IrValueParameterImpl(startOffset, endOffset, origin, descriptor, type, varargElementType).also { it.parent = newFunction } + } newFunction.extensionReceiverParameter = extensionReceiverParameter?.copyTo(newFunction) newFunction.valueParameters += newValueParameters newFunction.typeParameters += newTypeParameters @@ -399,7 +400,7 @@ private fun buildFunctionDeclaration(irFunction: IrFunction): IrFunction { irFunction.name, irFunction.visibility, irFunction.isInline, - irFunction.isExternal, + false, false ).also { descriptor.bind(it) @@ -417,10 +418,10 @@ private fun buildFunctionDeclaration(irFunction: IrFunction): IrFunction { IrSimpleFunctionSymbolImpl(descriptor), name, irFunction.visibility, - irFunction.modality, + Modality.FINAL, irFunction.isInline, - irFunction.isExternal, - irFunction.isTailrec, + false, + false, irFunction.isSuspend ).also { descriptor.bind(it) diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LocalDeclarationsLowering.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LocalDeclarationsLowering.kt index 1bacc8cff0a..58507f80fc0 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LocalDeclarationsLowering.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LocalDeclarationsLowering.kt @@ -55,7 +55,7 @@ class LocalDeclarationsLowering( val context: BackendContext, val localNameProvider: LocalNameProvider = LocalNameProvider.DEFAULT, val loweredConstructorVisibility: Visibility = Visibilities.PRIVATE, - private val isJVM: Boolean = false + private val isJVM: Boolean = false // TODO: remove this workaround ) : DeclarationContainerLoweringPass { @@ -350,7 +350,7 @@ class LocalDeclarationsLowering( override fun visitReturn(expression: IrReturn): IrExpression { expression.transformChildrenVoid(this) - val oldReturnTarget = expression.returnTargetSymbol.owner as IrFunction + val oldReturnTarget = expression.returnTargetSymbol.owner as? IrFunction ?: return expression val newReturnTarget = oldReturnTarget.transformed ?: return expression return IrReturnImpl( @@ -503,7 +503,7 @@ class LocalDeclarationsLowering( newSymbol, newName, // TODO: change to PRIVATE when issue with CallableReferenceLowering in Jvm BE is fixed - Visibilities.PUBLIC, + if (isJVM) Visibilities.PUBLIC else Visibilities.PRIVATE, Modality.FINAL, oldDeclaration.isInline, oldDeclaration.isExternal, @@ -596,8 +596,10 @@ class LocalDeclarationsLowering( newDeclaration.parent = localClassContext.declaration newDeclaration.returnType = oldDeclaration.returnType + // TODO: should dispatch receiver be copied? newDeclaration.dispatchReceiverParameter = oldDeclaration.dispatchReceiverParameter?.run { - copyTo(newDeclaration).also { + IrValueParameterImpl(startOffset, endOffset, origin, descriptor, type, varargElementType).also { + it.parent = newDeclaration newParameterToOld.putAbsentOrSame(it, this) } } diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LowerUtils.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LowerUtils.kt index 2a54611b044..4a3373d645c 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LowerUtils.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LowerUtils.kt @@ -68,6 +68,11 @@ class VariableRemapper(val mapping: Map) : A mapping[value] } +class VariableRemapperDesc(val mapping: Map) : AbstractVariableRemapper() { + override fun remapVariable(value: IrValueDeclaration): IrValueParameter? = + mapping[value.descriptor] +} + fun BackendContext.createIrBuilder( symbol: IrSymbol, startOffset: Int = UNDEFINED_OFFSET, diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsSharedVariablesManager.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsSharedVariablesManager.kt index 34403f16bec..5be0c7da800 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsSharedVariablesManager.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsSharedVariablesManager.kt @@ -133,7 +133,9 @@ class JsSharedVariablesManager(val builtIns: IrBuiltIns, val implicitDeclaration declaration.parent = implicitDeclarationsFile closureBoxType = IrSimpleTypeImpl(declaration.symbol, false, emptyList(), emptyList()) declaration.thisReceiver = - JsIrBuilder.buildValueParameter(Name.special(""), -1, closureBoxType, IrDeclarationOrigin.INSTANCE_RECEIVER) + JsIrBuilder.buildValueParameter(Name.special(""), -1, closureBoxType, IrDeclarationOrigin.INSTANCE_RECEIVER).apply { + parent = declaration + } implicitDeclarationsFile.declarations += declaration return declaration diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ir/IrBuilder.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ir/IrBuilder.kt index 262b1af7c67..b4e36748fc6 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ir/IrBuilder.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ir/IrBuilder.kt @@ -176,6 +176,7 @@ object JsIrBuilder { fun buildVar( type: IrType, + parent: IrDeclarationParent, name: String = "tmp", isVar: Boolean = false, isConst: Boolean = false, @@ -196,6 +197,7 @@ object JsIrBuilder { ).also { descriptor.bind(it) it.initializer = initializer + it.parent = parent } } diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/BlockDecomposerLowering.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/BlockDecomposerLowering.kt index 1fe81f8e871..3e8104213e2 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/BlockDecomposerLowering.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/BlockDecomposerLowering.kt @@ -13,7 +13,6 @@ import org.jetbrains.kotlin.ir.backend.js.ir.JsIrBuilder import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.expressions.* import org.jetbrains.kotlin.ir.expressions.impl.* -import org.jetbrains.kotlin.ir.symbols.IrVariableSymbol import org.jetbrains.kotlin.ir.types.IrType import org.jetbrains.kotlin.ir.util.transformFlat import org.jetbrains.kotlin.ir.visitors.IrElementTransformer @@ -101,7 +100,7 @@ class BlockDecomposerTransformer(context: JsIrBackendContext) : IrElementTransfo } private fun makeTempVar(type: IrType, init: IrExpression? = null) = - JsIrBuilder.buildVar(type, initializer = init, isVar = true).also { it.parent = function } + JsIrBuilder.buildVar(type, function, initializer = init, isVar = true) private fun makeLoopLabel() = "\$l\$${tmpVarCounter++}" @@ -538,8 +537,8 @@ class BlockDecomposerTransformer(context: JsIrBackendContext) : IrElementTransfo private fun wrap(expression: IrExpression) = expression as? IrBlock ?: expression.let { IrBlockImpl(it.startOffset, it.endOffset, it.type, null, listOf(it)) } - private fun wrap(expression: IrExpression, variable: IrVariableSymbol) = - wrap(JsIrBuilder.buildSetVariable(variable, expression, unitType)) + private fun wrap(expression: IrExpression, variable: IrVariable) = + wrap(JsIrBuilder.buildSetVariable(variable.symbol, expression, unitType)) // try { // try_block {} @@ -561,9 +560,9 @@ class BlockDecomposerTransformer(context: JsIrBackendContext) : IrElementTransfo override fun visitTry(aTry: IrTry): IrExpression { val irVar = makeTempVar(aTry.type) - val newTryResult = wrap(aTry.tryResult, irVar.symbol) + val newTryResult = wrap(aTry.tryResult, irVar) val newCatches = aTry.catches.map { - val newCatchBody = wrap(it.result, irVar.symbol) + val newCatchBody = wrap(it.result, irVar) IrCatchImpl(it.startOffset, it.endOffset, it.catchParameter, newCatchBody) } @@ -610,7 +609,7 @@ class BlockDecomposerTransformer(context: JsIrBackendContext) : IrElementTransfo val irVar = makeTempVar(expression.type) val newBranches = decomposedResults.map { (branch, condition, result) -> - val newResult = wrap(result, irVar.symbol) + val newResult = wrap(result, irVar) when (branch) { is IrElseBranch -> IrElseBranchImpl(branch.startOffset, branch.endOffset, condition, newResult) else /* IrBranch */ -> IrBranchImpl(branch.startOffset, branch.endOffset, condition, newResult) diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/BridgesConstruction.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/BridgesConstruction.kt index 3f2b1fa82d0..5cca6c76557 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/BridgesConstruction.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/BridgesConstruction.kt @@ -30,14 +30,15 @@ import org.jetbrains.kotlin.ir.backend.js.ir.JsIrBuilder import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.isStatic import org.jetbrains.kotlin.ir.builders.* import org.jetbrains.kotlin.ir.declarations.* +import org.jetbrains.kotlin.ir.declarations.impl.IrValueParameterImpl import org.jetbrains.kotlin.ir.expressions.IrExpression import org.jetbrains.kotlin.ir.types.IrType import org.jetbrains.kotlin.ir.types.classifierOrNull import org.jetbrains.kotlin.ir.types.isUnit -import org.jetbrains.kotlin.ir.types.toKotlinType import org.jetbrains.kotlin.ir.util.isInterface import org.jetbrains.kotlin.ir.util.isReal import org.jetbrains.kotlin.ir.util.parentAsClass +import org.jetbrains.kotlin.ir.util.render import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.DescriptorUtils @@ -121,7 +122,10 @@ class BridgesConstruction(val context: JsIrBackendContext) : ClassLoweringPass { IrDeclarationOrigin.BRIDGE ).apply { - dispatchReceiverParameter = bridge.dispatchReceiverParameter?.copyTo(this) + // TODO: should dispatch receiver be copied? + dispatchReceiverParameter = bridge.dispatchReceiverParameter?.run { + IrValueParameterImpl(startOffset, endOffset, origin, descriptor, type, varargElementType).also { it.parent = this@apply } + } extensionReceiverParameter = bridge.extensionReceiverParameter?.copyTo(this) typeParameters += bridge.typeParameters valueParameters += bridge.valueParameters.map { p -> p.copyTo(this) } @@ -185,9 +189,8 @@ class FunctionAndSignature(val function: IrSimpleFunction) { private val signature = Signature( function.name, - // TODO: should kotlinTypes be used here? - function.extensionReceiverParameter?.type?.toKotlinType()?.toString(), - function.valueParameters.map { it.type.toKotlinType().toString() } + function.extensionReceiverParameter?.type?.render(), + function.valueParameters.map { it.type.render() } ) override fun equals(other: Any?) = diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/CallableReferenceLowering.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/CallableReferenceLowering.kt index cdb356f1ab8..dbed1f545da 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/CallableReferenceLowering.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/CallableReferenceLowering.kt @@ -210,9 +210,7 @@ class CallableReferenceLowering(val context: JsIrBackendContext) { val additionalDeclarations = generateGetterBodyWithGuard(refGetFunction) { val irClosureReference = JsIrBuilder.buildFunctionReference(functionReference.type, refClosureFunction.symbol) - val irVar = JsIrBuilder.buildVar(irClosureReference.type, initializer = irClosureReference).also { - it.parent = refGetFunction - } + val irVar = JsIrBuilder.buildVar(irClosureReference.type, refGetFunction, initializer = irClosureReference) // TODO: fill other fields of callable reference (returnType, parameters, isFinal, etc.) val irSetName = JsIrBuilder.buildCall(context.intrinsics.jsSetJSField.symbol).apply { @@ -261,7 +259,7 @@ class CallableReferenceLowering(val context: JsIrBackendContext) { val getterFunctionType = context.builtIns.getFunction(getterFunction.valueParameters.size + 1) val type = getterFunctionType.toIrType(symbolTable = context.symbolTable) val irGetReference = JsIrBuilder.buildFunctionReference(type, getterFunction.symbol) - val irVar = JsIrBuilder.buildVar(type, initializer = irGetReference).also { it.parent = refGetFunction } + val irVar = JsIrBuilder.buildVar(type, refGetFunction, initializer = irGetReference) statements += irVar @@ -331,7 +329,7 @@ class CallableReferenceLowering(val context: JsIrBackendContext) { val getterFunctionType = context.builtIns.getFunction(getterFunction.valueParameters.size + 1) val type = getterFunctionType.toIrType(symbolTable = context.symbolTable) val irGetReference = JsIrBuilder.buildFunctionReference(type, getterFunction.symbol) - val irVar = JsIrBuilder.buildVar(type = type, initializer = irGetReference).also { it.parent = refGetFunction } + val irVar = JsIrBuilder.buildVar(type, refGetFunction, initializer = irGetReference) val irVarSymbol = irVar.symbol statements += irVar @@ -374,9 +372,7 @@ class CallableReferenceLowering(val context: JsIrBackendContext) { val cacheName = "${getterFunction.name}_${Namer.KCALLABLE_CACHE_SUFFIX}" val type = getterFunction.returnType val irNull = JsIrBuilder.buildNull(context.irBuiltIns.nothingNType) - val cacheVar = JsIrBuilder.buildVar(type, cacheName, true, initializer = irNull).also { - it.parent = getterFunction.parent - } + val cacheVar = JsIrBuilder.buildVar(type, getterFunction.parent, cacheName, true, initializer = irNull) val irCacheValue = JsIrBuilder.buildGetValue(cacheVar.symbol) val irIfCondition = JsIrBuilder.buildCall(context.irBuiltIns.eqeqSymbol).apply { diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/IntrinsicifyCallsLowering.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/IntrinsicifyCallsLowering.kt index 787318ace05..c44f000d856 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/IntrinsicifyCallsLowering.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/IntrinsicifyCallsLowering.kt @@ -317,7 +317,7 @@ class IntrinsicifyCallsLowering(private val context: JsIrBackendContext) : FileL val symbol = call.symbol val declaration = symbol.owner - if (declaration.isDynamic || declaration.isEffectivelyExternal()) { + if (declaration.isDynamic() || declaration.isEffectivelyExternal()) { when (call.origin) { IrStatementOrigin.GET_PROPERTY -> { val fieldSymbol = context.symbolTable.lazyWrapper.referenceField( @@ -340,7 +340,7 @@ class IntrinsicifyCallsLowering(private val context: JsIrBackendContext) : FileL } } - if (declaration.isDynamic) { + if (declaration.isDynamic()) { dynamicCallOriginToIrFunction[call.origin]?.let { return irCall(call, it.symbol, dispatchReceiverAsFirstArgument = true) } @@ -416,7 +416,7 @@ class IntrinsicifyCallsLowering(private val context: JsIrBackendContext) : FileL it.name == Name.identifier("equals") && it.valueParameters.size == 1 && rhs.isSubtypeOf(it.valueParameters[0].type) - && !it./*descriptor.*/isFakeOverriddenFromAny() + && !it.isFakeOverriddenFromAny() } .maxWith( // Find the most specific function Comparator { f1, f2 -> diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/MoveExternalDeclarationsToSeparatePlace.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/MoveExternalDeclarationsToSeparatePlace.kt index d5aa1f2d50b..ee7286e0486 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/MoveExternalDeclarationsToSeparatePlace.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/MoveExternalDeclarationsToSeparatePlace.kt @@ -8,11 +8,11 @@ package org.jetbrains.kotlin.ir.backend.js.lower import org.jetbrains.kotlin.backend.common.FileLoweringPass import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor import org.jetbrains.kotlin.ir.backend.js.lower.inline.addChild +import org.jetbrains.kotlin.ir.util.isEffectivelyExternal import org.jetbrains.kotlin.ir.declarations.IrExternalPackageFragment import org.jetbrains.kotlin.ir.declarations.IrFile import org.jetbrains.kotlin.ir.declarations.impl.IrExternalPackageFragmentImpl import org.jetbrains.kotlin.ir.symbols.IrExternalPackageFragmentSymbol -import org.jetbrains.kotlin.ir.util.isEffectivelyExternal import org.jetbrains.kotlin.name.FqName class MoveExternalDeclarationsToSeparatePlace : FileLoweringPass { diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/MultipleCatchesLowering.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/MultipleCatchesLowering.kt index c6826fb36be..7a0892ceae4 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/MultipleCatchesLowering.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/MultipleCatchesLowering.kt @@ -69,7 +69,7 @@ class MultipleCatchesLowering(val context: JsIrBackendContext) : FileLoweringPas val commonType = mergeTypes(aTry.catches.map { it.catchParameter.type }) - val pendingExceptionDeclaration = JsIrBuilder.buildVar(commonType, "\$p").apply { parent = data } + val pendingExceptionDeclaration = JsIrBuilder.buildVar(commonType, data, "\$p") val pendingException = JsIrBuilder.buildGetValue(pendingExceptionDeclaration.symbol) val branches = mutableListOf() diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/SecondaryCtorLowering.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/SecondaryCtorLowering.kt index 1e836d8ded4..9ed22e550b9 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/SecondaryCtorLowering.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/SecondaryCtorLowering.kt @@ -257,7 +257,7 @@ class SecondaryCtorLowering(val context: JsIrBackendContext) { newTarget: IrSimpleFunctionSymbol ) = IrCallImpl(call.startOffset, call.endOffset, call.type, newTarget).apply { - copyTypeArgumentsFrom(call) +// copyTypeArgumentsFrom(call) for (i in 0 until call.valueArgumentsCount) { putValueArgument(i, call.getValueArgument(i)) diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/TypeOperatorLowering.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/TypeOperatorLowering.kt index 2293dffc117..ab0579c8cca 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/TypeOperatorLowering.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/TypeOperatorLowering.kt @@ -6,7 +6,8 @@ package org.jetbrains.kotlin.ir.backend.js.lower import org.jetbrains.kotlin.backend.common.FileLoweringPass -import org.jetbrains.kotlin.backend.common.utils.* +import org.jetbrains.kotlin.backend.common.utils.getPrimitiveArrayElementType +import org.jetbrains.kotlin.backend.common.utils.isPrimitiveArray import org.jetbrains.kotlin.ir.IrStatement import org.jetbrains.kotlin.ir.backend.js.JsIrBackendContext import org.jetbrains.kotlin.ir.backend.js.ir.JsIrArithBuilder @@ -178,7 +179,7 @@ class TypeOperatorLowering(val context: JsIrBackendContext) : FileLoweringPass { newStatements: MutableList, declaration: IrDeclarationParent ): IrExpression { - val varDeclaration = JsIrBuilder.buildVar(value.type, initializer = value).apply { parent = declaration } + val varDeclaration = JsIrBuilder.buildVar(value.type, declaration, initializer = value) newStatements += varDeclaration return JsIrBuilder.buildGetValue(varDeclaration.symbol) } diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/coroutines/StateMachineBuilder.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/coroutines/StateMachineBuilder.kt index be32d34c741..1919d4a7d2d 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/coroutines/StateMachineBuilder.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/coroutines/StateMachineBuilder.kt @@ -75,7 +75,7 @@ class StateMachineBuilder( val entryState = SuspendState(unit) val rootExceptionTrap = buildExceptionTrapState() - private val globalExceptionVar = JsIrBuilder.buildVar(exceptionSymbol.owner.type, "e").also { it.parent = function.owner } + private val globalExceptionVar = JsIrBuilder.buildVar(exceptionSymbol.owner.type, function.owner, "e") lateinit var globalCatch: IrCatch fun finalizeStateMachine() { @@ -719,5 +719,5 @@ class StateMachineBuilder( ) private fun tempVar(type: IrType, name: String = "tmp") = - JsIrBuilder.buildVar(type, name).also { it.parent = function.owner } + JsIrBuilder.buildVar(type, function.owner, name) } \ No newline at end of file diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/coroutines/SuspendFunctionsLowering.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/coroutines/SuspendFunctionsLowering.kt index 0805069ed6a..d954b891283 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/coroutines/SuspendFunctionsLowering.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/coroutines/SuspendFunctionsLowering.kt @@ -789,14 +789,15 @@ internal class SuspendFunctionsLowering(val context: JsIrBackendContext): FileLo dataArgument = function.valueParameters[0] exceptionArgument = function.valueParameters[1] - suspendResult = JsIrBuilder.buildVar(context.irBuiltIns.anyNType, "suspendResult", true).also { - it.parent = function - it.initializer = JsIrBuilder.buildGetValue(dataArgument.symbol) - } + suspendResult = JsIrBuilder.buildVar( + context.irBuiltIns.anyNType, + function, + "suspendResult", + true, + initializer = JsIrBuilder.buildGetValue(dataArgument.symbol) + ) - suspendState = JsIrBuilder.buildVar(coroutineImplLabelFieldSymbol.owner.type, "suspendState", true).also { - it.parent = function - } + suspendState = JsIrBuilder.buildVar(coroutineImplLabelFieldSymbol.owner.type, function, "suspendState", true) val body = (originalBody as IrBlockBody).run { diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/inline/ReturnableBlockLowering.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/inline/ReturnableBlockLowering.kt index 7a78a0b9b6c..0435cd85969 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/inline/ReturnableBlockLowering.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/inline/ReturnableBlockLowering.kt @@ -102,8 +102,7 @@ private class ReturnableBlockTransformer( if (expression !is IrReturnableBlock) return super.visitContainerExpression(expression, data) val variable by lazy { - JsIrBuilder.buildVar(expression.type, "tmp\$ret\$${data.labelCnt++}", true) - .also { it.parent = data.containingDeclaration } + JsIrBuilder.buildVar(expression.type, data.containingDeclaration, "tmp\$ret\$${data.labelCnt++}", true) } val loop by lazy { diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/utils/JsGenerationContext.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/utils/JsGenerationContext.kt index fc07009ded3..16beb49eb2b 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/utils/JsGenerationContext.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/utils/JsGenerationContext.kt @@ -46,7 +46,6 @@ class JsGenerationContext { fun getNameForSymbol(symbol: IrSymbol): JsName = staticContext.getNameForSymbol(symbol, this) fun getNameForType(type: IrType): JsName = staticContext.getNameForType(type, this) -// fun getNameForReceiver(symbol: IrValueSymbol, isExt: Boolean): JsName = staticContext.getNameForReceiver(symbol, isExt, this) fun getNameForLoop(loop: IrLoop): JsName? = staticContext.getNameForLoop(loop, this) val continuation diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/utils/SimpleNameGenerator.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/utils/SimpleNameGenerator.kt index 5cf697f441e..524e6216fce 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/utils/SimpleNameGenerator.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/utils/SimpleNameGenerator.kt @@ -93,7 +93,7 @@ class SimpleNameGenerator : NameGenerator { val descriptor = declaration.descriptor - if (declaration.isDynamic) { + if (declaration.isDynamic()) { return@getOrPut nameDeclarator(declaration.descriptor.name.asString()) } diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/SharedVariablesManager.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/SharedVariablesManager.kt index 83bf97ea2c8..a3b38d02c2b 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/SharedVariablesManager.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/SharedVariablesManager.kt @@ -178,8 +178,8 @@ class JvmSharedVariablesManager( ) return IrVariableImpl( originalDeclaration.startOffset, originalDeclaration.endOffset, originalDeclaration.origin, - sharedVariableSymbol, sharedVariableDescriptor.type.toIrType()!!, refConstructorCall - ) + sharedVariableSymbol, sharedVariableDescriptor.type.toIrType()!! + ).apply { initializer = refConstructorCall } } override fun defineSharedValue( diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/InterfaceLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/InterfaceLowering.kt index 879dbdae793..b98bc5a5378 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/InterfaceLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/InterfaceLowering.kt @@ -8,52 +8,46 @@ package org.jetbrains.kotlin.backend.jvm.lower import org.jetbrains.kotlin.backend.common.ClassLoweringPass import org.jetbrains.kotlin.backend.common.lower.DECLARATION_ORIGIN_FUNCTION_FOR_DEFAULT_PARAMETER import org.jetbrains.kotlin.backend.common.lower.InitializersLowering.Companion.clinitName -import org.jetbrains.kotlin.backend.common.lower.VariableRemapper -import org.jetbrains.kotlin.backend.jvm.JvmLoweredDeclarationOrigin -import org.jetbrains.kotlin.backend.jvm.descriptors.DefaultImplsClassDescriptorImpl +import org.jetbrains.kotlin.backend.common.lower.VariableRemapperDesc +import org.jetbrains.kotlin.backend.jvm.JvmBackendContext import org.jetbrains.kotlin.codegen.AsmUtil -import org.jetbrains.kotlin.codegen.state.GenerationState -import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.descriptors.annotations.Annotations import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl import org.jetbrains.kotlin.ir.declarations.IrClass +import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin import org.jetbrains.kotlin.ir.declarations.IrFunction import org.jetbrains.kotlin.ir.declarations.IrValueParameter -import org.jetbrains.kotlin.ir.declarations.impl.IrClassImpl import org.jetbrains.kotlin.ir.declarations.impl.IrFunctionImpl import org.jetbrains.kotlin.ir.symbols.impl.IrSimpleFunctionSymbolImpl import org.jetbrains.kotlin.ir.util.createParameterDeclarations import org.jetbrains.kotlin.ir.util.isInterface import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid -import org.jetbrains.kotlin.load.java.JvmAbi import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.types.KotlinType import org.jetbrains.org.objectweb.asm.Opcodes -class InterfaceLowering(val state: GenerationState) : IrElementTransformerVoid(), ClassLoweringPass { +class InterfaceLowering(val context: JvmBackendContext) : IrElementTransformerVoid(), ClassLoweringPass { + + val state = context.state override fun lower(irClass: IrClass) { if (!irClass.isInterface) return - val interfaceDescriptor = irClass.descriptor - val defaultImplsDescriptor = createDefaultImplsClassDescriptor(interfaceDescriptor) - val defaultImplsIrClass = - IrClassImpl(irClass.startOffset, irClass.endOffset, JvmLoweredDeclarationOrigin.DEFAULT_IMPLS, defaultImplsDescriptor) + val defaultImplsIrClass = context.declarationFactory.getDefaultImplsClass(irClass) irClass.declarations.add(defaultImplsIrClass) - val members = defaultImplsIrClass.declarations irClass.declarations.filterIsInstance().forEach { val descriptor = it.descriptor if (it.origin == DECLARATION_ORIGIN_FUNCTION_FOR_DEFAULT_PARAMETER) { members.add(it) //just copy $default to DefaultImpls - } else if (descriptor.modality != Modality.ABSTRACT) { - val functionDescriptorImpl = - createDefaultImplFunDescriptor(defaultImplsDescriptor, descriptor, interfaceDescriptor, state.typeMapper) - members.add(functionDescriptorImpl.createFunctionAndMapVariables(it, it.visibility)) + } else if (descriptor.modality != Modality.ABSTRACT && it.origin != IrDeclarationOrigin.FAKE_OVERRIDE) { + val element = context.declarationFactory.getDefaultImplsFunction(it) + members.add(element) + element.body = it.body it.body = null //TODO reset modality to abstract } @@ -76,24 +70,6 @@ class InterfaceLowering(val state: GenerationState) : IrElementTransformerVoid() irClass.declarations.removeAll(privateToRemove) irClass.declarations.removeAll(defaultBodies) } - - companion object { - - fun createDefaultImplsClassDescriptor(interfaceDescriptor: ClassDescriptor): DefaultImplsClassDescriptorImpl { - return DefaultImplsClassDescriptorImpl( - Name.identifier(JvmAbi.DEFAULT_IMPLS_CLASS_NAME), interfaceDescriptor, interfaceDescriptor.source - ) - } - - fun createDefaultImplFunDescriptor( - defaultImplsDescriptor: DefaultImplsClassDescriptorImpl, - descriptor: FunctionDescriptor, - interfaceDescriptor: ClassDescriptor, typeMapper: KotlinTypeMapper - ): SimpleFunctionDescriptorImpl { - val name = Name.identifier(typeMapper.mapAsmMethod(descriptor).name) - return createStaticFunctionWithReceivers(defaultImplsDescriptor, name, descriptor, interfaceDescriptor.defaultType) - } - } } @@ -135,18 +111,20 @@ internal fun createStaticFunctionWithReceivers( internal fun FunctionDescriptor.createFunctionAndMapVariables( oldFunction: IrFunction, - visibility: Visibility + visibility: Visibility = oldFunction.visibility, + origin: IrDeclarationOrigin = oldFunction.origin ) = IrFunctionImpl( - oldFunction.startOffset, oldFunction.endOffset, oldFunction.origin, IrSimpleFunctionSymbolImpl(this), + oldFunction.startOffset, oldFunction.endOffset, origin, IrSimpleFunctionSymbolImpl(this), visibility = visibility ).apply { body = oldFunction.body returnType = oldFunction.returnType createParameterDeclarations() - val mapping: Map = - (listOfNotNull(oldFunction.dispatchReceiverParameter!!, oldFunction.extensionReceiverParameter) + oldFunction.valueParameters) - .zip(valueParameters).toMap() + // TODO: do we really need descriptor here? This workaround is about coping `dispatchReceiver` descriptor + val mapping: Map = + (listOfNotNull(oldFunction.dispatchReceiverParameter!!.descriptor, oldFunction.extensionReceiverParameter?.descriptor) + oldFunction.valueParameters.map { it.descriptor }) + .zip(valueParameters).toMap() - body?.transform(VariableRemapper(mapping), null) + body?.transform(VariableRemapperDesc(mapping), null) } diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/FunctionGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/FunctionGenerator.kt index 4c67ca79c80..8f17c62fe8b 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/FunctionGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/FunctionGenerator.kt @@ -242,7 +242,6 @@ class FunctionGenerator(declarationGenerator: DeclarationGenerator) : Declaratio ktConstructorElement.pureStartOffset, ktConstructorElement.pureEndOffset, IrDeclarationOrigin.DEFINED, constructorDescriptor ).buildWithScope { irConstructor -> - declarationGenerator.generateScopedTypeParameterDeclarations(irConstructor, constructorDescriptor.typeParameters) generateValueParameterDeclarations(irConstructor, ktParametersElement, null) irConstructor.body = createBodyGenerator(irConstructor.symbol).generateBody() irConstructor.returnType = constructorDescriptor.returnType.toIrType() diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrVariableImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrVariableImpl.kt index 1f54f795cc4..7fccef108aa 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrVariableImpl.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrVariableImpl.kt @@ -55,24 +55,6 @@ class IrVariableImpl( isLateinit = symbol.descriptor.isLateInit ) - constructor( - startOffset: Int, - endOffset: Int, - origin: IrDeclarationOrigin, - symbol: IrVariableSymbol, - type: IrType, - initializer: IrExpression? - ) : this( - startOffset, endOffset, origin, symbol, - symbol.descriptor.name, type, - isVar = symbol.descriptor.isVar, - isConst = symbol.descriptor.isConst, - isLateinit = symbol.descriptor.isLateInit - ) { - this.initializer = initializer - } - - @Deprecated("Use constructor which takes symbol instead of descriptor") constructor( startOffset: Int, endOffset: Int, @@ -81,7 +63,6 @@ class IrVariableImpl( type: IrType ) : this(startOffset, endOffset, origin, IrVariableSymbolImpl(descriptor), type) - @Deprecated("Use constructor which takes symbol instead of descriptor") constructor( startOffset: Int, endOffset: Int, diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazySymbolTable.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazySymbolTable.kt index a34aacaa19b..f6a8b79eaee 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazySymbolTable.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazySymbolTable.kt @@ -5,14 +5,9 @@ package org.jetbrains.kotlin.ir.declarations.lazy -import org.jetbrains.kotlin.descriptors.ClassConstructorDescriptor -import org.jetbrains.kotlin.descriptors.ClassDescriptor -import org.jetbrains.kotlin.descriptors.FunctionDescriptor -import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor +import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.ir.symbols.* -import org.jetbrains.kotlin.ir.util.DeclarationStubGenerator -import org.jetbrains.kotlin.ir.util.ReferenceSymbolTable -import org.jetbrains.kotlin.ir.util.SymbolTable +import org.jetbrains.kotlin.ir.util.* class IrLazySymbolTable(private val originalTable: SymbolTable) : ReferenceSymbolTable by originalTable { diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrUtils.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrUtils.kt index 462b66173ad..d6bccf96a23 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrUtils.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrUtils.kt @@ -158,7 +158,6 @@ fun IrFunction.createParameterDeclarations() { assert(valueParameters.isEmpty()) descriptor.valueParameters.mapTo(valueParameters) { it.irValueParameter() } -// valueParameters.mapTo(valueParameters) { it.descriptor.irValueParameter() } assert(typeParameters.isEmpty()) descriptor.typeParameters.mapTo(typeParameters) { @@ -331,7 +330,6 @@ fun IrCall.isSuperToAny() = superQualifier?.let { this.symbol.owner.isFakeOverri fun IrDeclaration.isEffectivelyExternal(): Boolean { return when (this) { - is IrConstructor -> isExternal || parent is IrDeclaration && parent.isEffectivelyExternal() is IrFunction -> isExternal || parent is IrDeclaration && parent.isEffectivelyExternal() is IrField -> isExternal || parent is IrDeclaration && parent.isEffectivelyExternal() is IrClass -> isExternal || parent is IrDeclaration && parent.isEffectivelyExternal() @@ -339,7 +337,7 @@ fun IrDeclaration.isEffectivelyExternal(): Boolean { } } -val IrDeclaration.isDynamic get() = this is IrFunction && dispatchReceiverParameter?.type is IrDynamicType +fun IrDeclaration.isDynamic() = this is IrFunction && dispatchReceiverParameter?.type is IrDynamicType fun IrValueParameter.copy(newDescriptor: ParameterDescriptor): IrValueParameter { assert(this.descriptor.type == newDescriptor.type)