wip
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrDelegatingConstructorCallImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrDelegatingConstructorCallImpl.kt
index c61c9f1..6792621 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrDelegatingConstructorCallImpl.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrDelegatingConstructorCallImpl.kt
@@ -32,9 +32,8 @@
override val symbol: IrConstructorSymbol,
typeArgumentsCount: Int,
valueArgumentsCount: Int,
+ override val origin: IrStatementOrigin? = null
) : IrDelegatingConstructorCall() {
- override val origin: IrStatementOrigin?
- get() = null
override val typeArgumentsByIndex: Array<IrType?> = arrayOfNulls(typeArgumentsCount)
diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/ClassifierExplorer.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/ClassifierExplorer.kt
index 07d46b3..02ba03b 100644
--- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/ClassifierExplorer.kt
+++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/ClassifierExplorer.kt
@@ -8,8 +8,6 @@
import org.jetbrains.kotlin.backend.common.serialization.unlinked.ExploredClassifier.Unusable
import org.jetbrains.kotlin.backend.common.serialization.unlinked.ExploredClassifier.Unusable.*
import org.jetbrains.kotlin.backend.common.serialization.unlinked.ExploredClassifier.Usable
-import org.jetbrains.kotlin.backend.common.serialization.unlinked.PartialLinkageUtils.DeclarationId
-import org.jetbrains.kotlin.backend.common.serialization.unlinked.PartialLinkageUtils.DeclarationId.Companion.declarationId
import org.jetbrains.kotlin.backend.common.serialization.unlinked.PartialLinkageUtils.isEffectivelyMissingLazyIrDeclaration
import org.jetbrains.kotlin.builtins.PrimitiveType
import org.jetbrains.kotlin.builtins.StandardNames.BUILT_INS_PACKAGE_FQ_NAME
@@ -24,7 +22,6 @@
import org.jetbrains.kotlin.ir.expressions.*
import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
import org.jetbrains.kotlin.ir.symbols.IrClassifierSymbol
-import org.jetbrains.kotlin.ir.symbols.IrConstructorSymbol
import org.jetbrains.kotlin.ir.types.*
import org.jetbrains.kotlin.ir.util.*
import org.jetbrains.kotlin.ir.visitors.IrElementVisitorVoid
@@ -231,62 +228,8 @@
return InvalidInheritance(symbol, superClassSymbols) // Invalid inheritance.
}
- // Check delegating constructor calls.
- val ownConstructors: Map<IrConstructorSymbol, IrConstructor> = declarations
- .filterIsInstance<IrConstructor>()
- .associateBy { it.symbol }
-
- ownConstructors.forEach { (_, constructor) ->
- var unexpectedSuperClassConstructorSymbol: IrConstructorSymbol? = null
-
- constructor.acceptChildrenVoid(object : IrElementVisitorVoid {
- override fun visitElement(element: IrElement) {
- if (unexpectedSuperClassConstructorSymbol != null)
- return // Break.
-
- element.acceptChildrenVoid(this)
- }
-
- override fun visitClass(declaration: IrClass) {
- // Skip nested
- }
-
- override fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall) {
- if (unexpectedSuperClassConstructorSymbol != null)
- return // Break.
-
- val calledConstructorSymbol = expression.symbol
- if (calledConstructorSymbol in ownConstructors) return // OK, just calling another constructor of the same class
-
- if (calledConstructorSymbol.isBound) {
- val calledConstructor = calledConstructorSymbol.owner
- if (calledConstructor.origin != PartiallyLinkedDeclarationOrigin.MISSING_DECLARATION) {
- val constructedSuperClassSymbol = calledConstructor.parentAsClass.symbol
- if (constructedSuperClassSymbol != superClassSymbol) {
- // Wrong delegating constructor call.
- unexpectedSuperClassConstructorSymbol = calledConstructorSymbol
- }
- }
- } else {
- // Fallback to signatures.
- (calledConstructorSymbol.signature as? IdSignature.CommonSignature)?.let { constructorSignature ->
- val constructedSuperClassId = DeclarationId(
- constructorSignature.packageFqName,
- constructorSignature.declarationFqName.substringBeforeLast('.')
- )
-
- if (superClassSymbol.owner.declarationId != constructedSuperClassId) {
- // Wrong delegating constructor call.
- unexpectedSuperClassConstructorSymbol = calledConstructorSymbol
- }
- }
- }
- }
- })
-
- if (unexpectedSuperClassConstructorSymbol != null)
- return InvalidInheritance(symbol, superClassSymbol, unexpectedSuperClassConstructorSymbol!!)
- }
+ // IMPORTANT: Constructor delegation is intentionally not performed here.
+ // For details see [InvalidInheritance].
}
return null
diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/PartiallyLinkedIrTreePatcher.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/PartiallyLinkedIrTreePatcher.kt
index 81db6d1..7540f4d 100644
--- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/PartiallyLinkedIrTreePatcher.kt
+++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/PartiallyLinkedIrTreePatcher.kt
@@ -6,7 +6,10 @@
package org.jetbrains.kotlin.backend.common.serialization.unlinked
import org.jetbrains.kotlin.backend.common.serialization.unlinked.PartialLinkageCase.*
+import org.jetbrains.kotlin.backend.common.serialization.unlinked.PartialLinkageUtils.DeclarationId
+import org.jetbrains.kotlin.backend.common.serialization.unlinked.PartialLinkageUtils.DeclarationId.Companion.declarationId
import org.jetbrains.kotlin.backend.common.serialization.unlinked.PartialLinkageUtils.isEffectivelyMissingLazyIrDeclaration
+import org.jetbrains.kotlin.backend.common.serialization.unlinked.PartiallyLinkedStatementOrigin.FIXED_CONSTRUCTOR_DELEGATION
import org.jetbrains.kotlin.backend.common.serialization.unlinked.PartiallyLinkedStatementOrigin.PARTIAL_LINKAGE_RUNTIME_ERROR
import org.jetbrains.kotlin.descriptors.ClassKind
import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
@@ -14,12 +17,11 @@
import org.jetbrains.kotlin.ir.declarations.*
import org.jetbrains.kotlin.ir.declarations.lazy.IrLazyDeclarationBase
import org.jetbrains.kotlin.ir.expressions.*
-import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl
-import org.jetbrains.kotlin.ir.expressions.impl.IrCompositeImpl
-import org.jetbrains.kotlin.ir.expressions.impl.IrConstImpl
+import org.jetbrains.kotlin.ir.expressions.impl.*
import org.jetbrains.kotlin.ir.overrides.isEffectivelyPrivate
import org.jetbrains.kotlin.ir.symbols.*
import org.jetbrains.kotlin.ir.symbols.impl.IrAnonymousInitializerSymbolImpl
+import org.jetbrains.kotlin.ir.types.IrSimpleType
import org.jetbrains.kotlin.ir.types.IrType
import org.jetbrains.kotlin.ir.util.*
import org.jetbrains.kotlin.ir.util.IrMessageLogger.Severity
@@ -203,8 +205,38 @@
return declaration.transformChildrenWithRemoval()
}
- override fun visitFunction(declaration: IrFunction): IrStatement {
- (declaration as? IrOverridableDeclaration<*>)?.filterOverriddenSymbols()
+ override fun visitConstructor(declaration: IrConstructor): IrStatement {
+ // IMPORTANT: It's necessary to overwrite types. Please don't remove this statement or move it somewhere else.
+ val unusableClassifierInSignature = declaration.rewriteTypesInFunction()
+
+ // IMPORTANT: It's necessary to fix constructor delegation. Please don't remove this statement or move it somewhere else.
+ val inheritanceIssue = declaration.fixConstructorDelegation()
+
+ // Compute the linkage case.
+ val partialLinkageCase = if (declaration.origin == PartiallyLinkedDeclarationOrigin.MISSING_DECLARATION)
+ MissingDeclaration(declaration.symbol)
+ else
+ (unusableClassifierInSignature ?: inheritanceIssue)?.let { DeclarationWithUnusableClassifier(declaration.symbol, it) }
+
+ if (partialLinkageCase != null) {
+ // Note: Block body is missing for MISSING_DECLARATION.
+ val blockBody = declaration.body as? IrBlockBody
+ ?: builtIns.irFactory.createBlockBody(declaration.startOffset, declaration.endOffset).apply { declaration.body = this }
+
+ // IMPORTANT: Unlike it's done for IrSimpleFunction don't clean-up statements. Insert PL linkage as the first one.
+ blockBody.statements.add(
+ 0, partialLinkageCase.throwLinkageError(
+ declaration,
+ suppressWarningInCompilerOutput = declaration.isDirectMemberOf(unusableClassifierInSignature)
+ )
+ )
+ }
+
+ return declaration.transformChildren()
+ }
+
+ override fun visitSimpleFunction(declaration: IrSimpleFunction): IrStatement {
+ declaration.filterOverriddenSymbols()
// IMPORTANT: It's necessary to overwrite types. Please don't move the statement below.
val unusableClassifierInSignature = declaration.rewriteTypesInFunction()
@@ -217,6 +249,7 @@
}
if (partialLinkageCase != null) {
+ // Note: Block body is missing for UNIMPLEMENTED_ABSTRACT_CALLABLE_MEMBER and MISSING_DECLARATION.
val blockBody = declaration.body as? IrBlockBody
?: builtIns.irFactory.createBlockBody(declaration.startOffset, declaration.endOffset).apply { declaration.body = this }
@@ -234,7 +267,7 @@
if (declaration.isTopLevelDeclaration) {
// Optimization: Remove unlinked top-level functions.
declaration.scheduleForRemoval()
- } else if (declaration is IrSimpleFunction) {
+ } else {
// Optimization: Remove unlinked top-level properties.
val property = declaration.correspondingPropertySymbol?.owner
if (property?.isTopLevelDeclaration == true)
@@ -285,6 +318,106 @@
return result
}
+ /**
+ * Check and fix constructor delegation. Note: This particular case of class exploration is intentionally performed
+ * outside of [ClassifierExplorer]. For details see [ExploredClassifier.Unusable.InvalidInheritance].
+ */
+ private fun IrConstructor.fixConstructorDelegation(): ExploredClassifier.Unusable.InvalidInheritance? {
+ if (origin == PartiallyLinkedDeclarationOrigin.MISSING_DECLARATION)
+ return null
+
+ val blockBody = body as? IrBlockBody
+ if (blockBody == null || blockBody.statements.isEmpty())
+ return null
+
+ val constructedClass = parentAsClass
+ val constructedClassSymbol = constructedClass.symbol
+
+ val actualSuperClassSymbol = constructedClass.superTypes
+ .firstNotNullOfOrNull { (it as? IrSimpleType)?.classifier as? IrClassSymbol }
+ ?: builtIns.anyClass
+ val actualSuperClass = actualSuperClassSymbol.owner
+
+ var inheritanceIssue: ExploredClassifier.Unusable.InvalidInheritance? = null
+
+ blockBody.statements.transformInPlace { statement ->
+ if (statement !is IrDelegatingConstructorCall)
+ return@transformInPlace statement
+
+ val calledConstructorSymbol = statement.symbol
+ val calledConstructor = calledConstructorSymbol.owner
+
+ val invalidConstructorDelegationFound =
+ if (calledConstructor.origin != PartiallyLinkedDeclarationOrigin.MISSING_DECLARATION) {
+ val constructedSuperClassSymbol = calledConstructor.parentAsClass.symbol
+ constructedSuperClassSymbol != constructedClassSymbol && constructedSuperClassSymbol != actualSuperClassSymbol
+ } else {
+ // Fallback to signatures.
+ (calledConstructorSymbol.signature as? IdSignature.CommonSignature)?.let { constructorSignature ->
+ val constructedSuperClassId = DeclarationId(
+ constructorSignature.packageFqName,
+ constructorSignature.declarationFqName.substringBeforeLast('.')
+ )
+
+ actualSuperClass.declarationId != constructedSuperClassId
+ } ?: false
+ }
+
+ if (!invalidConstructorDelegationFound)
+ return@transformInPlace statement
+
+ inheritanceIssue = ExploredClassifier.Unusable.InvalidInheritance(
+ symbol = constructedClassSymbol,
+ superClassSymbol = actualSuperClassSymbol,
+ unexpectedSuperClassConstructorSymbol = calledConstructorSymbol
+ )
+
+ val actualSuperClassConstructors = actualSuperClass.constructors.toMutableList()
+ val actualSuperClassConstructor = when (actualSuperClassConstructors.size) {
+ 0 -> error("Class without constructors: $actualSuperClass") // Normally, should not happen.
+ 1 -> actualSuperClassConstructors.first()
+ else -> {
+ // Try to find the best match.
+ actualSuperClassConstructors.sortWith(Comparator<IrConstructor> { a, b ->
+ val visibilitiesDiff = a.visibility.compareTo(b.visibility) ?: 0
+ if (visibilitiesDiff != 0) visibilitiesDiff else a.isPrimary.compareTo(b.isPrimary)
+ }.reversed())
+ actualSuperClassConstructors.first()
+ }
+ }
+
+ // An attempt to restore constructor delegation to avoid errors in subsequent lowerings and codegenerator phases.
+ IrDelegatingConstructorCallImpl(
+ statement.startOffset,
+ statement.endOffset,
+ actualSuperClass.defaultType,
+ actualSuperClassConstructor.symbol,
+ actualSuperClassConstructor.allTypeParameters.size,
+ actualSuperClassConstructor.valueParameters.size,
+ origin = FIXED_CONSTRUCTOR_DELEGATION
+ ).apply {
+ // Supply fake arguments. Anyway the super class constructor will never be called from here.
+ for (i in 0 until typeArgumentsCount) {
+ putTypeArgument(i, builtIns.anyNType)
+ }
+ for (i in 0 until valueArgumentsCount) {
+ putValueArgument(
+ i,
+ throwThrowable(
+ statement.startOffset,
+ statement.endOffset,
+ builtIns.throwIseSymbol,
+ FIXED_CONSTRUCTOR_DELEGATION,
+ "Not expected to be executed during the runtime"
+ )
+ )
+ }
+ }
+ }
+
+ return inheritanceIssue
+ }
+
override fun visitProperty(declaration: IrProperty): IrStatement {
declaration.filterOverriddenSymbols()
return declaration.transformChildren()
@@ -660,16 +793,33 @@
else
renderAndLogLinkageError(element, file)
+ return throwThrowable(
+ element.startOffset,
+ element.endOffset,
+ builtIns.linkageErrorSymbol,
+ PARTIAL_LINKAGE_RUNTIME_ERROR,
+ errorMessage
+ )
+ }
+
+ // Just a shortcut.
+ private fun throwThrowable(
+ startOffset: Int,
+ endOffset: Int,
+ throwingFunctionSymbol: IrSimpleFunctionSymbol,
+ origin: PartiallyLinkedStatementOrigin,
+ message: String
+ ): IrCall {
return IrCallImpl(
- startOffset = element.startOffset,
- endOffset = element.endOffset,
+ startOffset = startOffset,
+ endOffset = endOffset,
type = builtIns.nothingType,
- symbol = builtIns.linkageErrorSymbol,
+ symbol = throwingFunctionSymbol,
typeArgumentsCount = 0,
valueArgumentsCount = 1,
- origin = PARTIAL_LINKAGE_RUNTIME_ERROR
+ origin = origin
).apply {
- putValueArgument(0, IrConstImpl.string(startOffset, endOffset, builtIns.stringType, errorMessage))
+ putValueArgument(0, IrConstImpl.string(startOffset, endOffset, builtIns.stringType, message))
}
}
diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/PartiallyLinkedStatementOrigin.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/PartiallyLinkedStatementOrigin.kt
index 99347e8..249dc21 100644
--- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/PartiallyLinkedStatementOrigin.kt
+++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/PartiallyLinkedStatementOrigin.kt
@@ -6,7 +6,13 @@
package org.jetbrains.kotlin.backend.common.serialization.unlinked
import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin
+import org.jetbrains.kotlin.ir.expressions.IrDelegatingConstructorCall
+import org.jetbrains.kotlin.ir.expressions.IrExpression
internal enum class PartiallyLinkedStatementOrigin : IrStatementOrigin {
- PARTIAL_LINKAGE_RUNTIME_ERROR
+ /** An [IrExpression] that represents an PL runtime error. */
+ PARTIAL_LINKAGE_RUNTIME_ERROR,
+
+ /** An [IrDelegatingConstructorCall] that restores the correct constructor delegation. */
+ FIXED_CONSTRUCTOR_DELEGATION
}
