wip 18 - VERY DIRTY 13
diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/ClassifierExplorationResult.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/ExploredClassifier.kt
similarity index 89%
rename from compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/ClassifierExplorationResult.kt
rename to compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/ExploredClassifier.kt
index eb45460..3ddb1d8 100644
--- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/ClassifierExplorationResult.kt
+++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/ExploredClassifier.kt
@@ -12,11 +12,11 @@
* Describes the reason why a certain classifier is considered as unusable (partially linked or having visibility conflicts).
* For more details see [LinkedClassifierExplorer.exploreSymbol].
*/
-internal sealed interface ClassifierExplorationResult {
- /** Indicated unusable classifier. */
- sealed interface Unusable : ClassifierExplorationResult {
- val symbol: IrClassifierSymbol
+internal sealed interface ExploredClassifier {
+ val symbol: IrClassifierSymbol
+ /** Indicated unusable classifier. */
+ sealed interface Unusable : ExploredClassifier {
sealed interface CanBeRootCause : Unusable
/**
@@ -56,8 +56,7 @@
}
/** Indicates usable type that is fully linked and does not have visibility conflicts. */
- sealed interface Usable : ClassifierExplorationResult {
- val symbol: IrClassifierSymbol
+ sealed interface Usable : ExploredClassifier {
val visibility: ABIVisibility
class AccessibleClassifier(override val symbol: IrClassifierSymbol, override val visibility: ABIVisibility) : Usable
@@ -67,5 +66,7 @@
}
}
- object RecursionAvoidance : ClassifierExplorationResult
+ object RecursionAvoidance : ExploredClassifier {
+ override val symbol get() = error("Not supposed to be called")
+ }
}
diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/LinkedClassifierExplorer.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/LinkedClassifierExplorer.kt
index 5416af6..ae30ab9 100644
--- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/LinkedClassifierExplorer.kt
+++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/LinkedClassifierExplorer.kt
@@ -27,10 +27,10 @@
import org.jetbrains.kotlin.ir.visitors.acceptChildrenVoid
internal class LinkedClassifierExplorer(private val stubGenerator: MissingDeclarationStubGenerator) {
- private val exploredSymbols = THashMap<IrClassifierSymbol, ClassifierExplorationResult>()
+ private val exploredSymbols = THashMap<IrClassifierSymbol, ExploredClassifier>()
fun exploreType(type: IrType): TypeExplorationResult = type.exploreType(visitedSymbols = hashSetOf())
- fun exploreSymbol(symbol: IrClassifierSymbol): ClassifierExplorationResult = symbol.exploreSymbol(visitedSymbols = hashSetOf())
+ fun exploreSymbol(symbol: IrClassifierSymbol): ExploredClassifier = symbol.exploreSymbol(visitedSymbols = hashSetOf())
fun exploreIrElement(element: IrElement) {
element.acceptChildrenVoid(IrElementExplorer { it.exploreType(visitedSymbols = hashSetOf()) })
@@ -49,7 +49,7 @@
}
/** Explore the IR classifier symbol to find the first cause why this symbol should be considered as partially linked. */
- private fun IrClassifierSymbol.exploreSymbol(visitedSymbols: MutableSet<IrClassifierSymbol>): ClassifierExplorationResult {
+ private fun IrClassifierSymbol.exploreSymbol(visitedSymbols: MutableSet<IrClassifierSymbol>): ExploredClassifier {
// TODO: check filters
// if (this.isTrusted()) {
// return Fully.TrustedClassifier
@@ -62,24 +62,24 @@
if (!isBound) {
stubGenerator.getDeclaration(this) // Generate a stub and bind the symbol immediately.
- return registerClassifier(this, ClassifierExplorationResult.Unusable.MissingClassifier(this))
+ return registerClassifier(this, ExploredClassifier.Unusable.MissingClassifier(this))
} else if ((owner as? IrLazyDeclarationBase)?.descriptor is NotFoundClasses.MockClassDescriptor) {
// In case of Lazy IR the declaration is present, but wraps a special descriptor.
- return registerClassifier(this, ClassifierExplorationResult.Unusable.MissingClassifier(this))
+ return registerClassifier(this, ExploredClassifier.Unusable.MissingClassifier(this))
}
if (!visitedSymbols.add(this)) {
- return ClassifierExplorationResult.RecursionAvoidance
+ return ExploredClassifier.RecursionAvoidance
}
val explorationResult = when (val classifier = owner) {
is IrClass -> {
if (classifier.origin == PartiallyLinkedDeclarationOrigin.MISSING_DECLARATION)
- return registerClassifier(this, ClassifierExplorationResult.Unusable.MissingClassifier(this))
+ return registerClassifier(this, ExploredClassifier.Unusable.MissingClassifier(this))
val outerClassSymbol = if (classifier.isInner || classifier.isEnumEntry) {
classifier.parentClassOrNull?.symbol
- ?: return registerClassifier(this, ClassifierExplorationResult.Unusable.MissingEnclosingClass(this as IrClassSymbol))
+ ?: return registerClassifier(this, ExploredClassifier.Unusable.MissingEnclosingClass(this as IrClassSymbol))
} else null
classifierExploration {
@@ -99,19 +99,19 @@
return registerClassifier(this, explorationResult)
}
- private fun <S : ClassifierExplorationResult> registerClassifier(symbol: IrClassifierSymbol, explorationResult: S): S {
+ private fun <S : ExploredClassifier> registerClassifier(symbol: IrClassifierSymbol, explorationResult: S): S {
exploredSymbols[symbol] = explorationResult
return explorationResult
}
}
private abstract class ExplorationResultBuilder<R, UR : R> {
- protected var dependencyWithNarrowerVisibility: ClassifierExplorationResult.Usable.AccessibleClassifier? = null
+ protected var dependencyWithNarrowerVisibility: ExploredClassifier.Usable.AccessibleClassifier? = null
protected var unusableResult: UR? = null
private inline val done get() = unusableResult != null
- fun exploreByClassifier(block: () -> ClassifierExplorationResult) {
+ fun exploreByClassifier(block: () -> ExploredClassifier) {
if (!done) consume(block())
}
@@ -119,7 +119,7 @@
if (!done) consume(block())
}
- fun <T> exploreByClassifiers(collection: Collection<T>, block: (T) -> ClassifierExplorationResult?) {
+ fun <T> exploreByClassifiers(collection: Collection<T>, block: (T) -> ExploredClassifier?) {
if (!done && collection.isNotEmpty()) {
collection.asSequence().mapNotNull(block).forEach { next ->
consume(next)
@@ -145,23 +145,23 @@
}
}
- private fun consume(exploredClassifier: ClassifierExplorationResult) {
+ private fun consume(exploredClassifier: ExploredClassifier) {
when (exploredClassifier) {
- is ClassifierExplorationResult.Unusable -> onPartiallyLinkedClassifier(exploredClassifier)
- is ClassifierExplorationResult.Usable -> onFullyLinkedClassifier(exploredClassifier.accessibleClassifier)
- is ClassifierExplorationResult.RecursionAvoidance -> return // Just skip it.
+ is ExploredClassifier.Unusable -> onPartiallyLinkedClassifier(exploredClassifier)
+ is ExploredClassifier.Usable -> onFullyLinkedClassifier(exploredClassifier.accessibleClassifier)
+ is ExploredClassifier.RecursionAvoidance -> return // Just skip it.
}
}
- private inline val ClassifierExplorationResult.Usable.accessibleClassifier: ClassifierExplorationResult.Usable.AccessibleClassifier
+ private inline val ExploredClassifier.Usable.accessibleClassifier: ExploredClassifier.Usable.AccessibleClassifier
get() = when (this) {
- is ClassifierExplorationResult.Usable.AccessibleClassifier -> this
- is ClassifierExplorationResult.Usable.LesserAccessibleClassifier -> dueTo
+ is ExploredClassifier.Usable.AccessibleClassifier -> this
+ is ExploredClassifier.Usable.LesserAccessibleClassifier -> dueTo
}
protected fun checkDependencyVisibility(
currentVisibility: ABIVisibility,
- nextClassifier: ClassifierExplorationResult.Usable.AccessibleClassifier,
+ nextClassifier: ExploredClassifier.Usable.AccessibleClassifier,
onConflictingVisibilities: (ABIVisibility.Limited) -> UR
) {
val nextVisibility = nextClassifier.visibility
@@ -173,19 +173,19 @@
}
}
- protected abstract fun onPartiallyLinkedClassifier(exploredClassifier: ClassifierExplorationResult.Unusable)
- protected abstract fun onFullyLinkedClassifier(exploredClassifier: ClassifierExplorationResult.Usable.AccessibleClassifier)
+ protected abstract fun onPartiallyLinkedClassifier(exploredClassifier: ExploredClassifier.Unusable)
+ protected abstract fun onFullyLinkedClassifier(exploredClassifier: ExploredClassifier.Usable.AccessibleClassifier)
protected abstract fun onVisibilityConflict(exploredType: TypeExplorationResult.UnusableType.DueToVisibilityConflict)
abstract fun build(): R
}
-private class TypeExplorationResultBuilder : ExplorationResultBuilder<TypeExplorationResult, TypeExplorationResult.UnusableType>() {
- override fun onPartiallyLinkedClassifier(exploredClassifier: ClassifierExplorationResult.Unusable) {
+private class ExploredTypeBuilder : ExplorationResultBuilder<TypeExplorationResult, TypeExplorationResult.UnusableType>() {
+ override fun onPartiallyLinkedClassifier(exploredClassifier: ExploredClassifier.Unusable) {
unusableResult = TypeExplorationResult.UnusableType.DueToClassifier(exploredClassifier)
}
- override fun onFullyLinkedClassifier(exploredClassifier: ClassifierExplorationResult.Usable.AccessibleClassifier) {
+ override fun onFullyLinkedClassifier(exploredClassifier: ExploredClassifier.Usable.AccessibleClassifier) {
when (val dependencyWithNarrowerVisibility = dependencyWithNarrowerVisibility) {
null -> {
// Memoize the dependency if it has non-default public visibility.
@@ -213,56 +213,56 @@
}
}
-private class ClassifierExplorationResultBuilder(
+private class ExploredClassifierBuilder(
private val symbol: IrClassifierSymbol
-) : (ExplorationResultBuilder<ClassifierExplorationResult, ClassifierExplorationResult>)() {
+) : (ExplorationResultBuilder<ExploredClassifier, ExploredClassifier>)() {
private val ownVisibility = ABIVisibility.determineVisibilityFor(symbol.owner as IrDeclaration)
- override fun onPartiallyLinkedClassifier(exploredClassifier: ClassifierExplorationResult.Unusable) {
+ override fun onPartiallyLinkedClassifier(exploredClassifier: ExploredClassifier.Unusable) {
unusableResult = when (exploredClassifier) {
- is ClassifierExplorationResult.Unusable.CanBeRootCause -> ClassifierExplorationResult.Unusable.DueToOtherClassifier(symbol, exploredClassifier)
- is ClassifierExplorationResult.Unusable.DueToOtherClassifier -> ClassifierExplorationResult.Unusable.DueToOtherClassifier(symbol, exploredClassifier.rootCause)
+ is ExploredClassifier.Unusable.CanBeRootCause -> ExploredClassifier.Unusable.DueToOtherClassifier(symbol, exploredClassifier)
+ is ExploredClassifier.Unusable.DueToOtherClassifier -> ExploredClassifier.Unusable.DueToOtherClassifier(symbol, exploredClassifier.rootCause)
}
}
- override fun onFullyLinkedClassifier(exploredClassifier: ClassifierExplorationResult.Usable.AccessibleClassifier) {
+ override fun onFullyLinkedClassifier(exploredClassifier: ExploredClassifier.Usable.AccessibleClassifier) {
when (val dependencyWithNarrowerVisibility = dependencyWithNarrowerVisibility) {
null -> {
// Compare own visibility of the classifier with the visibility of the `next` dependency.
checkDependencyVisibility(ownVisibility, exploredClassifier) { currentVisibility ->
- ClassifierExplorationResult.Unusable.InaccessibleClassifier(symbol, currentVisibility, exploredClassifier)
+ ExploredClassifier.Unusable.InaccessibleClassifier(symbol, currentVisibility, exploredClassifier)
}
}
else -> {
// Compare the visibility of the latest memoized dependency with the visibility of the `next` dependency.
checkDependencyVisibility(dependencyWithNarrowerVisibility.visibility, exploredClassifier) {
- ClassifierExplorationResult.Unusable.InaccessibleClassifierDueToOtherClassifiers(symbol, dependencyWithNarrowerVisibility, exploredClassifier)
+ ExploredClassifier.Unusable.InaccessibleClassifierDueToOtherClassifiers(symbol, dependencyWithNarrowerVisibility, exploredClassifier)
}
}
}
}
override fun onVisibilityConflict(exploredType: TypeExplorationResult.UnusableType.DueToVisibilityConflict) {
- unusableResult = ClassifierExplorationResult.Unusable.InaccessibleClassifierDueToOtherClassifiers(
+ unusableResult = ExploredClassifier.Unusable.InaccessibleClassifierDueToOtherClassifiers(
symbol,
exploredType.classifierWithConflictingVisibility1,
exploredType.classifierWithConflictingVisibility2
)
}
- override fun build(): ClassifierExplorationResult {
+ override fun build(): ExploredClassifier {
return unusableResult
- ?: dependencyWithNarrowerVisibility?.let { ClassifierExplorationResult.Usable.LesserAccessibleClassifier(symbol, it) }
- ?: ClassifierExplorationResult.Usable.AccessibleClassifier(symbol, ownVisibility)
+ ?: dependencyWithNarrowerVisibility?.let { ExploredClassifier.Usable.LesserAccessibleClassifier(symbol, it) }
+ ?: ExploredClassifier.Usable.AccessibleClassifier(symbol, ownVisibility)
}
}
-private inline fun typeExploration(init: TypeExplorationResultBuilder.() -> Unit): TypeExplorationResult =
- TypeExplorationResultBuilder().apply(init).build()
+private inline fun typeExploration(init: ExploredTypeBuilder.() -> Unit): TypeExplorationResult =
+ ExploredTypeBuilder().apply(init).build()
-private inline fun IrClassifierSymbol.classifierExploration(init: ClassifierExplorationResultBuilder.() -> Unit): ClassifierExplorationResult =
- ClassifierExplorationResultBuilder(this).apply(init).build()
+private inline fun IrClassifierSymbol.classifierExploration(init: ExploredClassifierBuilder.() -> Unit): ExploredClassifier =
+ ExploredClassifierBuilder(this).apply(init).build()
private class IrElementExplorer(private val visitType: (IrType) -> Unit) : IrElementVisitorVoid {
override fun visitElement(element: IrElement) {
diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/PartialLinkageCase.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/PartialLinkageCase.kt
index 7142a61..327926d 100644
--- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/PartialLinkageCase.kt
+++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/PartialLinkageCase.kt
@@ -43,7 +43,7 @@
*/
class DeclarationUsesPartiallyLinkedClassifier(
val declarationSymbol: IrSymbol,
- val cause: ClassifierExplorationResult.Unusable
+ val cause: ExploredClassifier.Unusable
) : PartialLinkageCase
/**
@@ -72,7 +72,7 @@
*/
class ExpressionUsesPartiallyLinkedClassifier(
val expression: IrExpression,
- val cause: ClassifierExplorationResult.Unusable
+ val cause: ExploredClassifier.Unusable
) : PartialLinkageCase
/**
@@ -83,7 +83,7 @@
class ExpressionUsesDeclarationThatUsesPartiallyLinkedClassifier(
val expression: IrExpression,
val referencedDeclarationSymbol: IrSymbol,
- val cause: ClassifierExplorationResult.Unusable
+ val cause: ExploredClassifier.Unusable
) : PartialLinkageCase
/**
diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/PartialLinkageErrorMessages.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/PartialLinkageErrorMessages.kt
index 8151d5f..c9bb73b 100644
--- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/PartialLinkageErrorMessages.kt
+++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/PartialLinkageErrorMessages.kt
@@ -194,14 +194,14 @@
return append(": ")
}
-private fun Appendable.cause(cause: ClassifierExplorationResult.Unusable): Appendable =
+private fun Appendable.cause(cause: ExploredClassifier.Unusable): Appendable =
when (cause) {
- is ClassifierExplorationResult.Unusable.MissingClassifier -> unlinkedSymbol(cause)
- is ClassifierExplorationResult.Unusable.MissingEnclosingClass -> noEnclosingClass(cause)
- is ClassifierExplorationResult.Unusable.DueToOtherClassifier -> {
+ is ExploredClassifier.Unusable.MissingClassifier -> unlinkedSymbol(cause)
+ is ExploredClassifier.Unusable.MissingEnclosingClass -> noEnclosingClass(cause)
+ is ExploredClassifier.Unusable.DueToOtherClassifier -> {
when (val rootCause = cause.rootCause) {
- is ClassifierExplorationResult.Unusable.MissingClassifier -> unlinkedSymbol(rootCause, cause)
- is ClassifierExplorationResult.Unusable.MissingEnclosingClass -> noEnclosingClass(rootCause, cause)
+ is ExploredClassifier.Unusable.MissingClassifier -> unlinkedSymbol(rootCause, cause)
+ is ExploredClassifier.Unusable.MissingEnclosingClass -> noEnclosingClass(rootCause, cause)
}
}
}
@@ -213,8 +213,8 @@
declarationKindName(symbol, capitalized = true).append(" lacks enclosing class")
private fun Appendable.unlinkedSymbol(
- rootCause: ClassifierExplorationResult.Unusable.MissingClassifier,
- cause: ClassifierExplorationResult.Unusable.DueToOtherClassifier? = null
+ rootCause: ExploredClassifier.Unusable.MissingClassifier,
+ cause: ExploredClassifier.Unusable.DueToOtherClassifier? = null
): Appendable {
append("unlinked ").append(rootCause.symbol.declarationKind.displayName).append(" symbol ").signature(rootCause.symbol)
if (cause != null) through(cause)
@@ -222,15 +222,15 @@
}
private fun Appendable.noEnclosingClass(
- rootCause: ClassifierExplorationResult.Unusable.MissingEnclosingClass,
- cause: ClassifierExplorationResult.Unusable.DueToOtherClassifier? = null
+ rootCause: ExploredClassifier.Unusable.MissingEnclosingClass,
+ cause: ExploredClassifier.Unusable.DueToOtherClassifier? = null
): Appendable {
declarationKindName(rootCause.symbol, capitalized = false)
if (cause != null) through(cause)
return append(". ").noEnclosingClass(rootCause.symbol)
}
-private fun Appendable.through(cause: ClassifierExplorationResult.Unusable.DueToOtherClassifier): Appendable =
+private fun Appendable.through(cause: ExploredClassifier.Unusable.DueToOtherClassifier): Appendable =
append(" (through ").declarationKindName(cause.symbol, capitalized = false).append(")")
private fun Appendable.unimplementedAbstractCallable(callable: IrOverridableDeclaration<*>): Appendable =
diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/PartialLinkageSupportImpl.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/PartialLinkageSupportImpl.kt
index 6c88d12..44c6a2a 100644
--- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/PartialLinkageSupportImpl.kt
+++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/PartialLinkageSupportImpl.kt
@@ -27,7 +27,7 @@
val toExclude = buildSet {
for (clazz in entries.keys) {
- if (classifierExplorer.exploreSymbol(clazz.symbol) is ClassifierExplorationResult.Unusable) {
+ if (classifierExplorer.exploreSymbol(clazz.symbol) is ExploredClassifier.Unusable) {
this += clazz
}
}
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 e75e304..f4cf905 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
@@ -131,9 +131,9 @@
if (partialLinkageReason != null) {
// Transform the reason into the most appropriate linkage case.
val partialLinkageCase = when (partialLinkageReason) {
- is ClassifierExplorationResult.Unusable.MissingClassifier -> MissingDeclaration(declaration.symbol)
- is ClassifierExplorationResult.Unusable.MissingEnclosingClass -> MissingEnclosingClass(declaration.symbol)
- is ClassifierExplorationResult.Unusable.DueToOtherClassifier -> DeclarationUsesPartiallyLinkedClassifier(
+ is ExploredClassifier.Unusable.MissingClassifier -> MissingDeclaration(declaration.symbol)
+ is ExploredClassifier.Unusable.MissingEnclosingClass -> MissingEnclosingClass(declaration.symbol)
+ is ExploredClassifier.Unusable.DueToOtherClassifier -> DeclarationUsesPartiallyLinkedClassifier(
declaration.symbol,
partialLinkageReason.rootCause
)
@@ -233,11 +233,11 @@
}
/**
- * Returns the first encountered [ClassifierExplorationResult.Unusable].
+ * Returns the first encountered [ExploredClassifier.Unusable].
*/
- private fun IrFunction.rewriteTypesInFunction(): ClassifierExplorationResult.Unusable? {
+ private fun IrFunction.rewriteTypesInFunction(): ExploredClassifier.Unusable? {
// Remember the first assignment. Ignore all subsequent.
- var result: ClassifierExplorationResult.Unusable? by Delegates.vetoable(null) { _, oldValue, _ -> oldValue == null }
+ var result: ExploredClassifier.Unusable? by Delegates.vetoable(null) { _, oldValue, _ -> oldValue == null }
fun IrValueParameter.fixType() {
val newType = type.toPartiallyLinkedMarkerTypeOrNull() ?: return
@@ -509,10 +509,10 @@
else null
}
- private fun IrType.precalculatedPartialLinkageReason(): ClassifierExplorationResult.Unusable? =
+ private fun IrType.precalculatedPartialLinkageReason(): ExploredClassifier.Unusable? =
(this as? PartiallyLinkedMarkerType)?.partialLinkageReason ?: partialLinkageReason()
- private fun List<IrType>.precalculatedPartialLinkageReason(): ClassifierExplorationResult.Unusable? =
+ private fun List<IrType>.precalculatedPartialLinkageReason(): ExploredClassifier.Unusable? =
firstNotNullOfOrNull { it.precalculatedPartialLinkageReason() }
/**
@@ -529,8 +529,8 @@
}
}
- private fun IrClassifierSymbol.partialLinkageReason(): ClassifierExplorationResult.Unusable? =
- classifierExplorer.exploreSymbol(this) as? ClassifierExplorationResult.Unusable
+ private fun IrClassifierSymbol.partialLinkageReason(): ExploredClassifier.Unusable? =
+ classifierExplorer.exploreSymbol(this) as? ExploredClassifier.Unusable
private fun IrType.partialLinkageReason(): TypeExplorationResult.UnusableType? =
classifierExplorer.exploreType(this) as? TypeExplorationResult.UnusableType
diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/PartiallyLinkedMarkerType.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/PartiallyLinkedMarkerType.kt
index 84f3d71..a70ccd0 100644
--- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/PartiallyLinkedMarkerType.kt
+++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/PartiallyLinkedMarkerType.kt
@@ -12,11 +12,11 @@
/**
* Replacement for IR types that use partially linked classifier symbols.
- * Behaves like [kotlin.Any]?. Preserves [ClassifierExplorationResult.Unusable].
+ * Behaves like [kotlin.Any]?. Preserves [ExploredClassifier.Unusable].
*/
internal class PartiallyLinkedMarkerType(
builtIns: IrBuiltIns,
- val partialLinkageReason: ClassifierExplorationResult.Unusable
+ val partialLinkageReason: ExploredClassifier.Unusable
) : IrSimpleType(null) {
override val annotations get() = emptyList<IrConstructorCall>()
override val classifier = builtIns.anyClass
diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/TypeExplorationResult.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/TypeExplorationResult.kt
index 653b0b9..d9a9792 100644
--- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/TypeExplorationResult.kt
+++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/unlinked/TypeExplorationResult.kt
@@ -12,16 +12,16 @@
internal sealed interface TypeExplorationResult {
/** Indicates unusable type. */
sealed interface UnusableType : TypeExplorationResult {
- class DueToClassifier(val classifier: ClassifierExplorationResult.Unusable) : UnusableType
+ class DueToClassifier(val classifier: ExploredClassifier.Unusable) : UnusableType
class DueToVisibilityConflict(
- val classifierWithConflictingVisibility1: ClassifierExplorationResult.Usable.AccessibleClassifier,
- val classifierWithConflictingVisibility2: ClassifierExplorationResult.Usable.AccessibleClassifier
+ val classifierWithConflictingVisibility1: ExploredClassifier.Usable.AccessibleClassifier,
+ val classifierWithConflictingVisibility2: ExploredClassifier.Usable.AccessibleClassifier
) : UnusableType
}
/** Indicates usable type that does not reference any partially linked classifiers and does not have visibility conflicts. */
- class UsableType(val classifierWithNarrowestVisibility: ClassifierExplorationResult.Usable?) : TypeExplorationResult {
+ class UsableType(val classifierWithNarrowestVisibility: ExploredClassifier.Usable?) : TypeExplorationResult {
companion object {
val DEFAULT_PUBLIC = UsableType(null)
}
