From b2c78e490e49d3010b9fb2bc6c40d9ba4df7cc79 Mon Sep 17 00:00:00 2001 From: Mikhail Glukhikh Date: Mon, 8 Jun 2020 13:24:30 +0300 Subject: [PATCH] [FIR2IR] Remove some descriptor-around calls --- .../kotlin/fir/backend/ConversionUtils.kt | 9 +++-- .../fir/backend/Fir2IrClassifierStorage.kt | 13 +++++--- .../fir/backend/Fir2IrDeclarationStorage.kt | 6 ++-- .../kotlin/fir/backend/Fir2IrVisitor.kt | 16 ++++++--- .../kotlin/fir/backend/FirMetadataSource.kt | 11 +++---- .../generators/CallAndReferenceGenerator.kt | 33 ++++++++++++++++--- .../generators/ClassMemberGenerator.kt | 14 +++++--- .../generators/DataClassMembersGenerator.kt | 3 +- .../generators/OperatorExpressionGenerator.kt | 9 +++-- .../box/multiplatform/optionalExpectation.kt | 1 - 10 files changed, 78 insertions(+), 37 deletions(-) diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConversionUtils.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConversionUtils.kt index 4e1065053db..dba53cfb583 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConversionUtils.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConversionUtils.kt @@ -43,7 +43,6 @@ import org.jetbrains.kotlin.ir.symbols.IrSymbol import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol import org.jetbrains.kotlin.ir.symbols.IrValueSymbol import org.jetbrains.kotlin.ir.expressions.impl.IrConstImpl -import org.jetbrains.kotlin.ir.symbols.* import org.jetbrains.kotlin.ir.symbols.impl.IrClassPublicSymbolImpl import org.jetbrains.kotlin.ir.symbols.impl.IrClassSymbolImpl import org.jetbrains.kotlin.ir.types.* @@ -503,7 +502,11 @@ fun Fir2IrComponents.createSafeCallConstruction( statements += receiverVariable statements += IrWhenImpl(startOffset, endOffset, resultType).apply { val condition = IrCallImpl( - startOffset, endOffset, irBuiltIns.booleanType, irBuiltIns.eqeqSymbol, origin = IrStatementOrigin.EQEQ + startOffset, endOffset, irBuiltIns.booleanType, + irBuiltIns.eqeqSymbol, + valueArgumentsCount = 2, + typeArgumentsCount = 0, + origin = IrStatementOrigin.EQEQ ).apply { putValueArgument(0, IrGetValueImpl(startOffset, endOffset, receiverVariableSymbol)) putValueArgument(1, IrConstImpl.constNull(startOffset, endOffset, irBuiltIns.nothingNType)) @@ -526,7 +529,7 @@ fun Fir2IrComponents.createTemporaryVariableForSafeCallConstruction( val receiverVariable = declarationStorage.declareTemporaryVariable(receiverExpression, "safe_receiver").apply { parent = conversionScope.parentFromStack() } - val variableSymbol = symbolTable.referenceValue(receiverVariable.descriptor) + val variableSymbol = receiverVariable.symbol return Pair(receiverVariable, variableSymbol) } diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrClassifierStorage.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrClassifierStorage.kt index 67959f980a5..acbaf02c0cd 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrClassifierStorage.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrClassifierStorage.kt @@ -230,8 +230,7 @@ class Fir2IrClassifierStorage( isExpect = regularClass.isExpect, isFun = regularClass.isFun ).apply { - val descriptor = symbol.descriptor - metadata = FirMetadataSource.Class(regularClass, descriptor as WrappedClassDescriptor) + metadata = FirMetadataSource.Class(regularClass) } } } @@ -263,8 +262,7 @@ class Fir2IrClassifierStorage( anonymousObject.classKind.takeIf { it == ClassKind.ENUM_ENTRY } ?: ClassKind.CLASS, visibility, modality ).apply { - val descriptor = symbol.descriptor - metadata = FirMetadataSource.Class(anonymousObject, descriptor as WrappedClassDescriptor) + metadata = FirMetadataSource.Class(anonymousObject) setThisReceiver(anonymousObject.typeParameters) if (irParent != null) { this.parent = irParent @@ -388,8 +386,13 @@ class Fir2IrClassifierStorage( this.correspondingClass = klass } else if (irParent != null && origin == IrDeclarationOrigin.DEFINED) { + val constructor = irParent.constructors.first() this.initializerExpression = IrExpressionBodyImpl( - IrEnumConstructorCallImpl(startOffset, endOffset, irType, irParent.constructors.first().symbol) + IrEnumConstructorCallImpl( + startOffset, endOffset, irType, constructor.symbol, + valueArgumentsCount = constructor.valueParameters.size, + typeArgumentsCount = constructor.typeParameters.size + ) ) } declarationStorage.leaveScope(this) diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrDeclarationStorage.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrDeclarationStorage.kt index aaf6871887d..32bb05a0869 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrDeclarationStorage.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrDeclarationStorage.kt @@ -476,7 +476,7 @@ class Fir2IrDeclarationStorage( isFakeOverride = updatedOrigin == IrDeclarationOrigin.FAKE_OVERRIDE, isOperator = simpleFunction?.isOperator == true ).apply { - metadata = FirMetadataSource.Function(function, descriptor) + metadata = FirMetadataSource.Function(function) enterScope(this) bindAndDeclareParameters( function, irParent, @@ -545,7 +545,7 @@ class Fir2IrDeclarationStorage( constructor.returnTypeRef.toIrType(), isInline = false, isExternal = false, isPrimary = isPrimary, isExpect = false ).apply { - metadata = FirMetadataSource.Function(constructor, descriptor) + metadata = FirMetadataSource.Function(constructor) enterScope(this) bindAndDeclareParameters(constructor, irParent, isStatic = false) leaveScope(this) @@ -601,7 +601,7 @@ class Fir2IrDeclarationStorage( isOperator = false ).apply { if (propertyAccessor != null) { - metadata = FirMetadataSource.Function(propertyAccessor, descriptor) + metadata = FirMetadataSource.Function(propertyAccessor) } with(classifierStorage) { setTypeParameters( diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt index b706ab84480..39f60900403 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt @@ -65,7 +65,7 @@ class Fir2IrVisitor( private val memberGenerator = ClassMemberGenerator(components, this, conversionScope, callGenerator, fakeOverrideMode) - private val operatorGenerator = OperatorExpressionGenerator(components, this, callGenerator, conversionScope) + private val operatorGenerator = OperatorExpressionGenerator(components, this, conversionScope) private fun FirTypeRef.toIrType(): IrType = with(typeConverter) { toIrType() } @@ -106,10 +106,13 @@ class Fir2IrVisitor( converter.processAnonymousObjectMembers(enumEntry.initializer as FirAnonymousObject, correspondingClass) conversionScope.withParent(correspondingClass) { memberGenerator.convertClassContent(correspondingClass, enumEntry.initializer as FirAnonymousObject) + val constructor = correspondingClass.constructors.first() irEnumEntry.initializerExpression = IrExpressionBodyImpl( IrEnumConstructorCallImpl( startOffset, endOffset, enumEntry.returnTypeRef.toIrType(), - correspondingClass.constructors.first().symbol + constructor.symbol, + typeArgumentsCount = constructor.typeParameters.size, + valueArgumentsCount = constructor.valueParameters.size ) ) } @@ -598,7 +601,10 @@ class Fir2IrVisitor( } if (whenExpression.isExhaustive && !unconditionalBranchFound) { val irResult = IrCallImpl( - startOffset, endOffset, irBuiltIns.nothingType, irBuiltIns.noWhenBranchMatchedExceptionSymbol + startOffset, endOffset, irBuiltIns.nothingType, + irBuiltIns.noWhenBranchMatchedExceptionSymbol, + typeArgumentsCount = 0, + valueArgumentsCount = 0 ) branches += IrElseBranchImpl( IrConstImpl.boolean(startOffset, endOffset, irBuiltIns.booleanType, true), irResult @@ -757,7 +763,9 @@ class Fir2IrVisitor( startOffset, endOffset, checkNotNullCall.typeRef.toIrType(), irBuiltIns.checkNotNullSymbol, - IrStatementOrigin.EXCLEXCL + typeArgumentsCount = 1, + valueArgumentsCount = 1, + origin = IrStatementOrigin.EXCLEXCL ).apply { putTypeArgument(0, checkNotNullCall.argument.typeRef.toIrType().makeNotNull()) putValueArgument(0, convertToIrExpression(checkNotNullCall.argument)) diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/FirMetadataSource.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/FirMetadataSource.kt index be29e9a2186..6f119d5b374 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/FirMetadataSource.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/FirMetadataSource.kt @@ -5,13 +5,10 @@ package org.jetbrains.kotlin.fir.backend -import org.jetbrains.kotlin.descriptors.DeclarationDescriptor -import org.jetbrains.kotlin.descriptors.FunctionDescriptor import org.jetbrains.kotlin.descriptors.PropertyDescriptor import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.ir.declarations.MetadataSource -import org.jetbrains.kotlin.ir.descriptors.WrappedClassDescriptor interface FirMetadataSource : MetadataSource { @@ -22,15 +19,15 @@ interface FirMetadataSource : MetadataSource { ) : MetadataSource.File(emptyList()), FirMetadataSource class Class( - val klass: FirClass<*>, descriptor: WrappedClassDescriptor - ) : MetadataSource.Class(descriptor), FirMetadataSource { + val klass: FirClass<*> + ) : FirMetadataSource { override val session: FirSession get() = klass.session } class Function( - val function: FirFunction<*>, descriptor: FunctionDescriptor - ) : MetadataSource.Function(descriptor), FirMetadataSource { + val function: FirFunction<*> + ) : FirMetadataSource { override val session: FirSession get() = function.session } diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt index 2f5931d1d26..a6698ffba05 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt @@ -81,13 +81,16 @@ internal class CallAndReferenceGenerator( IrFunctionReferenceImpl( startOffset, endOffset, type, symbol, typeArgumentsCount = constructor.typeParameters.size + (klass?.typeParameters?.size ?: 0), + valueArgumentsCount = constructor.valueParameters.size, reflectionTarget = symbol ) } is IrFunctionSymbol -> { + val function = symbol.owner IrFunctionReferenceImpl( startOffset, endOffset, type, symbol, - typeArgumentsCount = symbol.owner.typeParameters.size, + typeArgumentsCount = function.typeParameters.size, + valueArgumentsCount = function.valueParameters.size, reflectionTarget = symbol ) } @@ -159,6 +162,8 @@ internal class CallAndReferenceGenerator( is IrSimpleFunctionSymbol -> { IrCallImpl( startOffset, endOffset, type, symbol, + typeArgumentsCount = symbol.owner.typeParameters.size, + valueArgumentsCount = symbol.owner.valueParameters.size, origin = qualifiedAccess.calleeReference.statementOrigin(), superQualifierSymbol = superQualifierSymbol ) @@ -168,7 +173,10 @@ internal class CallAndReferenceGenerator( val backingField = symbol.owner.backingField when { getter != null -> IrCallImpl( - startOffset, endOffset, type, getter.symbol, origin = IrStatementOrigin.GET_PROPERTY, + startOffset, endOffset, type, getter.symbol, + typeArgumentsCount = getter.typeParameters.size, + valueArgumentsCount = 0, + origin = IrStatementOrigin.GET_PROPERTY, superQualifierSymbol = superQualifierSymbol ) backingField != null -> IrGetFieldImpl( @@ -213,7 +221,12 @@ internal class CallAndReferenceGenerator( val setter = irProperty.setter val backingField = irProperty.backingField when { - setter != null -> IrCallImpl(startOffset, endOffset, type, setter.symbol, origin).apply { + setter != null -> IrCallImpl( + startOffset, endOffset, type, setter.symbol, + typeArgumentsCount = setter.typeParameters.size, + valueArgumentsCount = 1, + origin = origin + ).apply { putValueArgument(0, assignedValue) } backingField != null -> IrSetFieldImpl(startOffset, endOffset, backingField.symbol, type).apply { @@ -224,7 +237,12 @@ internal class CallAndReferenceGenerator( } } is IrSimpleFunctionSymbol -> { - IrCallImpl(startOffset, endOffset, type, symbol, origin).apply { + IrCallImpl( + startOffset, endOffset, type, symbol, + typeArgumentsCount = symbol.owner.typeParameters.size, + valueArgumentsCount = 1, + origin = origin + ).apply { putValueArgument(0, assignedValue) } } @@ -250,7 +268,12 @@ internal class CallAndReferenceGenerator( if (irConstructor == null) { IrErrorCallExpressionImpl(startOffset, endOffset, type, "No annotation constructor found: ${irClass.name}") } else { - IrConstructorCallImpl.fromSymbolDescriptor(startOffset, endOffset, type, irConstructor) + IrConstructorCallImpl( + startOffset, endOffset, type, irConstructor, + valueArgumentsCount = irConstructor.owner.valueParameters.size, + typeArgumentsCount = 0, + constructorTypeArgumentsCount = 0 + ) } } diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/ClassMemberGenerator.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/ClassMemberGenerator.kt index aec81407578..2ff37b0a876 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/ClassMemberGenerator.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/ClassMemberGenerator.kt @@ -211,9 +211,9 @@ internal class ClassMemberGenerator( conversionScope.withParent(this) { declarationStorage.enterScope(this) val backingField = correspondingProperty.backingField - val fieldSymbol = symbolTable.referenceField(correspondingProperty.descriptor) + val fieldSymbol = backingField?.symbol val declaration = this - if (backingField != null) { + if (fieldSymbol != null) { body = IrBlockBodyImpl( startOffset, endOffset, listOf( @@ -260,12 +260,14 @@ internal class ClassMemberGenerator( return convertWithOffsets { startOffset, endOffset -> val irConstructorSymbol = declarationStorage.getIrFunctionSymbol(constructorSymbol) as IrConstructorSymbol if (constructorSymbol.fir.isFromEnumClass || constructorSymbol.fir.returnTypeRef.isEnum) { + val typeArguments = (constructedTypeRef as? FirResolvedTypeRef)?.type?.typeArguments IrEnumConstructorCallImpl( startOffset, endOffset, constructedIrType, - irConstructorSymbol + irConstructorSymbol, + typeArgumentsCount = typeArguments?.size ?: 0, + valueArgumentsCount = constructorSymbol.fir.valueParameters.size ).apply { - val typeArguments = (constructedTypeRef as? FirResolvedTypeRef)?.type?.typeArguments if (typeArguments?.isNotEmpty() == true) { val irType = (typeArguments.first() as ConeKotlinTypeProjection).type.toIrType() putTypeArgument(0, irType) @@ -275,7 +277,9 @@ internal class ClassMemberGenerator( IrDelegatingConstructorCallImpl( startOffset, endOffset, constructedIrType, - irConstructorSymbol + irConstructorSymbol, + valueArgumentsCount = irConstructorSymbol.owner.valueParameters.size, + typeArgumentsCount = irConstructorSymbol.owner.typeParameters.size ) }.let { if (firDispatchReceiver !is FirNoReceiverExpression) { diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/DataClassMembersGenerator.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/DataClassMembersGenerator.kt index 22f11f47c18..112f1ba7f61 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/DataClassMembersGenerator.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/DataClassMembersGenerator.kt @@ -264,8 +264,7 @@ class DataClassMembersGenerator(val components: Fir2IrComponents) { } ) } - }, - descriptor + } ) } diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/OperatorExpressionGenerator.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/OperatorExpressionGenerator.kt index e8f0d96849b..5ca02a8e15f 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/OperatorExpressionGenerator.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/OperatorExpressionGenerator.kt @@ -25,7 +25,6 @@ import org.jetbrains.kotlin.ir.util.getSimpleFunction internal class OperatorExpressionGenerator( private val components: Fir2IrComponents, private val visitor: Fir2IrVisitor, - private val callGenerator: CallAndReferenceGenerator, private val conversionScope: Fir2IrConversionScope ) : Fir2IrComponents by components { @@ -156,7 +155,13 @@ internal class OperatorExpressionGenerator( ?: throw AssertionError("No conversion function for $operandType ~> $targetType") val dispatchReceiver = this@asComparisonOperand - val unsafeIrCall = IrCallImpl(startOffset, endOffset, conversionFunction.owner.returnType, conversionFunction).also { + val unsafeIrCall = IrCallImpl( + startOffset, endOffset, + conversionFunction.owner.returnType, + conversionFunction, + valueArgumentsCount = 0, + typeArgumentsCount = 0 + ).also { it.dispatchReceiver = dispatchReceiver } return if (operandType.isNullable) { diff --git a/compiler/testData/codegen/box/multiplatform/optionalExpectation.kt b/compiler/testData/codegen/box/multiplatform/optionalExpectation.kt index dd8d1270904..91d1f7864b7 100644 --- a/compiler/testData/codegen/box/multiplatform/optionalExpectation.kt +++ b/compiler/testData/codegen/box/multiplatform/optionalExpectation.kt @@ -1,7 +1,6 @@ // !LANGUAGE: +MultiPlatformProjects // !USE_EXPERIMENTAL: kotlin.ExperimentalMultiplatform // IGNORE_BACKEND: NATIVE -// IGNORE_BACKEND_FIR: JVM_IR // WITH_RUNTIME // MODULE: library // FILE: expected.kt