From b3aa2dd60fcb98faa137c2fb52b180475e50d956 Mon Sep 17 00:00:00 2001
From: Dmitrii Gridin <dmitry.gridin@jetbrains.com>
Date: Tue, 9 May 2023 16:23:49 +0200
Subject: [PATCH] [LL FIR] calculate designation path by FirFile where it is
 possible

This will fix problems with declaration clash.
Otherwise, a designation path to the constructor of the second class
from the snippet
```
class A
class A
```
Will contain the first class instead of the second

Also, this is more performed than trying to find a segment of
a path by providers

^KT-58546 Fixed
---
 .../low/level/api/fir/api/FirDesignation.kt   |   19 +
 .../LLFirSupertypeLazyResolver.kt             |   43 +-
 .../fir/transformers/LLFirTypeLazyResolver.kt |    4 +-
 .../util/FirNonLocalDeclarationSearcher.kt    |   62 +-
 .../lazyResolve/complexRedeclaration.kt       |   41 +
 .../lazyResolve/complexRedeclaration.txt      | 1328 +++++++++++++++++
 .../testdata/lazyResolve/redeclaration.txt    |   32 +-
 ...otLazyDeclarationResolveTestGenerated.java |    6 +
 ...ceLazyDeclarationResolveTestGenerated.java |    6 +
 9 files changed, 1499 insertions(+), 42 deletions(-)
 create mode 100644 analysis/low-level-api-fir/testdata/lazyResolve/complexRedeclaration.kt
 create mode 100644 analysis/low-level-api-fir/testdata/lazyResolve/complexRedeclaration.txt

diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/FirDesignation.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/FirDesignation.kt
index a8a54df10ee..d6ea8ef5b2a 100644
--- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/FirDesignation.kt
+++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/FirDesignation.kt
@@ -116,11 +116,30 @@ private fun collectDesignationPath(target: FirElementWithResolveState): List<Fir
     }
 }
 
+private fun collectDesignationPathWithContainingClassByFirFile(
+    firFile: FirFile,
+    containingClassId: ClassId,
+    target: FirDeclaration,
+): List<FirRegularClass>? = FirElementFinder.findClassPathToDeclaration(
+    firFile = firFile,
+    declarationContainerClassId = containingClassId,
+    targetMemberDeclaration = target,
+)
+
 private fun collectDesignationPathWithContainingClass(target: FirDeclaration, containingClassId: ClassId): List<FirRegularClass>? {
     if (containingClassId.isLocal) {
         return null
     }
 
+    val firFile = target.getContainingFile()
+    if (firFile != null && firFile.packageFqName == containingClassId.packageFqName) {
+        // We should do fallback to the heavy implementation if something goes wrong.
+        // For example, we can't be able to find an on-air declaration by this way
+        collectDesignationPathWithContainingClassByFirFile(firFile, containingClassId, target)?.let {
+            return it
+        }
+    }
+
     val useSiteSession = getTargetSession(target)
 
     fun resolveChunk(classId: ClassId): FirRegularClass {
diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirSupertypeLazyResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirSupertypeLazyResolver.kt
index f1d1bcd8c9c..c02b50b3a0b 100644
--- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirSupertypeLazyResolver.kt
+++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirSupertypeLazyResolver.kt
@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers
 
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.LLFirResolveTarget
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.LLFirSingleResolveTarget
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.asResolveTarget
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.tryCollectDesignationWithFile
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockProvider
@@ -26,7 +27,6 @@ import org.jetbrains.kotlin.fir.resolve.transformers.SupertypeComputationSession
 import org.jetbrains.kotlin.fir.resolve.transformers.SupertypeComputationStatus
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirTowerDataContextCollector
 import org.jetbrains.kotlin.fir.resolve.transformers.platformSupertypeUpdater
-import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.name.ClassId
@@ -86,6 +86,12 @@ private class LLFirSuperTypeTargetResolver(
             // We can get into this function during a loop calculation, so it is possible that the result for [outerClass]
             // is not yet published, so we expect that this class was already visited or resolved
             if (outerClass !in visitedElements) {
+                outerClass.asResolveTarget()?.let { resolveTarget ->
+                    // It is possible in case of declaration collision,
+                    // so we need this logic only to be sure that [outerClass] is resolved
+                    resolveToSupertypePhase(resolveTarget)
+                }
+
                 LLFirSupertypeLazyResolver.checkIsResolved(outerClass)
             }
         }
@@ -181,6 +187,25 @@ private class LLFirSuperTypeTargetResolver(
         }
     }
 
+    private fun FirClassLikeDeclaration.asResolveTarget(): LLFirSingleResolveTarget? {
+        return takeIf { it.canHaveLoopInSupertypesHierarchy(session, forceSkipResolvedClasses = true) }
+            ?.tryCollectDesignationWithFile()
+            ?.asResolveTarget()
+    }
+
+    private fun resolveToSupertypePhase(target: LLFirSingleResolveTarget) {
+        LLFirSuperTypeTargetResolver(
+            target = target,
+            lockProvider = lockProvider,
+            session = session,
+            scopeSession = scopeSession,
+            supertypeComputationSession = supertypeComputationSession,
+            visitedElements = visitedElements,
+        ).resolveDesignation()
+
+        LLFirLazyPhaseResolverByPhase.getByPhase(resolverPhase).checkIsResolved(target)
+    }
+
     /**
      * We want to apply resolved supertypes to as many designations as possible.
      * So we crawl the resolved supertypes of visited designations to find more designations to collect.
@@ -205,21 +230,9 @@ private class LLFirSuperTypeTargetResolver(
             return
         }
 
-        val resolveTarget = classLikeDeclaration.takeIf { it.canHaveLoopInSupertypesHierarchy(session, forceSkipResolvedClasses = true) }
-            ?.tryCollectDesignationWithFile()
-            ?.asResolveTarget()
-
+        val resolveTarget = classLikeDeclaration.asResolveTarget()
         if (resolveTarget != null) {
-            LLFirSuperTypeTargetResolver(
-                target = resolveTarget,
-                lockProvider = lockProvider,
-                session = session,
-                scopeSession = scopeSession,
-                supertypeComputationSession = supertypeComputationSession,
-                visitedElements = visitedElements,
-            ).resolveDesignation()
-
-            LLFirLazyPhaseResolverByPhase.getByPhase(resolverPhase).checkIsResolved(resolveTarget)
+            resolveToSupertypePhase(resolveTarget)
         } else if (type is ConeClassLikeType) {
             // The `classLikeDeclaration` is not associated with a file, and thus there is no need to resolve it, but it may still point
             // to declarations via its type arguments which need to be collected and have a containing file.
diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirTypeLazyResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirTypeLazyResolver.kt
index 80db97989d3..df5f8659534 100644
--- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirTypeLazyResolver.kt
+++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirTypeLazyResolver.kt
@@ -126,13 +126,11 @@ private class LLFirTypeTargetResolver(
     override fun doLazyResolveUnderLock(target: FirElementWithResolveState) {
         when (target) {
             is FirConstructor -> {
-                // TODO: should be uncommented after KT-58546
-//                error("Shoul be resolved during ${::resolveConstructors.name}")
+                error("Should be resolved during ${::resolveConstructors.name}")
             }
             is FirDanglingModifierList, is FirFileAnnotationsContainer, is FirCallableDeclaration, is FirTypeAlias, is FirScript -> {
                 target.accept(transformer, null)
             }
-
             is FirRegularClass -> {
                 resolveClassTypes(target)
             }
diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/util/FirNonLocalDeclarationSearcher.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/util/FirNonLocalDeclarationSearcher.kt
index 71fdc384cf2..d640d31c0f8 100644
--- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/util/FirNonLocalDeclarationSearcher.kt
+++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/util/FirNonLocalDeclarationSearcher.kt
@@ -15,7 +15,30 @@ import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid
 import org.jetbrains.kotlin.name.ClassId
 
 object FirElementFinder {
-    fun findClassifierWithClassId(firFile: FirFile, classId: ClassId): FirClassLikeDeclaration? {
+    fun findClassifierWithClassId(
+        firFile: FirFile,
+        classId: ClassId,
+    ): FirClassLikeDeclaration? = findPathToClassifierWithClassId(
+        firFile = firFile,
+        classId = classId,
+        expectedMemberDeclaration = null
+    )?.second
+
+    fun findClassPathToDeclaration(
+        firFile: FirFile,
+        declarationContainerClassId: ClassId,
+        targetMemberDeclaration: FirDeclaration,
+    ): List<FirRegularClass>? = findPathToClassifierWithClassId(
+        firFile = firFile,
+        classId = declarationContainerClassId,
+        expectedMemberDeclaration = targetMemberDeclaration
+    )?.first
+
+    private fun findPathToClassifierWithClassId(
+        firFile: FirFile,
+        classId: ClassId,
+        expectedMemberDeclaration: FirDeclaration?,
+    ): Pair<List<FirRegularClass>, FirClassLikeDeclaration>? {
         requireWithAttachmentBuilder(!classId.isLocal, { "ClassId should not be local" }) {
             withEntry("classId", classId) { it.asString() }
         }
@@ -28,33 +51,56 @@ object FirElementFinder {
         }
 
         val classIdPathSegment = classId.relativeClassName.pathSegments()
+        val path = ArrayList<FirRegularClass>(classIdPathSegment.size)
         var result: FirClassLikeDeclaration? = null
 
-        fun find(declarations: Iterable<FirDeclaration>, classIdPathIndex: Int) {
-            if (result != null) return
+        fun find(declarations: Iterable<FirDeclaration>, classIdPathIndex: Int): Boolean {
             val currentClassSegment = classIdPathSegment[classIdPathIndex]
 
             for (subDeclaration in declarations) {
                 if (subDeclaration is FirScript) {
                     val scriptDeclarations = subDeclaration.statements.asSequence().filterIsInstance<FirDeclaration>()
-                    find(scriptDeclarations.asIterable(), classIdPathIndex)
+                    if (find(scriptDeclarations.asIterable(), classIdPathIndex)) {
+                        return true
+                    }
+
                     continue
                 }
 
                 if (subDeclaration is FirClassLikeDeclaration && currentClassSegment == subDeclaration.symbol.name) {
                     if (classIdPathIndex == classIdPathSegment.lastIndex) {
-                        result = subDeclaration
-                        return
+                        if (expectedMemberDeclaration == null ||
+                            subDeclaration is FirRegularClass && expectedMemberDeclaration in subDeclaration.declarations
+                        ) {
+                            if (subDeclaration is FirRegularClass) {
+                                path += subDeclaration
+                            }
+
+                            result = subDeclaration
+                            return true
+                        }
+
+                        continue
                     }
+
                     if (subDeclaration is FirRegularClass) {
-                        find(subDeclaration.declarations, classIdPathIndex + 1)
+                        path += subDeclaration
+                        if (find(subDeclaration.declarations, classIdPathIndex + 1)) {
+                            return true
+                        }
+
+                        path.removeLast()
                     }
                 }
             }
+
+            return false
         }
 
         find(firFile.declarations, classIdPathIndex = 0)
-        return result
+        return result?.let {
+            (path as List<FirRegularClass>) to it
+        }
     }
 
     inline fun <reified E : FirElement> findElementIn(
diff --git a/analysis/low-level-api-fir/testdata/lazyResolve/complexRedeclaration.kt b/analysis/low-level-api-fir/testdata/lazyResolve/complexRedeclaration.kt
new file mode 100644
index 00000000000..0baf6231fcc
--- /dev/null
+++ b/analysis/low-level-api-fir/testdata/lazyResolve/complexRedeclaration.kt
@@ -0,0 +1,41 @@
+// MEMBER_CLASS_FILTER: org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol
+sealed class A
+
+class B : A()
+
+interface C : A
+
+interface D : C, A
+
+class E : B, A()
+
+sealed class P {
+    object H: P()
+    class J : P()
+
+    object T {
+        object V : P()
+        class M : P()
+    }
+
+    val p: P = object : P() {
+
+    }
+
+    val r = object : P() {
+
+    }
+}
+
+class K : P()
+
+object B {
+    class <caret>I : P()
+}
+
+fun test() {
+    class L : P()
+    val a = object : P() {
+
+    }
+}
diff --git a/analysis/low-level-api-fir/testdata/lazyResolve/complexRedeclaration.txt b/analysis/low-level-api-fir/testdata/lazyResolve/complexRedeclaration.txt
new file mode 100644
index 00000000000..a35b3227266
--- /dev/null
+++ b/analysis/low-level-api-fir/testdata/lazyResolve/complexRedeclaration.txt
@@ -0,0 +1,1328 @@
+RAW_FIR:
+FILE: [ResolvedTo(RAW_FIR)] complexRedeclaration.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? sealed [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        protected [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] class B : A {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
+            LAZY_super<A>
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface C : A {
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface D : C, A {
+    }
+    public? final? [ResolvedTo(RAW_FIR)] class E : B, A {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=E] constructor(): R|E| {
+            LAZY_super<A>
+        }
+
+    }
+    public? sealed [ResolvedTo(RAW_FIR)] class P : R|kotlin/Any| {
+        protected [ResolvedTo(RAW_FIR)] [ContainingClassKey=P] constructor(): R|P| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] object H : P {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=H] constructor(): R|P.H| {
+                LAZY_super<P>
+            }
+
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class J : P {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=J] constructor(): R|P.J| {
+                LAZY_super<P>
+            }
+
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] object T : R|kotlin/Any| {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=T] constructor(): R|P.T| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] object V : P {
+                private [ResolvedTo(RAW_FIR)] [ContainingClassKey=V] constructor(): R|P.T.V| {
+                    LAZY_super<P>
+                }
+
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] class M : P {
+                public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=M] constructor(): R|P.T.M| {
+                    LAZY_super<P>
+                }
+
+            }
+
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] val p: P = LAZY_EXPRESSION
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=P] get(): P
+
+        public? final? [ResolvedTo(RAW_FIR)] val r: <implicit> = LAZY_EXPRESSION
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=P] get(): <implicit>
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] class K : P {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=K] constructor(): R|K| {
+            LAZY_super<P>
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] object B : R|kotlin/Any| {
+        private [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class I : P {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=I] constructor(): R|B.I| {
+                LAZY_super<P>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] fun test(): R|kotlin/Unit| { LAZY_BLOCK }
+
+IMPORTS:
+FILE: [ResolvedTo(IMPORTS)] complexRedeclaration.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? sealed [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        protected [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] class B : A {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
+            LAZY_super<A>
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface C : A {
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface D : C, A {
+    }
+    public? final? [ResolvedTo(RAW_FIR)] class E : B, A {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=E] constructor(): R|E| {
+            LAZY_super<A>
+        }
+
+    }
+    public? sealed [ResolvedTo(RAW_FIR)] class P : R|kotlin/Any| {
+        protected [ResolvedTo(RAW_FIR)] [ContainingClassKey=P] constructor(): R|P| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] object H : P {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=H] constructor(): R|P.H| {
+                LAZY_super<P>
+            }
+
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class J : P {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=J] constructor(): R|P.J| {
+                LAZY_super<P>
+            }
+
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] object T : R|kotlin/Any| {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=T] constructor(): R|P.T| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] object V : P {
+                private [ResolvedTo(RAW_FIR)] [ContainingClassKey=V] constructor(): R|P.T.V| {
+                    LAZY_super<P>
+                }
+
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] class M : P {
+                public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=M] constructor(): R|P.T.M| {
+                    LAZY_super<P>
+                }
+
+            }
+
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] val p: P = LAZY_EXPRESSION
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=P] get(): P
+
+        public? final? [ResolvedTo(RAW_FIR)] val r: <implicit> = LAZY_EXPRESSION
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=P] get(): <implicit>
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] class K : P {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=K] constructor(): R|K| {
+            LAZY_super<P>
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] object B : R|kotlin/Any| {
+        private [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class I : P {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=I] constructor(): R|B.I| {
+                LAZY_super<P>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] fun test(): R|kotlin/Unit| { LAZY_BLOCK }
+
+COMPILER_REQUIRED_ANNOTATIONS:
+FILE: [ResolvedTo(IMPORTS)] complexRedeclaration.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? sealed [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        protected [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] class B : A {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
+            LAZY_super<A>
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface C : A {
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface D : C, A {
+    }
+    public? final? [ResolvedTo(RAW_FIR)] class E : B, A {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=E] constructor(): R|E| {
+            LAZY_super<A>
+        }
+
+    }
+    public? sealed [ResolvedTo(RAW_FIR)] class P : R|kotlin/Any| {
+        protected [ResolvedTo(RAW_FIR)] [ContainingClassKey=P] constructor(): R|P| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] object H : P {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=H] constructor(): R|P.H| {
+                LAZY_super<P>
+            }
+
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class J : P {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=J] constructor(): R|P.J| {
+                LAZY_super<P>
+            }
+
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] object T : R|kotlin/Any| {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=T] constructor(): R|P.T| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] object V : P {
+                private [ResolvedTo(RAW_FIR)] [ContainingClassKey=V] constructor(): R|P.T.V| {
+                    LAZY_super<P>
+                }
+
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] class M : P {
+                public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=M] constructor(): R|P.T.M| {
+                    LAZY_super<P>
+                }
+
+            }
+
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] val p: P = LAZY_EXPRESSION
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=P] get(): P
+
+        public? final? [ResolvedTo(RAW_FIR)] val r: <implicit> = LAZY_EXPRESSION
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=P] get(): <implicit>
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] class K : P {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=K] constructor(): R|K| {
+            LAZY_super<P>
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] object B : R|kotlin/Any| {
+        private [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class I : P {
+            public? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] [ContainingClassKey=I] constructor(): R|B.I| {
+                LAZY_super<P>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] fun test(): R|kotlin/Unit| { LAZY_BLOCK }
+
+COMPANION_GENERATION:
+FILE: [ResolvedTo(IMPORTS)] complexRedeclaration.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? sealed [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        protected [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] class B : A {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
+            LAZY_super<A>
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface C : A {
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface D : C, A {
+    }
+    public? final? [ResolvedTo(RAW_FIR)] class E : B, A {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=E] constructor(): R|E| {
+            LAZY_super<A>
+        }
+
+    }
+    public? sealed [ResolvedTo(RAW_FIR)] class P : R|kotlin/Any| {
+        protected [ResolvedTo(RAW_FIR)] [ContainingClassKey=P] constructor(): R|P| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] object H : P {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=H] constructor(): R|P.H| {
+                LAZY_super<P>
+            }
+
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class J : P {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=J] constructor(): R|P.J| {
+                LAZY_super<P>
+            }
+
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] object T : R|kotlin/Any| {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=T] constructor(): R|P.T| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] object V : P {
+                private [ResolvedTo(RAW_FIR)] [ContainingClassKey=V] constructor(): R|P.T.V| {
+                    LAZY_super<P>
+                }
+
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] class M : P {
+                public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=M] constructor(): R|P.T.M| {
+                    LAZY_super<P>
+                }
+
+            }
+
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] val p: P = LAZY_EXPRESSION
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=P] get(): P
+
+        public? final? [ResolvedTo(RAW_FIR)] val r: <implicit> = LAZY_EXPRESSION
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=P] get(): <implicit>
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] class K : P {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=K] constructor(): R|K| {
+            LAZY_super<P>
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] object B : R|kotlin/Any| {
+        private [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class I : P {
+            public? [ResolvedTo(COMPANION_GENERATION)] [ContainingClassKey=I] constructor(): R|B.I| {
+                LAZY_super<P>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] fun test(): R|kotlin/Unit| { LAZY_BLOCK }
+
+SUPER_TYPES:
+FILE: [ResolvedTo(IMPORTS)] complexRedeclaration.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? sealed [ResolvedTo(SUPER_TYPES)] class A : R|kotlin/Any| {
+        protected [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] class B : R|A| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
+            LAZY_super<A>
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface C : A {
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface D : C, A {
+    }
+    public? final? [ResolvedTo(RAW_FIR)] class E : B, A {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=E] constructor(): R|E| {
+            LAZY_super<A>
+        }
+
+    }
+    public? sealed [ResolvedTo(SUPER_TYPES)] class P : R|kotlin/Any| {
+        protected [ResolvedTo(RAW_FIR)] [ContainingClassKey=P] constructor(): R|P| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] object H : P {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=H] constructor(): R|P.H| {
+                LAZY_super<P>
+            }
+
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class J : P {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=J] constructor(): R|P.J| {
+                LAZY_super<P>
+            }
+
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] object T : R|kotlin/Any| {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=T] constructor(): R|P.T| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] object V : P {
+                private [ResolvedTo(RAW_FIR)] [ContainingClassKey=V] constructor(): R|P.T.V| {
+                    LAZY_super<P>
+                }
+
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] class M : P {
+                public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=M] constructor(): R|P.T.M| {
+                    LAZY_super<P>
+                }
+
+            }
+
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] val p: P = LAZY_EXPRESSION
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=P] get(): P
+
+        public? final? [ResolvedTo(RAW_FIR)] val r: <implicit> = LAZY_EXPRESSION
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=P] get(): <implicit>
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] class K : P {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=K] constructor(): R|K| {
+            LAZY_super<P>
+        }
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] object B : R|kotlin/Any| {
+        private [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(SUPER_TYPES)] class I : R|P| {
+            public? [ResolvedTo(SUPER_TYPES)] [ContainingClassKey=I] constructor(): R|B.I| {
+                LAZY_super<P>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] fun test(): R|kotlin/Unit| { LAZY_BLOCK }
+
+TYPES:
+FILE: [ResolvedTo(IMPORTS)] complexRedeclaration.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? sealed [ResolvedTo(SUPER_TYPES)] class A : R|kotlin/Any| {
+        protected [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] class B : R|A| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
+            LAZY_super<A>
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface C : A {
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface D : C, A {
+    }
+    public? final? [ResolvedTo(RAW_FIR)] class E : B, A {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=E] constructor(): R|E| {
+            LAZY_super<A>
+        }
+
+    }
+    public? sealed [ResolvedTo(SUPER_TYPES)] class P : R|kotlin/Any| {
+        protected [ResolvedTo(RAW_FIR)] [ContainingClassKey=P] constructor(): R|P| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] object H : P {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=H] constructor(): R|P.H| {
+                LAZY_super<P>
+            }
+
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class J : P {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=J] constructor(): R|P.J| {
+                LAZY_super<P>
+            }
+
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] object T : R|kotlin/Any| {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=T] constructor(): R|P.T| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] object V : P {
+                private [ResolvedTo(RAW_FIR)] [ContainingClassKey=V] constructor(): R|P.T.V| {
+                    LAZY_super<P>
+                }
+
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] class M : P {
+                public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=M] constructor(): R|P.T.M| {
+                    LAZY_super<P>
+                }
+
+            }
+
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] val p: P = LAZY_EXPRESSION
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=P] get(): P
+
+        public? final? [ResolvedTo(RAW_FIR)] val r: <implicit> = LAZY_EXPRESSION
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=P] get(): <implicit>
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] class K : P {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=K] constructor(): R|K| {
+            LAZY_super<P>
+        }
+
+    }
+    public? final? [ResolvedTo(TYPES)] object B : R|kotlin/Any| {
+        private [ResolvedTo(TYPES)] [ContainingClassKey=B] constructor(): R|B| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(TYPES)] class I : R|P| {
+            public? [ResolvedTo(TYPES)] [ContainingClassKey=I] constructor(): R|B.I| {
+                LAZY_super<R|P|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] fun test(): R|kotlin/Unit| { LAZY_BLOCK }
+
+STATUS:
+FILE: [ResolvedTo(IMPORTS)] complexRedeclaration.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? sealed [ResolvedTo(SUPER_TYPES)] class A : R|kotlin/Any| {
+        protected [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] class B : R|A| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
+            LAZY_super<A>
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface C : A {
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface D : C, A {
+    }
+    public? final? [ResolvedTo(RAW_FIR)] class E : B, A {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=E] constructor(): R|E| {
+            LAZY_super<A>
+        }
+
+    }
+    public sealed [ResolvedTo(STATUS)] class P : R|kotlin/Any| {
+        protected [ResolvedTo(STATUS)] [ContainingClassKey=P] constructor(): R|P| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] object H : P {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=H] constructor(): R|P.H| {
+                LAZY_super<P>
+            }
+
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class J : P {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=J] constructor(): R|P.J| {
+                LAZY_super<P>
+            }
+
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] object T : R|kotlin/Any| {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=T] constructor(): R|P.T| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] object V : P {
+                private [ResolvedTo(RAW_FIR)] [ContainingClassKey=V] constructor(): R|P.T.V| {
+                    LAZY_super<P>
+                }
+
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] class M : P {
+                public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=M] constructor(): R|P.T.M| {
+                    LAZY_super<P>
+                }
+
+            }
+
+        }
+
+        public final [ResolvedTo(STATUS)] val p: R|P| = LAZY_EXPRESSION
+            public [ResolvedTo(STATUS)] [ContainingClassKey=P] get(): R|P|
+
+        public final [ResolvedTo(STATUS)] val r: <implicit> = LAZY_EXPRESSION
+            public [ResolvedTo(STATUS)] [ContainingClassKey=P] get(): <implicit>
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] class K : P {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=K] constructor(): R|K| {
+            LAZY_super<P>
+        }
+
+    }
+    public final [ResolvedTo(STATUS)] object B : R|kotlin/Any| {
+        private [ResolvedTo(STATUS)] [ContainingClassKey=B] constructor(): R|B| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public final [ResolvedTo(STATUS)] class I : R|P| {
+            public [ResolvedTo(STATUS)] [ContainingClassKey=I] constructor(): R|B.I| {
+                LAZY_super<R|P|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] fun test(): R|kotlin/Unit| { LAZY_BLOCK }
+
+EXPECT_ACTUAL_MATCHING:
+FILE: [ResolvedTo(IMPORTS)] complexRedeclaration.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? sealed [ResolvedTo(SUPER_TYPES)] class A : R|kotlin/Any| {
+        protected [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] class B : R|A| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
+            LAZY_super<A>
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface C : A {
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface D : C, A {
+    }
+    public? final? [ResolvedTo(RAW_FIR)] class E : B, A {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=E] constructor(): R|E| {
+            LAZY_super<A>
+        }
+
+    }
+    public sealed [ResolvedTo(STATUS)] class P : R|kotlin/Any| {
+        protected [ResolvedTo(STATUS)] [ContainingClassKey=P] constructor(): R|P| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] object H : P {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=H] constructor(): R|P.H| {
+                LAZY_super<P>
+            }
+
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class J : P {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=J] constructor(): R|P.J| {
+                LAZY_super<P>
+            }
+
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] object T : R|kotlin/Any| {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=T] constructor(): R|P.T| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] object V : P {
+                private [ResolvedTo(RAW_FIR)] [ContainingClassKey=V] constructor(): R|P.T.V| {
+                    LAZY_super<P>
+                }
+
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] class M : P {
+                public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=M] constructor(): R|P.T.M| {
+                    LAZY_super<P>
+                }
+
+            }
+
+        }
+
+        public final [ResolvedTo(STATUS)] val p: R|P| = LAZY_EXPRESSION
+            public [ResolvedTo(STATUS)] [ContainingClassKey=P] get(): R|P|
+
+        public final [ResolvedTo(STATUS)] val r: <implicit> = LAZY_EXPRESSION
+            public [ResolvedTo(STATUS)] [ContainingClassKey=P] get(): <implicit>
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] class K : P {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=K] constructor(): R|K| {
+            LAZY_super<P>
+        }
+
+    }
+    public final [ResolvedTo(STATUS)] object B : R|kotlin/Any| {
+        private [ResolvedTo(STATUS)] [ContainingClassKey=B] constructor(): R|B| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public final [ResolvedTo(STATUS)] class I : R|P| {
+            public [ResolvedTo(EXPECT_ACTUAL_MATCHING)] [ContainingClassKey=I] constructor(): R|B.I| {
+                LAZY_super<R|P|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] fun test(): R|kotlin/Unit| { LAZY_BLOCK }
+
+ARGUMENTS_OF_ANNOTATIONS:
+FILE: [ResolvedTo(IMPORTS)] complexRedeclaration.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public sealed [ResolvedTo(STATUS)] class A : R|kotlin/Any| {
+        protected [ResolvedTo(STATUS)] [ContainingClassKey=A] constructor(): R|A| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+    }
+    public final [ResolvedTo(STATUS)] class B : R|A| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=B] constructor(): R|B| {
+            LAZY_super<R|A|>
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface C : A {
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface D : C, A {
+    }
+    public? final? [ResolvedTo(RAW_FIR)] class E : B, A {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=E] constructor(): R|E| {
+            LAZY_super<A>
+        }
+
+    }
+    public sealed [ResolvedTo(STATUS)] class P : R|kotlin/Any| {
+        protected [ResolvedTo(STATUS)] [ContainingClassKey=P] constructor(): R|P| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] object H : P {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=H] constructor(): R|P.H| {
+                LAZY_super<P>
+            }
+
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class J : P {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=J] constructor(): R|P.J| {
+                LAZY_super<P>
+            }
+
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] object T : R|kotlin/Any| {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=T] constructor(): R|P.T| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] object V : P {
+                private [ResolvedTo(RAW_FIR)] [ContainingClassKey=V] constructor(): R|P.T.V| {
+                    LAZY_super<P>
+                }
+
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] class M : P {
+                public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=M] constructor(): R|P.T.M| {
+                    LAZY_super<P>
+                }
+
+            }
+
+        }
+
+        public final [ResolvedTo(STATUS)] val p: R|P| = LAZY_EXPRESSION
+            public [ResolvedTo(STATUS)] [ContainingClassKey=P] get(): R|P|
+
+        public final [ResolvedTo(STATUS)] val r: <implicit> = LAZY_EXPRESSION
+            public [ResolvedTo(STATUS)] [ContainingClassKey=P] get(): <implicit>
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] class K : P {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=K] constructor(): R|K| {
+            LAZY_super<P>
+        }
+
+    }
+    public final [ResolvedTo(STATUS)] object B : R|kotlin/Any| {
+        private [ResolvedTo(STATUS)] [ContainingClassKey=B] constructor(): R|B| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public final [ResolvedTo(STATUS)] class I : R|P| {
+            public [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] [ContainingClassKey=I] constructor(): R|B.I| {
+                LAZY_super<R|P|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] fun test(): R|kotlin/Unit| { LAZY_BLOCK }
+
+CONTRACTS:
+FILE: [ResolvedTo(IMPORTS)] complexRedeclaration.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public sealed [ResolvedTo(STATUS)] class A : R|kotlin/Any| {
+        protected [ResolvedTo(STATUS)] [ContainingClassKey=A] constructor(): R|A| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+    }
+    public final [ResolvedTo(STATUS)] class B : R|A| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=B] constructor(): R|B| {
+            LAZY_super<R|A|>
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface C : A {
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface D : C, A {
+    }
+    public? final? [ResolvedTo(RAW_FIR)] class E : B, A {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=E] constructor(): R|E| {
+            LAZY_super<A>
+        }
+
+    }
+    public sealed [ResolvedTo(STATUS)] class P : R|kotlin/Any| {
+        protected [ResolvedTo(STATUS)] [ContainingClassKey=P] constructor(): R|P| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] object H : P {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=H] constructor(): R|P.H| {
+                LAZY_super<P>
+            }
+
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class J : P {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=J] constructor(): R|P.J| {
+                LAZY_super<P>
+            }
+
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] object T : R|kotlin/Any| {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=T] constructor(): R|P.T| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] object V : P {
+                private [ResolvedTo(RAW_FIR)] [ContainingClassKey=V] constructor(): R|P.T.V| {
+                    LAZY_super<P>
+                }
+
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] class M : P {
+                public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=M] constructor(): R|P.T.M| {
+                    LAZY_super<P>
+                }
+
+            }
+
+        }
+
+        public final [ResolvedTo(STATUS)] val p: R|P| = LAZY_EXPRESSION
+            public [ResolvedTo(STATUS)] [ContainingClassKey=P] get(): R|P|
+
+        public final [ResolvedTo(STATUS)] val r: <implicit> = LAZY_EXPRESSION
+            public [ResolvedTo(STATUS)] [ContainingClassKey=P] get(): <implicit>
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] class K : P {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=K] constructor(): R|K| {
+            LAZY_super<P>
+        }
+
+    }
+    public final [ResolvedTo(STATUS)] object B : R|kotlin/Any| {
+        private [ResolvedTo(STATUS)] [ContainingClassKey=B] constructor(): R|B| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public final [ResolvedTo(STATUS)] class I : R|P| {
+            public [ResolvedTo(CONTRACTS)] [ContainingClassKey=I] constructor(): R|B.I| {
+                super<R|P|>()
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] fun test(): R|kotlin/Unit| { LAZY_BLOCK }
+
+IMPLICIT_TYPES_BODY_RESOLVE:
+FILE: [ResolvedTo(IMPORTS)] complexRedeclaration.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public sealed [ResolvedTo(STATUS)] class A : R|kotlin/Any| {
+        protected [ResolvedTo(STATUS)] [ContainingClassKey=A] constructor(): R|A| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+    }
+    public final [ResolvedTo(STATUS)] class B : R|A| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=B] constructor(): R|B| {
+            LAZY_super<R|A|>
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface C : A {
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface D : C, A {
+    }
+    public? final? [ResolvedTo(RAW_FIR)] class E : B, A {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=E] constructor(): R|E| {
+            LAZY_super<A>
+        }
+
+    }
+    public sealed [ResolvedTo(STATUS)] class P : R|kotlin/Any| {
+        protected [ResolvedTo(STATUS)] [ContainingClassKey=P] constructor(): R|P| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] object H : P {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=H] constructor(): R|P.H| {
+                LAZY_super<P>
+            }
+
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class J : P {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=J] constructor(): R|P.J| {
+                LAZY_super<P>
+            }
+
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] object T : R|kotlin/Any| {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=T] constructor(): R|P.T| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] object V : P {
+                private [ResolvedTo(RAW_FIR)] [ContainingClassKey=V] constructor(): R|P.T.V| {
+                    LAZY_super<P>
+                }
+
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] class M : P {
+                public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=M] constructor(): R|P.T.M| {
+                    LAZY_super<P>
+                }
+
+            }
+
+        }
+
+        public final [ResolvedTo(STATUS)] val p: R|P| = LAZY_EXPRESSION
+            public [ResolvedTo(STATUS)] [ContainingClassKey=P] get(): R|P|
+
+        public final [ResolvedTo(STATUS)] val r: <implicit> = LAZY_EXPRESSION
+            public [ResolvedTo(STATUS)] [ContainingClassKey=P] get(): <implicit>
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] class K : P {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=K] constructor(): R|K| {
+            LAZY_super<P>
+        }
+
+    }
+    public final [ResolvedTo(STATUS)] object B : R|kotlin/Any| {
+        private [ResolvedTo(STATUS)] [ContainingClassKey=B] constructor(): R|B| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public final [ResolvedTo(STATUS)] class I : R|P| {
+            public [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] [ContainingClassKey=I] constructor(): R|B.I| {
+                super<R|P|>()
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] fun test(): R|kotlin/Unit| { LAZY_BLOCK }
+
+ANNOTATIONS_ARGUMENTS_MAPPING:
+FILE: [ResolvedTo(IMPORTS)] complexRedeclaration.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public sealed [ResolvedTo(STATUS)] class A : R|kotlin/Any| {
+        protected [ResolvedTo(STATUS)] [ContainingClassKey=A] constructor(): R|A| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+    }
+    public final [ResolvedTo(STATUS)] class B : R|A| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=B] constructor(): R|B| {
+            LAZY_super<R|A|>
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface C : A {
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface D : C, A {
+    }
+    public? final? [ResolvedTo(RAW_FIR)] class E : B, A {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=E] constructor(): R|E| {
+            LAZY_super<A>
+        }
+
+    }
+    public sealed [ResolvedTo(STATUS)] class P : R|kotlin/Any| {
+        protected [ResolvedTo(STATUS)] [ContainingClassKey=P] constructor(): R|P| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] object H : P {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=H] constructor(): R|P.H| {
+                LAZY_super<P>
+            }
+
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class J : P {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=J] constructor(): R|P.J| {
+                LAZY_super<P>
+            }
+
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] object T : R|kotlin/Any| {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=T] constructor(): R|P.T| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] object V : P {
+                private [ResolvedTo(RAW_FIR)] [ContainingClassKey=V] constructor(): R|P.T.V| {
+                    LAZY_super<P>
+                }
+
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] class M : P {
+                public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=M] constructor(): R|P.T.M| {
+                    LAZY_super<P>
+                }
+
+            }
+
+        }
+
+        public final [ResolvedTo(STATUS)] val p: R|P| = LAZY_EXPRESSION
+            public [ResolvedTo(STATUS)] [ContainingClassKey=P] get(): R|P|
+
+        public final [ResolvedTo(STATUS)] val r: <implicit> = LAZY_EXPRESSION
+            public [ResolvedTo(STATUS)] [ContainingClassKey=P] get(): <implicit>
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] class K : P {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=K] constructor(): R|K| {
+            LAZY_super<P>
+        }
+
+    }
+    public final [ResolvedTo(STATUS)] object B : R|kotlin/Any| {
+        private [ResolvedTo(STATUS)] [ContainingClassKey=B] constructor(): R|B| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public final [ResolvedTo(STATUS)] class I : R|P| {
+            public [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] [ContainingClassKey=I] constructor(): R|B.I| {
+                super<R|P|>()
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] fun test(): R|kotlin/Unit| { LAZY_BLOCK }
+
+BODY_RESOLVE:
+FILE: [ResolvedTo(IMPORTS)] complexRedeclaration.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public sealed [ResolvedTo(STATUS)] class A : R|kotlin/Any| {
+        protected [ResolvedTo(STATUS)] [ContainingClassKey=A] constructor(): R|A| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+    }
+    public final [ResolvedTo(STATUS)] class B : R|A| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=B] constructor(): R|B| {
+            LAZY_super<R|A|>
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface C : A {
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface D : C, A {
+    }
+    public? final? [ResolvedTo(RAW_FIR)] class E : B, A {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=E] constructor(): R|E| {
+            LAZY_super<A>
+        }
+
+    }
+    public sealed [ResolvedTo(STATUS)] class P : R|kotlin/Any| {
+        protected [ResolvedTo(STATUS)] [ContainingClassKey=P] constructor(): R|P| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] object H : P {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=H] constructor(): R|P.H| {
+                LAZY_super<P>
+            }
+
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class J : P {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=J] constructor(): R|P.J| {
+                LAZY_super<P>
+            }
+
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] object T : R|kotlin/Any| {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=T] constructor(): R|P.T| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] object V : P {
+                private [ResolvedTo(RAW_FIR)] [ContainingClassKey=V] constructor(): R|P.T.V| {
+                    LAZY_super<P>
+                }
+
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] class M : P {
+                public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=M] constructor(): R|P.T.M| {
+                    LAZY_super<P>
+                }
+
+            }
+
+        }
+
+        public final [ResolvedTo(STATUS)] val p: R|P| = LAZY_EXPRESSION
+            public [ResolvedTo(STATUS)] [ContainingClassKey=P] get(): R|P|
+
+        public final [ResolvedTo(STATUS)] val r: <implicit> = LAZY_EXPRESSION
+            public [ResolvedTo(STATUS)] [ContainingClassKey=P] get(): <implicit>
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] class K : P {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=K] constructor(): R|K| {
+            LAZY_super<P>
+        }
+
+    }
+    public final [ResolvedTo(STATUS)] object B : R|kotlin/Any| {
+        private [ResolvedTo(STATUS)] [ContainingClassKey=B] constructor(): R|B| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public final [ResolvedTo(STATUS)] class I : R|P| {
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=I] constructor(): R|B.I| {
+                super<R|P|>()
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] fun test(): R|kotlin/Unit| { LAZY_BLOCK }
+
+FILE RAW TO BODY:
+FILE: [ResolvedTo(IMPORTS)] complexRedeclaration.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public sealed [ResolvedTo(BODY_RESOLVE)] class A : R|kotlin/Any| {
+        protected [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=A] constructor(): R|A| {
+            super<R|kotlin/Any|>()
+        }
+
+    }
+    public final [ResolvedTo(BODY_RESOLVE)] class B : R|A| {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=B] constructor(): R|B| {
+            super<R|A|>()
+        }
+
+    }
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface C : R|A| {
+    }
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface D : R|C|, R|A| {
+    }
+    public final [ResolvedTo(BODY_RESOLVE)] class E : R|B|, R|A| {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=E] constructor(): R|E| {
+            super<R|A|>()
+        }
+
+    }
+    public sealed [ResolvedTo(BODY_RESOLVE)] class P : R|kotlin/Any| {
+        protected [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=P] constructor(): R|P| {
+            super<R|kotlin/Any|>()
+        }
+
+        public final [ResolvedTo(BODY_RESOLVE)] object H : R|P| {
+            private [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=H] constructor(): R|P.H| {
+                super<R|P|>()
+            }
+
+        }
+
+        public final [ResolvedTo(BODY_RESOLVE)] class J : R|P| {
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=J] constructor(): R|P.J| {
+                super<R|P|>()
+            }
+
+        }
+
+        public final [ResolvedTo(BODY_RESOLVE)] object T : R|kotlin/Any| {
+            private [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=T] constructor(): R|P.T| {
+                super<R|kotlin/Any|>()
+            }
+
+            public final [ResolvedTo(BODY_RESOLVE)] object V : R|P| {
+                private [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=V] constructor(): R|P.T.V| {
+                    super<R|P|>()
+                }
+
+            }
+
+            public final [ResolvedTo(BODY_RESOLVE)] class M : R|P| {
+                public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=M] constructor(): R|P.T.M| {
+                    super<R|P|>()
+                }
+
+            }
+
+        }
+
+        public final [ResolvedTo(BODY_RESOLVE)] val p: R|P| = object : R|P| {
+            private [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=<anonymous>] constructor(): R|<anonymous>| {
+                super<R|P|>()
+            }
+
+        }
+
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=P] get(): R|P|
+
+        public final [ResolvedTo(BODY_RESOLVE)] val r: R|P| = object : R|P| {
+            private [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=<anonymous>] constructor(): R|<anonymous>| {
+                super<R|P|>()
+            }
+
+        }
+
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=P] get(): R|P|
+
+    }
+    public final [ResolvedTo(BODY_RESOLVE)] class K : R|P| {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=K] constructor(): R|K| {
+            super<R|P|>()
+        }
+
+    }
+    public final [ResolvedTo(BODY_RESOLVE)] object B : R|kotlin/Any| {
+        private [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=B] constructor(): R|B| {
+            super<R|kotlin/Any|>()
+        }
+
+        public final [ResolvedTo(BODY_RESOLVE)] class I : R|P| {
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=I] constructor(): R|B.I| {
+                super<R|P|>()
+            }
+
+        }
+
+    }
+    public final [ResolvedTo(BODY_RESOLVE)] fun test(): R|kotlin/Unit| {
+        local final [ResolvedTo(BODY_RESOLVE)] class L : R|P| {
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=L] constructor(): R|L| {
+                super<R|P|>()
+            }
+
+        }
+
+        [ResolvedTo(BODY_RESOLVE)] lval a: R|<anonymous>| = object : R|P| {
+            private [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=<anonymous>] constructor(): R|<anonymous>| {
+                super<R|P|>()
+            }
+
+        }
+
+    }
diff --git a/analysis/low-level-api-fir/testdata/lazyResolve/redeclaration.txt b/analysis/low-level-api-fir/testdata/lazyResolve/redeclaration.txt
index dcf0471230b..945c058f69d 100644
--- a/analysis/low-level-api-fir/testdata/lazyResolve/redeclaration.txt
+++ b/analysis/low-level-api-fir/testdata/lazyResolve/redeclaration.txt
@@ -65,13 +65,13 @@ FILE: [ResolvedTo(IMPORTS)] redeclaration.kt
 SUPER_TYPES:
 FILE: [ResolvedTo(IMPORTS)] redeclaration.kt
     [ResolvedTo(RAW_FIR)] annotations container
-    public? final? [ResolvedTo(SUPER_TYPES)] class A : R|kotlin/Any| {
+    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
         public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+    public? final? [ResolvedTo(SUPER_TYPES)] class A : R|kotlin/Any| {
         public? [ResolvedTo(SUPER_TYPES)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
@@ -81,13 +81,13 @@ FILE: [ResolvedTo(IMPORTS)] redeclaration.kt
 TYPES:
 FILE: [ResolvedTo(IMPORTS)] redeclaration.kt
     [ResolvedTo(RAW_FIR)] annotations container
-    public? final? [ResolvedTo(TYPES)] class A : R|kotlin/Any| {
-        public? [ResolvedTo(TYPES)] [ContainingClassKey=A] constructor(): R|A| {
+    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+    public? final? [ResolvedTo(TYPES)] class A : R|kotlin/Any| {
         public? [ResolvedTo(TYPES)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
@@ -97,13 +97,13 @@ FILE: [ResolvedTo(IMPORTS)] redeclaration.kt
 STATUS:
 FILE: [ResolvedTo(IMPORTS)] redeclaration.kt
     [ResolvedTo(RAW_FIR)] annotations container
-    public final [ResolvedTo(STATUS)] class A : R|kotlin/Any| {
-        public [ResolvedTo(STATUS)] [ContainingClassKey=A] constructor(): R|A| {
+    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+    public final [ResolvedTo(STATUS)] class A : R|kotlin/Any| {
         public [ResolvedTo(STATUS)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
@@ -113,13 +113,13 @@ FILE: [ResolvedTo(IMPORTS)] redeclaration.kt
 EXPECT_ACTUAL_MATCHING:
 FILE: [ResolvedTo(IMPORTS)] redeclaration.kt
     [ResolvedTo(RAW_FIR)] annotations container
-    public final [ResolvedTo(STATUS)] class A : R|kotlin/Any| {
-        public [ResolvedTo(STATUS)] [ContainingClassKey=A] constructor(): R|A| {
+    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+    public final [ResolvedTo(STATUS)] class A : R|kotlin/Any| {
         public [ResolvedTo(EXPECT_ACTUAL_MATCHING)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
@@ -135,7 +135,7 @@ FILE: [ResolvedTo(IMPORTS)] redeclaration.kt
         }
 
     }
-    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+    public final [ResolvedTo(STATUS)] class A : R|kotlin/Any| {
         public [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
@@ -151,7 +151,7 @@ FILE: [ResolvedTo(IMPORTS)] redeclaration.kt
         }
 
     }
-    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+    public final [ResolvedTo(STATUS)] class A : R|kotlin/Any| {
         public [ResolvedTo(CONTRACTS)] [ContainingClassKey=A] constructor(): R|A| {
             super<R|kotlin/Any|>()
         }
@@ -167,7 +167,7 @@ FILE: [ResolvedTo(IMPORTS)] redeclaration.kt
         }
 
     }
-    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+    public final [ResolvedTo(STATUS)] class A : R|kotlin/Any| {
         public [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] [ContainingClassKey=A] constructor(): R|A| {
             super<R|kotlin/Any|>()
         }
@@ -183,7 +183,7 @@ FILE: [ResolvedTo(IMPORTS)] redeclaration.kt
         }
 
     }
-    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+    public final [ResolvedTo(STATUS)] class A : R|kotlin/Any| {
         public [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] [ContainingClassKey=A] constructor(): R|A| {
             super<R|kotlin/Any|>()
         }
@@ -199,7 +199,7 @@ FILE: [ResolvedTo(IMPORTS)] redeclaration.kt
         }
 
     }
-    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+    public final [ResolvedTo(STATUS)] class A : R|kotlin/Any| {
         public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=A] constructor(): R|A| {
             super<R|kotlin/Any|>()
         }
diff --git a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/FirOutOfContentRootLazyDeclarationResolveTestGenerated.java b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/FirOutOfContentRootLazyDeclarationResolveTestGenerated.java
index 3958d579173..e94bafa37f1 100644
--- a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/FirOutOfContentRootLazyDeclarationResolveTestGenerated.java
+++ b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/FirOutOfContentRootLazyDeclarationResolveTestGenerated.java
@@ -84,6 +84,12 @@ public class FirOutOfContentRootLazyDeclarationResolveTestGenerated extends Abst
         runTest("analysis/low-level-api-fir/testdata/lazyResolve/complexLocalHierarchy.kt");
     }
 
+    @Test
+    @TestMetadata("complexRedeclaration.kt")
+    public void testComplexRedeclaration() throws Exception {
+        runTest("analysis/low-level-api-fir/testdata/lazyResolve/complexRedeclaration.kt");
+    }
+
     @Test
     @TestMetadata("cyclicHierarchy.kt")
     public void testCyclicHierarchy() throws Exception {
diff --git a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/FirSourceLazyDeclarationResolveTestGenerated.java b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/FirSourceLazyDeclarationResolveTestGenerated.java
index d9654985dd4..709a3b553e3 100644
--- a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/FirSourceLazyDeclarationResolveTestGenerated.java
+++ b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/FirSourceLazyDeclarationResolveTestGenerated.java
@@ -84,6 +84,12 @@ public class FirSourceLazyDeclarationResolveTestGenerated extends AbstractFirSou
         runTest("analysis/low-level-api-fir/testdata/lazyResolve/complexLocalHierarchy.kt");
     }
 
+    @Test
+    @TestMetadata("complexRedeclaration.kt")
+    public void testComplexRedeclaration() throws Exception {
+        runTest("analysis/low-level-api-fir/testdata/lazyResolve/complexRedeclaration.kt");
+    }
+
     @Test
     @TestMetadata("cyclicHierarchy.kt")
     public void testCyclicHierarchy() throws Exception {