[LL FIR] add more lazy resolve tests on status phase

^KT-56551

analysis/low-level-api-fir/testdata/lazyResolve/classes/hierarchyWithOverride.kt

@@ -0,0 +1,15 @@
+interface Foo1 {
+    fun foo()
+    fun bar()
+    val str: String
+}
+
+interface Foo2 : Foo1 {
+    fun foo(i: Int)
+    fun bar(s: String)
+    val isBoo: Boolean
+}
+
+abstract class Usag<caret>e : Foo2 {
+    override fun foo() {}
+}

analysis/low-level-api-fir/testdata/lazyResolve/classes/hierarchyWithOverride.txt

@@ -0,0 +1,421 @@
+RAW_FIR:
+FILE: [ResolvedTo(RAW_FIR)] hierarchyWithOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(RAW_FIR)] class Usage : Foo2 {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            LAZY_super<<implicit>>
+        }
+
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+    }
+
+IMPORTS:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(RAW_FIR)] class Usage : Foo2 {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            LAZY_super<<implicit>>
+        }
+
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+    }
+
+COMPILER_REQUIRED_ANNOTATIONS:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] class Usage : Foo2 {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            LAZY_super<<implicit>>
+        }
+
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+    }
+
+COMPANION_GENERATION:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(COMPANION_GENERATION)] class Usage : Foo2 {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            LAZY_super<<implicit>>
+        }
+
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+    }
+
+SUPER_TYPES:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : R|Foo1| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(SUPER_TYPES)] class Usage : R|Foo2| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            LAZY_super<<implicit>>
+        }
+
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+    }
+
+TYPES:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : R|Foo1| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(TYPES)] class Usage : R|Foo2| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            LAZY_super<<implicit>>
+        }
+
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+    }
+
+STATUS:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public abstract [ResolvedTo(STATUS)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(STATUS)] fun foo([ResolvedTo(STATUS)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public abstract [ResolvedTo(STATUS)] class Usage : R|Foo2| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            LAZY_super<<implicit>>
+        }
+
+        public open override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+    }
+
+EXPECT_ACTUAL_MATCHING:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public abstract [ResolvedTo(STATUS)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(STATUS)] fun foo([ResolvedTo(STATUS)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public abstract [ResolvedTo(EXPECT_ACTUAL_MATCHING)] class Usage : R|Foo2| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            LAZY_super<<implicit>>
+        }
+
+        public open override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+    }
+
+ARGUMENTS_OF_ANNOTATIONS:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public abstract [ResolvedTo(STATUS)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(STATUS)] fun foo([ResolvedTo(STATUS)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public abstract [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] class Usage : R|Foo2| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            LAZY_super<<implicit>>
+        }
+
+        public open override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+    }
+
+CONTRACTS:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public abstract [ResolvedTo(STATUS)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(STATUS)] fun foo([ResolvedTo(STATUS)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public abstract [ResolvedTo(CONTRACTS)] class Usage : R|Foo2| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            LAZY_super<<implicit>>
+        }
+
+        public open override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+    }
+
+IMPLICIT_TYPES_BODY_RESOLVE:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public abstract [ResolvedTo(STATUS)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(STATUS)] fun foo([ResolvedTo(STATUS)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public abstract [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] class Usage : R|Foo2| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            LAZY_super<<implicit>>
+        }
+
+        public open override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+    }
+
+ANNOTATIONS_ARGUMENTS_MAPPING:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public abstract [ResolvedTo(STATUS)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(STATUS)] fun foo([ResolvedTo(STATUS)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public abstract [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] class Usage : R|Foo2| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            LAZY_super<<implicit>>
+        }
+
+        public open override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+    }
+
+BODY_RESOLVE:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public abstract [ResolvedTo(STATUS)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(STATUS)] fun foo([ResolvedTo(STATUS)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public abstract [ResolvedTo(BODY_RESOLVE)] class Usage : R|Foo2| {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            super<R|kotlin/Any|>()
+        }
+
+        public open override [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit| {
+        }
+
+    }
+
+FILE RAW TO BODY:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverride.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] val str: R|kotlin/String|
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun foo([ResolvedTo(BODY_RESOLVE)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun bar([ResolvedTo(BODY_RESOLVE)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public abstract [ResolvedTo(BODY_RESOLVE)] class Usage : R|Foo2| {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            super<R|kotlin/Any|>()
+        }
+
+        public open override [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit| {
+        }
+
+    }

analysis/low-level-api-fir/testdata/lazyResolve/classes/hierarchyWithOverrideAndNestedClass.kt

@@ -0,0 +1,37 @@
+interface Foo1 {
+    fun foo()
+    fun bar()
+    val str: String
+
+    class ClassFromInterface
+}
+
+interface Foo2 : Foo1 {
+    fun foo(i: Int)
+    fun bar(s: String)
+    val isBoo: Boolean
+}
+
+interface Foo3 : Foo1 {
+    fun foo(i: Int)
+    fun bar(s: String)
+    val isBoo: Boolean
+}
+
+abstract class Oute<caret>rClass : Foo1 {
+    class SimpleNestedClass {
+        fun foo() {
+
+        }
+    }
+
+    abstract class NestedClass : Foo2 {
+        override fun foo() {}
+    }
+
+    abstract class AnotherNestedClass : NestedClass() {
+        override fun bar(s: String) {
+
+        }
+    }
+}

analysis/low-level-api-fir/testdata/lazyResolve/classes/hierarchyWithOverrideAndNestedClass.txt

@@ -0,0 +1,996 @@
+RAW_FIR:
+FILE: [ResolvedTo(RAW_FIR)] hierarchyWithOverrideAndNestedClass.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(RAW_FIR)] class OuterClass : Foo1 {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class NestedClass : Foo2 {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+IMPORTS:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(RAW_FIR)] class OuterClass : Foo1 {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class NestedClass : Foo2 {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+COMPILER_REQUIRED_ANNOTATIONS:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] class OuterClass : Foo1 {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class NestedClass : Foo2 {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+COMPANION_GENERATION:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(COMPANION_GENERATION)] class OuterClass : Foo1 {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class NestedClass : Foo2 {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+SUPER_TYPES:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(SUPER_TYPES)] class OuterClass : R|Foo1| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class NestedClass : Foo2 {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+TYPES:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(TYPES)] class OuterClass : R|Foo1| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class NestedClass : Foo2 {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+STATUS:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public abstract [ResolvedTo(STATUS)] class OuterClass : R|Foo1| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class NestedClass : Foo2 {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+EXPECT_ACTUAL_MATCHING:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public abstract [ResolvedTo(EXPECT_ACTUAL_MATCHING)] class OuterClass : R|Foo1| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class NestedClass : Foo2 {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+ARGUMENTS_OF_ANNOTATIONS:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public abstract [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] class OuterClass : R|Foo1| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class NestedClass : Foo2 {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+CONTRACTS:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public abstract [ResolvedTo(CONTRACTS)] class OuterClass : R|Foo1| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class NestedClass : Foo2 {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+IMPLICIT_TYPES_BODY_RESOLVE:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public abstract [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] class OuterClass : R|Foo1| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class NestedClass : Foo2 {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+ANNOTATIONS_ARGUMENTS_MAPPING:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public abstract [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] class OuterClass : R|Foo1| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class NestedClass : Foo2 {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+BODY_RESOLVE:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public abstract [ResolvedTo(BODY_RESOLVE)] class OuterClass : R|Foo1| {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            super<R|kotlin/Any|>()
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class NestedClass : Foo2 {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+FILE RAW TO BODY:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] val str: R|kotlin/String|
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+        public final [ResolvedTo(BODY_RESOLVE)] class ClassFromInterface : R|kotlin/Any| {
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                super<R|kotlin/Any|>()
+            }
+
+        }
+
+    }
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun foo([ResolvedTo(BODY_RESOLVE)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun bar([ResolvedTo(BODY_RESOLVE)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Foo3 : R|Foo1| {
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun foo([ResolvedTo(BODY_RESOLVE)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun bar([ResolvedTo(BODY_RESOLVE)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Foo3] get(): R|kotlin/Boolean|
+
+    }
+    public abstract [ResolvedTo(BODY_RESOLVE)] class OuterClass : R|Foo1| {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            super<R|kotlin/Any|>()
+        }
+
+        public final [ResolvedTo(BODY_RESOLVE)] class SimpleNestedClass : R|kotlin/Any| {
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                super<R|kotlin/Any|>()
+            }
+
+            public final [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit| {
+            }
+
+        }
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] class NestedClass : R|Foo2| {
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                super<R|kotlin/Any|>()
+            }
+
+            public open override [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit| {
+            }
+
+        }
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] class AnotherNestedClass : R|OuterClass.NestedClass| {
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                super<R|OuterClass.NestedClass|>()
+            }
+
+            public open override [ResolvedTo(BODY_RESOLVE)] fun bar([ResolvedTo(BODY_RESOLVE)] s: R|kotlin/String|): R|kotlin/Unit| {
+            }
+
+        }
+
+    }

analysis/low-level-api-fir/testdata/lazyResolve/classes/hierarchyWithOverrideAndNestedClass2.kt

@@ -0,0 +1,37 @@
+interface Foo1 {
+    fun foo()
+    fun bar()
+    val str: String
+
+    class ClassFromInterface
+}
+
+interface Foo2 : Foo1 {
+    fun foo(i: Int)
+    fun bar(s: String)
+    val isBoo: Boolean
+}
+
+interface Foo3 : Foo1 {
+    fun foo(i: Int)
+    fun bar(s: String)
+    val isBoo: Boolean
+}
+
+abstract class OuterClass : Foo1 {
+    class SimpleNestedClass {
+        fun foo() {
+
+        }
+    }
+
+    abstract class Neste<caret>dClass : Foo2 {
+        override fun foo() {}
+    }
+
+    abstract class AnotherNestedClass : NestedClass() {
+        override fun bar(s: String) {
+
+        }
+    }
+}

analysis/low-level-api-fir/testdata/lazyResolve/classes/hierarchyWithOverrideAndNestedClass2.txt

@@ -0,0 +1,997 @@
+RAW_FIR:
+FILE: [ResolvedTo(RAW_FIR)] hierarchyWithOverrideAndNestedClass2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(RAW_FIR)] class OuterClass : Foo1 {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class NestedClass : Foo2 {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+IMPORTS:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(RAW_FIR)] class OuterClass : Foo1 {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class NestedClass : Foo2 {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+COMPILER_REQUIRED_ANNOTATIONS:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(RAW_FIR)] class OuterClass : Foo1 {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] class NestedClass : Foo2 {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+COMPANION_GENERATION:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(RAW_FIR)] class OuterClass : Foo1 {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(COMPANION_GENERATION)] class NestedClass : Foo2 {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+SUPER_TYPES:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : R|Foo1| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(SUPER_TYPES)] class OuterClass : R|Foo1| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(SUPER_TYPES)] class NestedClass : R|Foo2| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+TYPES:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : R|Foo1| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(TYPES)] class OuterClass : R|Foo1| {
+        public? [ResolvedTo(TYPES)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(TYPES)] class NestedClass : R|Foo2| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+STATUS:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public abstract [ResolvedTo(STATUS)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(STATUS)] fun foo([ResolvedTo(STATUS)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public abstract [ResolvedTo(STATUS)] class OuterClass : R|Foo1| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public abstract [ResolvedTo(STATUS)] class NestedClass : R|Foo2| {
+            public [ResolvedTo(STATUS)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public open override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+EXPECT_ACTUAL_MATCHING:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public abstract [ResolvedTo(STATUS)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(STATUS)] fun foo([ResolvedTo(STATUS)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public abstract [ResolvedTo(STATUS)] class OuterClass : R|Foo1| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public abstract [ResolvedTo(EXPECT_ACTUAL_MATCHING)] class NestedClass : R|Foo2| {
+            public [ResolvedTo(STATUS)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public open override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+ARGUMENTS_OF_ANNOTATIONS:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public abstract [ResolvedTo(STATUS)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(STATUS)] fun foo([ResolvedTo(STATUS)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public abstract [ResolvedTo(STATUS)] class OuterClass : R|Foo1| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public abstract [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] class NestedClass : R|Foo2| {
+            public [ResolvedTo(STATUS)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public open override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+CONTRACTS:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public abstract [ResolvedTo(STATUS)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(STATUS)] fun foo([ResolvedTo(STATUS)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public abstract [ResolvedTo(STATUS)] class OuterClass : R|Foo1| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public abstract [ResolvedTo(CONTRACTS)] class NestedClass : R|Foo2| {
+            public [ResolvedTo(STATUS)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public open override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+IMPLICIT_TYPES_BODY_RESOLVE:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public abstract [ResolvedTo(STATUS)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(STATUS)] fun foo([ResolvedTo(STATUS)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public abstract [ResolvedTo(STATUS)] class OuterClass : R|Foo1| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public abstract [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] class NestedClass : R|Foo2| {
+            public [ResolvedTo(STATUS)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public open override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+ANNOTATIONS_ARGUMENTS_MAPPING:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public abstract [ResolvedTo(STATUS)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(STATUS)] fun foo([ResolvedTo(STATUS)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public abstract [ResolvedTo(STATUS)] class OuterClass : R|Foo1| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public abstract [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] class NestedClass : R|Foo2| {
+            public [ResolvedTo(STATUS)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public open override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+BODY_RESOLVE:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public abstract [ResolvedTo(STATUS)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(STATUS)] fun foo([ResolvedTo(STATUS)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public abstract [ResolvedTo(STATUS)] class OuterClass : R|Foo1| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] class NestedClass : R|Foo2| {
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                super<R|kotlin/Any|>()
+            }
+
+            public open override [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit| {
+            }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+FILE RAW TO BODY:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass2.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] val str: R|kotlin/String|
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+        public final [ResolvedTo(BODY_RESOLVE)] class ClassFromInterface : R|kotlin/Any| {
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                super<R|kotlin/Any|>()
+            }
+
+        }
+
+    }
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun foo([ResolvedTo(BODY_RESOLVE)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun bar([ResolvedTo(BODY_RESOLVE)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Foo3 : R|Foo1| {
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun foo([ResolvedTo(BODY_RESOLVE)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun bar([ResolvedTo(BODY_RESOLVE)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Foo3] get(): R|kotlin/Boolean|
+
+    }
+    public abstract [ResolvedTo(BODY_RESOLVE)] class OuterClass : R|Foo1| {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            super<R|kotlin/Any|>()
+        }
+
+        public final [ResolvedTo(BODY_RESOLVE)] class SimpleNestedClass : R|kotlin/Any| {
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                super<R|kotlin/Any|>()
+            }
+
+            public final [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit| {
+            }
+
+        }
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] class NestedClass : R|Foo2| {
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                super<R|kotlin/Any|>()
+            }
+
+            public open override [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit| {
+            }
+
+        }
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] class AnotherNestedClass : R|OuterClass.NestedClass| {
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                super<R|OuterClass.NestedClass|>()
+            }
+
+            public open override [ResolvedTo(BODY_RESOLVE)] fun bar([ResolvedTo(BODY_RESOLVE)] s: R|kotlin/String|): R|kotlin/Unit| {
+            }
+
+        }
+
+    }

analysis/low-level-api-fir/testdata/lazyResolve/classes/hierarchyWithOverrideAndNestedClass3.kt

@@ -0,0 +1,37 @@
+interface Foo1 {
+    fun foo()
+    fun bar()
+    val str: String
+
+    class ClassFromInterface
+}
+
+interface Foo2 : Foo1 {
+    fun foo(i: Int)
+    fun bar(s: String)
+    val isBoo: Boolean
+}
+
+interface Foo3 : Foo1 {
+    fun foo(i: Int)
+    fun bar(s: String)
+    val isBoo: Boolean
+}
+
+abstract class OuterClass : Foo1 {
+    class Simple<caret>NestedClass {
+        fun foo() {
+
+        }
+    }
+
+    abstract class NestedClass : Foo2 {
+        override fun foo() {}
+    }
+
+    abstract class AnotherNestedClass : NestedClass() {
+        override fun bar(s: String) {
+
+        }
+    }
+}

analysis/low-level-api-fir/testdata/lazyResolve/classes/hierarchyWithOverrideAndNestedClass3.txt

@@ -0,0 +1,997 @@
+RAW_FIR:
+FILE: [ResolvedTo(RAW_FIR)] hierarchyWithOverrideAndNestedClass3.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(RAW_FIR)] class OuterClass : Foo1 {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class NestedClass : Foo2 {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+IMPORTS:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass3.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(RAW_FIR)] class OuterClass : Foo1 {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class NestedClass : Foo2 {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+COMPILER_REQUIRED_ANNOTATIONS:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass3.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(RAW_FIR)] class OuterClass : Foo1 {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class NestedClass : Foo2 {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+COMPANION_GENERATION:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass3.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(RAW_FIR)] class OuterClass : Foo1 {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(COMPANION_GENERATION)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class NestedClass : Foo2 {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+SUPER_TYPES:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass3.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(SUPER_TYPES)] class OuterClass : R|Foo1| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(SUPER_TYPES)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class NestedClass : Foo2 {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+TYPES:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass3.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(TYPES)] class OuterClass : R|Foo1| {
+        public? [ResolvedTo(TYPES)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(TYPES)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class NestedClass : Foo2 {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+STATUS:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass3.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public abstract [ResolvedTo(STATUS)] class OuterClass : R|Foo1| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public final [ResolvedTo(STATUS)] class SimpleNestedClass : R|kotlin/Any| {
+            public [ResolvedTo(STATUS)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public final [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class NestedClass : Foo2 {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+EXPECT_ACTUAL_MATCHING:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass3.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public abstract [ResolvedTo(STATUS)] class OuterClass : R|Foo1| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public final [ResolvedTo(EXPECT_ACTUAL_MATCHING)] class SimpleNestedClass : R|kotlin/Any| {
+            public [ResolvedTo(STATUS)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public final [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class NestedClass : Foo2 {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+ARGUMENTS_OF_ANNOTATIONS:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass3.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public abstract [ResolvedTo(STATUS)] class OuterClass : R|Foo1| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public final [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] class SimpleNestedClass : R|kotlin/Any| {
+            public [ResolvedTo(STATUS)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public final [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class NestedClass : Foo2 {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+CONTRACTS:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass3.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public abstract [ResolvedTo(STATUS)] class OuterClass : R|Foo1| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public final [ResolvedTo(CONTRACTS)] class SimpleNestedClass : R|kotlin/Any| {
+            public [ResolvedTo(STATUS)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public final [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class NestedClass : Foo2 {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+IMPLICIT_TYPES_BODY_RESOLVE:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass3.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public abstract [ResolvedTo(STATUS)] class OuterClass : R|Foo1| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] class SimpleNestedClass : R|kotlin/Any| {
+            public [ResolvedTo(STATUS)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public final [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class NestedClass : Foo2 {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+ANNOTATIONS_ARGUMENTS_MAPPING:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass3.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public abstract [ResolvedTo(STATUS)] class OuterClass : R|Foo1| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public final [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] class SimpleNestedClass : R|kotlin/Any| {
+            public [ResolvedTo(STATUS)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public final [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class NestedClass : Foo2 {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+BODY_RESOLVE:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass3.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public abstract [ResolvedTo(STATUS)] class OuterClass : R|Foo1| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public final [ResolvedTo(BODY_RESOLVE)] class SimpleNestedClass : R|kotlin/Any| {
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                super<R|kotlin/Any|>()
+            }
+
+            public final [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit| {
+            }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class NestedClass : Foo2 {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+FILE RAW TO BODY:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass3.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] val str: R|kotlin/String|
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+        public final [ResolvedTo(BODY_RESOLVE)] class ClassFromInterface : R|kotlin/Any| {
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                super<R|kotlin/Any|>()
+            }
+
+        }
+
+    }
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun foo([ResolvedTo(BODY_RESOLVE)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun bar([ResolvedTo(BODY_RESOLVE)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Foo3 : R|Foo1| {
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun foo([ResolvedTo(BODY_RESOLVE)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun bar([ResolvedTo(BODY_RESOLVE)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Foo3] get(): R|kotlin/Boolean|
+
+    }
+    public abstract [ResolvedTo(BODY_RESOLVE)] class OuterClass : R|Foo1| {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            super<R|kotlin/Any|>()
+        }
+
+        public final [ResolvedTo(BODY_RESOLVE)] class SimpleNestedClass : R|kotlin/Any| {
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                super<R|kotlin/Any|>()
+            }
+
+            public final [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit| {
+            }
+
+        }
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] class NestedClass : R|Foo2| {
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                super<R|kotlin/Any|>()
+            }
+
+            public open override [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit| {
+            }
+
+        }
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] class AnotherNestedClass : R|OuterClass.NestedClass| {
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                super<R|OuterClass.NestedClass|>()
+            }
+
+            public open override [ResolvedTo(BODY_RESOLVE)] fun bar([ResolvedTo(BODY_RESOLVE)] s: R|kotlin/String|): R|kotlin/Unit| {
+            }
+
+        }
+
+    }

analysis/low-level-api-fir/testdata/lazyResolve/classes/hierarchyWithOverrideAndNestedClass4.kt

@@ -0,0 +1,37 @@
+interface Foo1 {
+    fun foo()
+    fun bar()
+    val str: String
+
+    class ClassFromInterface
+}
+
+interface Foo2 : Foo1 {
+    fun foo(i: Int)
+    fun bar(s: String)
+    val isBoo: Boolean
+}
+
+interface Foo3 : Foo1 {
+    fun foo(i: Int)
+    fun bar(s: String)
+    val isBoo: Boolean
+}
+
+abstract class OuterClass : Foo1 {
+    class SimpleNestedClass {
+        fun foo() {
+
+        }
+    }
+
+    abstract class NestedClass : Foo2 {
+        override fun foo() {}
+    }
+
+    abstract class Another<caret>NestedClass : NestedClass() {
+        override fun bar(s: String) {
+
+        }
+    }
+}

analysis/low-level-api-fir/testdata/lazyResolve/classes/hierarchyWithOverrideAndNestedClass4.txt

@@ -0,0 +1,997 @@
+RAW_FIR:
+FILE: [ResolvedTo(RAW_FIR)] hierarchyWithOverrideAndNestedClass4.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(RAW_FIR)] class OuterClass : Foo1 {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class NestedClass : Foo2 {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+IMPORTS:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass4.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(RAW_FIR)] class OuterClass : Foo1 {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class NestedClass : Foo2 {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+COMPILER_REQUIRED_ANNOTATIONS:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass4.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(RAW_FIR)] class OuterClass : Foo1 {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class NestedClass : Foo2 {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+COMPANION_GENERATION:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass4.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(RAW_FIR)] class OuterClass : Foo1 {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] class NestedClass : Foo2 {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(COMPANION_GENERATION)] class AnotherNestedClass : NestedClass {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+SUPER_TYPES:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass4.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : R|Foo1| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(SUPER_TYPES)] class OuterClass : R|Foo1| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(SUPER_TYPES)] class NestedClass : R|Foo2| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(SUPER_TYPES)] class AnotherNestedClass : R|OuterClass.NestedClass| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+TYPES:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass4.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : R|Foo1| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(TYPES)] class OuterClass : R|Foo1| {
+        public? [ResolvedTo(TYPES)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(SUPER_TYPES)] class NestedClass : R|Foo2| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public? abstract [ResolvedTo(TYPES)] class AnotherNestedClass : R|OuterClass.NestedClass| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<NestedClass>
+            }
+
+            public? open? override [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+STATUS:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass4.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public abstract [ResolvedTo(STATUS)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(STATUS)] fun foo([ResolvedTo(STATUS)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public abstract [ResolvedTo(STATUS)] class OuterClass : R|Foo1| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public abstract [ResolvedTo(STATUS)] class NestedClass : R|Foo2| {
+            public [ResolvedTo(STATUS)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public open override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public abstract [ResolvedTo(STATUS)] class AnotherNestedClass : R|OuterClass.NestedClass| {
+            public [ResolvedTo(STATUS)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<R|OuterClass.NestedClass|>
+            }
+
+            public open override [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+EXPECT_ACTUAL_MATCHING:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass4.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public abstract [ResolvedTo(STATUS)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(STATUS)] fun foo([ResolvedTo(STATUS)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public abstract [ResolvedTo(STATUS)] class OuterClass : R|Foo1| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public abstract [ResolvedTo(STATUS)] class NestedClass : R|Foo2| {
+            public [ResolvedTo(STATUS)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public open override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public abstract [ResolvedTo(EXPECT_ACTUAL_MATCHING)] class AnotherNestedClass : R|OuterClass.NestedClass| {
+            public [ResolvedTo(STATUS)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<R|OuterClass.NestedClass|>
+            }
+
+            public open override [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+ARGUMENTS_OF_ANNOTATIONS:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass4.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public abstract [ResolvedTo(STATUS)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(STATUS)] fun foo([ResolvedTo(STATUS)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public abstract [ResolvedTo(STATUS)] class OuterClass : R|Foo1| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public abstract [ResolvedTo(STATUS)] class NestedClass : R|Foo2| {
+            public [ResolvedTo(STATUS)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public open override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public abstract [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] class AnotherNestedClass : R|OuterClass.NestedClass| {
+            public [ResolvedTo(STATUS)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<R|OuterClass.NestedClass|>
+            }
+
+            public open override [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+CONTRACTS:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass4.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public abstract [ResolvedTo(STATUS)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(STATUS)] fun foo([ResolvedTo(STATUS)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public abstract [ResolvedTo(STATUS)] class OuterClass : R|Foo1| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public abstract [ResolvedTo(STATUS)] class NestedClass : R|Foo2| {
+            public [ResolvedTo(STATUS)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public open override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public abstract [ResolvedTo(CONTRACTS)] class AnotherNestedClass : R|OuterClass.NestedClass| {
+            public [ResolvedTo(STATUS)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<R|OuterClass.NestedClass|>
+            }
+
+            public open override [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+IMPLICIT_TYPES_BODY_RESOLVE:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass4.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public abstract [ResolvedTo(STATUS)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(STATUS)] fun foo([ResolvedTo(STATUS)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public abstract [ResolvedTo(STATUS)] class OuterClass : R|Foo1| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public abstract [ResolvedTo(STATUS)] class NestedClass : R|Foo2| {
+            public [ResolvedTo(STATUS)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public open override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public abstract [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] class AnotherNestedClass : R|OuterClass.NestedClass| {
+            public [ResolvedTo(STATUS)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<R|OuterClass.NestedClass|>
+            }
+
+            public open override [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+ANNOTATIONS_ARGUMENTS_MAPPING:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass4.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public abstract [ResolvedTo(STATUS)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(STATUS)] fun foo([ResolvedTo(STATUS)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public abstract [ResolvedTo(STATUS)] class OuterClass : R|Foo1| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public abstract [ResolvedTo(STATUS)] class NestedClass : R|Foo2| {
+            public [ResolvedTo(STATUS)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public open override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public abstract [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] class AnotherNestedClass : R|OuterClass.NestedClass| {
+            public [ResolvedTo(STATUS)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                LAZY_super<R|OuterClass.NestedClass|>
+            }
+
+            public open override [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+    }
+
+BODY_RESOLVE:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass4.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+        public? final? [ResolvedTo(RAW_FIR)] class ClassFromInterface : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+    }
+    public abstract [ResolvedTo(STATUS)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(STATUS)] fun foo([ResolvedTo(STATUS)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): Boolean
+
+    }
+    public abstract [ResolvedTo(STATUS)] class OuterClass : R|Foo1| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            LAZY_super<<implicit>>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class SimpleNestedClass : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+            public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public abstract [ResolvedTo(STATUS)] class NestedClass : R|Foo2| {
+            public [ResolvedTo(STATUS)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                LAZY_super<<implicit>>
+            }
+
+            public open override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        }
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] class AnotherNestedClass : R|OuterClass.NestedClass| {
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                super<R|OuterClass.NestedClass|>()
+            }
+
+            public open override [ResolvedTo(BODY_RESOLVE)] fun bar([ResolvedTo(BODY_RESOLVE)] s: R|kotlin/String|): R|kotlin/Unit| {
+            }
+
+        }
+
+    }
+
+FILE RAW TO BODY:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverrideAndNestedClass4.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] val str: R|kotlin/String|
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+        public final [ResolvedTo(BODY_RESOLVE)] class ClassFromInterface : R|kotlin/Any| {
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=ClassFromInterface] constructor(): R|Foo1.ClassFromInterface| {
+                super<R|kotlin/Any|>()
+            }
+
+        }
+
+    }
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun foo([ResolvedTo(BODY_RESOLVE)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun bar([ResolvedTo(BODY_RESOLVE)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Foo3 : R|Foo1| {
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun foo([ResolvedTo(BODY_RESOLVE)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun bar([ResolvedTo(BODY_RESOLVE)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Foo3] get(): R|kotlin/Boolean|
+
+    }
+    public abstract [ResolvedTo(BODY_RESOLVE)] class OuterClass : R|Foo1| {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=OuterClass] constructor(): R|OuterClass| {
+            super<R|kotlin/Any|>()
+        }
+
+        public final [ResolvedTo(BODY_RESOLVE)] class SimpleNestedClass : R|kotlin/Any| {
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=SimpleNestedClass] constructor(): R|OuterClass.SimpleNestedClass| {
+                super<R|kotlin/Any|>()
+            }
+
+            public final [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit| {
+            }
+
+        }
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] class NestedClass : R|Foo2| {
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=NestedClass] constructor(): R|OuterClass.NestedClass| {
+                super<R|kotlin/Any|>()
+            }
+
+            public open override [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit| {
+            }
+
+        }
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] class AnotherNestedClass : R|OuterClass.NestedClass| {
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=AnotherNestedClass] constructor(): R|OuterClass.AnotherNestedClass| {
+                super<R|OuterClass.NestedClass|>()
+            }
+
+            public open override [ResolvedTo(BODY_RESOLVE)] fun bar([ResolvedTo(BODY_RESOLVE)] s: R|kotlin/String|): R|kotlin/Unit| {
+            }
+
+        }
+
+    }

analysis/low-level-api-fir/testdata/lazyResolve/classes/simpleLoopInOverride.kt

@@ -0,0 +1,11 @@
+interface Fo<caret>o1 : Foo2 {
+    override fun foo()
+}
+
+interface Foo2 : Foo3 {
+    override fun foo()
+}
+
+interface Foo3 : Foo1 {
+    override fun foo()
+}

analysis/low-level-api-fir/testdata/lazyResolve/classes/simpleLoopInOverride.txt

@@ -0,0 +1,223 @@
+RAW_FIR:
+FILE: [ResolvedTo(RAW_FIR)] simpleLoopInOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : Foo2 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo3 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+IMPORTS:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : Foo2 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo3 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+COMPILER_REQUIRED_ANNOTATIONS:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] interface Foo1 : Foo2 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo3 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+COMPANION_GENERATION:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(COMPANION_GENERATION)] interface Foo1 : Foo2 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo3 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+SUPER_TYPES:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+TYPES:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(TYPES)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+STATUS:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+EXPECT_ACTUAL_MATCHING:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(EXPECT_ACTUAL_MATCHING)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+ARGUMENTS_OF_ANNOTATIONS:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+CONTRACTS:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(CONTRACTS)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+IMPLICIT_TYPES_BODY_RESOLVE:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+ANNOTATIONS_ARGUMENTS_MAPPING:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+BODY_RESOLVE:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract override [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+FILE RAW TO BODY:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract override [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit|
+
+    }
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public abstract override [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit|
+
+    }
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public abstract override [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit|
+
+    }

analysis/low-level-api-fir/testdata/lazyResolve/classes/simpleLoopInOverride2.kt

@@ -0,0 +1,11 @@
+interface Fo<caret>o1 : Foo2 {
+    fun foo()
+}
+
+interface Foo2 : Foo3 {
+    override fun foo()
+}
+
+interface Foo3 : Foo1 {
+    override fun foo()
+}

analysis/low-level-api-fir/testdata/lazyResolve/classes/simpleLoopInOverride2.txt

@@ -0,0 +1,223 @@
+RAW_FIR:
+FILE: [ResolvedTo(RAW_FIR)] simpleLoopInOverride2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : Foo2 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo3 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+IMPORTS:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : Foo2 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo3 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+COMPILER_REQUIRED_ANNOTATIONS:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] interface Foo1 : Foo2 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo3 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+COMPANION_GENERATION:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(COMPANION_GENERATION)] interface Foo1 : Foo2 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo3 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+SUPER_TYPES:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+TYPES:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(TYPES)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+STATUS:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+EXPECT_ACTUAL_MATCHING:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(EXPECT_ACTUAL_MATCHING)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+ARGUMENTS_OF_ANNOTATIONS:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+CONTRACTS:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(CONTRACTS)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+IMPLICIT_TYPES_BODY_RESOLVE:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+ANNOTATIONS_ARGUMENTS_MAPPING:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+BODY_RESOLVE:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+FILE RAW TO BODY:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride2.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit|
+
+    }
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public abstract override [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit|
+
+    }
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public abstract override [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit|
+
+    }

analysis/low-level-api-fir/testdata/lazyResolve/functions/hierarchyWithOverride.kt

@@ -0,0 +1,15 @@
+interface Foo1 {
+    fun foo()
+    fun bar()
+    val str: String
+}
+
+interface Foo2 : Foo1 {
+    fun foo(i: Int)
+    fun bar(s: String)
+    val isBoo: Boolean
+}
+
+abstract class Usage : Foo2 {
+    override fun fo<caret>o() {}
+}

analysis/low-level-api-fir/testdata/lazyResolve/functions/hierarchyWithOverride.txt

@@ -0,0 +1,424 @@
+RAW_FIR:
+FILE: [ResolvedTo(RAW_FIR)] hierarchyWithOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(RAW_FIR)] class Usage : Foo2 {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            LAZY_super<<implicit>>
+        }
+
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+    }
+
+IMPORTS:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(RAW_FIR)] class Usage : Foo2 {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            LAZY_super<<implicit>>
+        }
+
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+    }
+
+COMPILER_REQUIRED_ANNOTATIONS:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(RAW_FIR)] class Usage : Foo2 {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            LAZY_super<<implicit>>
+        }
+
+        public? open? override [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+    }
+
+COMPANION_GENERATION:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(RAW_FIR)] class Usage : Foo2 {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            LAZY_super<<implicit>>
+        }
+
+        public? open? override [ResolvedTo(COMPANION_GENERATION)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+    }
+
+SUPER_TYPES:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : R|Foo1| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(SUPER_TYPES)] class Usage : R|Foo2| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            LAZY_super<<implicit>>
+        }
+
+        public? open? override [ResolvedTo(SUPER_TYPES)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+    }
+
+TYPES:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : R|Foo1| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(TYPES)] class Usage : R|Foo2| {
+        public? [ResolvedTo(TYPES)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            LAZY_super<<implicit>>
+        }
+
+        public? open? override [ResolvedTo(TYPES)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+    }
+
+STATUS:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public abstract [ResolvedTo(STATUS)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(STATUS)] fun foo([ResolvedTo(STATUS)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public abstract [ResolvedTo(STATUS)] class Usage : R|Foo2| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            LAZY_super<<implicit>>
+        }
+
+        public open override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+    }
+
+EXPECT_ACTUAL_MATCHING:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public abstract [ResolvedTo(STATUS)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(STATUS)] fun foo([ResolvedTo(STATUS)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public abstract [ResolvedTo(STATUS)] class Usage : R|Foo2| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            LAZY_super<<implicit>>
+        }
+
+        public open override [ResolvedTo(EXPECT_ACTUAL_MATCHING)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+    }
+
+ARGUMENTS_OF_ANNOTATIONS:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public abstract [ResolvedTo(STATUS)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(STATUS)] fun foo([ResolvedTo(STATUS)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public abstract [ResolvedTo(STATUS)] class Usage : R|Foo2| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            LAZY_super<<implicit>>
+        }
+
+        public open override [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+    }
+
+CONTRACTS:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public abstract [ResolvedTo(STATUS)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(STATUS)] fun foo([ResolvedTo(STATUS)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public abstract [ResolvedTo(STATUS)] class Usage : R|Foo2| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            LAZY_super<<implicit>>
+        }
+
+        public open override [ResolvedTo(CONTRACTS)] fun foo(): R|kotlin/Unit| {
+        }
+
+    }
+
+IMPLICIT_TYPES_BODY_RESOLVE:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public abstract [ResolvedTo(STATUS)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(STATUS)] fun foo([ResolvedTo(STATUS)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public abstract [ResolvedTo(STATUS)] class Usage : R|Foo2| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            LAZY_super<<implicit>>
+        }
+
+        public open override [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] fun foo(): R|kotlin/Unit| {
+        }
+
+    }
+
+ANNOTATIONS_ARGUMENTS_MAPPING:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public abstract [ResolvedTo(STATUS)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(STATUS)] fun foo([ResolvedTo(STATUS)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public abstract [ResolvedTo(STATUS)] class Usage : R|Foo2| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            LAZY_super<<implicit>>
+        }
+
+        public open override [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] fun foo(): R|kotlin/Unit| {
+        }
+
+    }
+
+BODY_RESOLVE:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public abstract [ResolvedTo(STATUS)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(STATUS)] fun foo([ResolvedTo(STATUS)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public abstract [ResolvedTo(STATUS)] class Usage : R|Foo2| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            LAZY_super<<implicit>>
+        }
+
+        public open override [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit| {
+        }
+
+    }
+
+FILE RAW TO BODY:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverride.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] val str: R|kotlin/String|
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun foo([ResolvedTo(BODY_RESOLVE)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun bar([ResolvedTo(BODY_RESOLVE)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public abstract [ResolvedTo(BODY_RESOLVE)] class Usage : R|Foo2| {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            super<R|kotlin/Any|>()
+        }
+
+        public open override [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit| {
+        }
+
+    }

analysis/low-level-api-fir/testdata/lazyResolve/functions/hierarchyWithOverrideAndNestedClass.kt

@@ -0,0 +1,37 @@
+interface Foo1 {
+    fun foo()
+    fun bar()
+    val str: String
+
+    class ClassFromInterface
+}
+
+interface Foo2 : Foo1 {
+    fun foo(i: Int)
+    fun bar(s: String)
+    val isBoo: Boolean
+}
+
+interface Foo3 : Foo1 {
+    fun foo(i: Int)
+    fun bar(s: String)
+    val isBoo: Boolean
+}
+
+abstract class OuterClass : Foo1 {
+    class SimpleNestedClass {
+        fun foo() {
+
+        }
+    }
+
+    abstract class NestedClass : Foo2 {
+        override fun fo<caret>o() {}
+    }
+
+    abstract class AnotherNestedClass : NestedClass() {
+        override fun bar(s: String) {
+
+        }
+    }
+}

analysis/low-level-api-fir/testdata/lazyResolve/functions/hierarchyWithOverrideAndNestedClass2.kt

@@ -0,0 +1,37 @@
+interface Foo1 {
+    fun foo()
+    fun bar()
+    val str: String
+
+    class ClassFromInterface
+}
+
+interface Foo2 : Foo1 {
+    fun foo(i: Int)
+    fun bar(s: String)
+    val isBoo: Boolean
+}
+
+interface Foo3 : Foo1 {
+    fun foo(i: Int)
+    fun bar(s: String)
+    val isBoo: Boolean
+}
+
+abstract class OuterClass : Foo1 {
+    class SimpleNestedClass {
+        fun foo() {
+
+        }
+    }
+
+    abstract class NestedClass : Foo2 {
+        override fun foo() {}
+    }
+
+    abstract class AnotherNestedClass : NestedClass() {
+        override fun b<caret>ar(s: String) {
+
+        }
+    }
+}

analysis/low-level-api-fir/testdata/lazyResolve/functions/hierarchyWithOverrideAndNestedClass3.kt

@@ -0,0 +1,37 @@
+interface Foo1 {
+    fun foo()
+    fun bar()
+    val str: String
+
+    class ClassFromInterface
+}
+
+interface Foo2 : Foo1 {
+    fun foo(i: Int)
+    fun bar(s: String)
+    val isBoo: Boolean
+}
+
+interface Foo3 : Foo1 {
+    fun foo(i: Int)
+    fun bar(s: String)
+    val isBoo: Boolean
+}
+
+abstract class OuterClass : Foo1 {
+    class SimpleNestedClass {
+        fun f<caret>oo() {
+
+        }
+    }
+
+    abstract class NestedClass : Foo2 {
+        override fun foo() {}
+    }
+
+    abstract class AnotherNestedClass : NestedClass() {
+        override fun bar(s: String) {
+
+        }
+    }
+}

analysis/low-level-api-fir/testdata/lazyResolve/functions/simpleLoopInOverride.kt

@@ -0,0 +1,11 @@
+interface Foo1 : Foo2 {
+    override fun f<caret>oo()
+}
+
+interface Foo2 : Foo3 {
+    override fun foo()
+}
+
+interface Foo3 : Foo1 {
+    override fun foo()
+}

analysis/low-level-api-fir/testdata/lazyResolve/functions/simpleLoopInOverride.txt

@@ -0,0 +1,223 @@
+RAW_FIR:
+FILE: [ResolvedTo(RAW_FIR)] simpleLoopInOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : Foo2 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo3 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+IMPORTS:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : Foo2 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo3 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+COMPILER_REQUIRED_ANNOTATIONS:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : Foo2 {
+        public? open? override [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo3 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+COMPANION_GENERATION:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : Foo2 {
+        public? open? override [ResolvedTo(COMPANION_GENERATION)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo3 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+SUPER_TYPES:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public? open? override [ResolvedTo(SUPER_TYPES)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+TYPES:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(TYPES)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public? open? override [ResolvedTo(TYPES)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+STATUS:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+EXPECT_ACTUAL_MATCHING:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract override [ResolvedTo(EXPECT_ACTUAL_MATCHING)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+ARGUMENTS_OF_ANNOTATIONS:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract override [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+CONTRACTS:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract override [ResolvedTo(CONTRACTS)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+IMPLICIT_TYPES_BODY_RESOLVE:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract override [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+ANNOTATIONS_ARGUMENTS_MAPPING:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract override [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+BODY_RESOLVE:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract override [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+FILE RAW TO BODY:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract override [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit|
+
+    }
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public abstract override [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit|
+
+    }
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public abstract override [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit|
+
+    }

analysis/low-level-api-fir/testdata/lazyResolve/functions/simpleLoopInOverride2.kt

@@ -0,0 +1,11 @@
+interface Foo1 : Foo2 {
+    fun f<caret>oo()
+}
+
+interface Foo2 : Foo3 {
+    override fun foo()
+}
+
+interface Foo3 : Foo1 {
+    override fun foo()
+}

analysis/low-level-api-fir/testdata/lazyResolve/functions/simpleLoopInOverride2.txt

@@ -0,0 +1,223 @@
+RAW_FIR:
+FILE: [ResolvedTo(RAW_FIR)] simpleLoopInOverride2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : Foo2 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo3 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+IMPORTS:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : Foo2 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo3 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+COMPILER_REQUIRED_ANNOTATIONS:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : Foo2 {
+        public? final? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo3 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+COMPANION_GENERATION:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : Foo2 {
+        public? final? [ResolvedTo(COMPANION_GENERATION)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo3 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+SUPER_TYPES:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public? final? [ResolvedTo(SUPER_TYPES)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+TYPES:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(TYPES)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public? final? [ResolvedTo(TYPES)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+STATUS:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+EXPECT_ACTUAL_MATCHING:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract [ResolvedTo(EXPECT_ACTUAL_MATCHING)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+ARGUMENTS_OF_ANNOTATIONS:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+CONTRACTS:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract [ResolvedTo(CONTRACTS)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+IMPLICIT_TYPES_BODY_RESOLVE:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+ANNOTATIONS_ARGUMENTS_MAPPING:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+BODY_RESOLVE:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+    }
+
+FILE RAW TO BODY:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride2.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit|
+
+    }
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public abstract override [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit|
+
+    }
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public abstract override [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit|
+
+    }

analysis/low-level-api-fir/testdata/lazyResolve/properties/hierarchyWithOverride.kt

@@ -0,0 +1,16 @@
+interface Foo1 {
+    fun foo()
+    fun bar()
+    val str: String
+}
+
+interface Foo2 : Foo1 {
+    fun foo(i: Int)
+    fun bar(s: String)
+    val isBoo: Boolean
+}
+
+abstract class Usage : Foo2 {
+    override fun foo() {}
+    override val s<caret>tr = ""
+}

analysis/low-level-api-fir/testdata/lazyResolve/properties/hierarchyWithOverride.txt

@@ -0,0 +1,462 @@
+RAW_FIR:
+FILE: [ResolvedTo(RAW_FIR)] hierarchyWithOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(RAW_FIR)] class Usage : Foo2 {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            LAZY_super<<implicit>>
+        }
+
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: <implicit> = LAZY_EXPRESSION
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Usage] get(): <implicit>
+
+    }
+
+IMPORTS:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(RAW_FIR)] class Usage : Foo2 {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            LAZY_super<<implicit>>
+        }
+
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: <implicit> = LAZY_EXPRESSION
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Usage] get(): <implicit>
+
+    }
+
+COMPILER_REQUIRED_ANNOTATIONS:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(RAW_FIR)] class Usage : Foo2 {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            LAZY_super<<implicit>>
+        }
+
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        public? open? override [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] val str: <implicit> = LAZY_EXPRESSION
+            public? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] [ContainingClassKey=Usage] get(): <implicit>
+
+    }
+
+COMPANION_GENERATION:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo1 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(RAW_FIR)] class Usage : Foo2 {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            LAZY_super<<implicit>>
+        }
+
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        public? open? override [ResolvedTo(COMPANION_GENERATION)] val str: <implicit> = LAZY_EXPRESSION
+            public? [ResolvedTo(COMPANION_GENERATION)] [ContainingClassKey=Usage] get(): <implicit>
+
+    }
+
+SUPER_TYPES:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : R|Foo1| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(SUPER_TYPES)] class Usage : R|Foo2| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            LAZY_super<<implicit>>
+        }
+
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        public? open? override [ResolvedTo(SUPER_TYPES)] val str: <implicit> = LAZY_EXPRESSION
+            public? [ResolvedTo(SUPER_TYPES)] [ContainingClassKey=Usage] get(): <implicit>
+
+    }
+
+TYPES:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo1 : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : R|Foo1| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] i: Int): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] fun bar([ResolvedTo(RAW_FIR)] s: String): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val isBoo: Boolean
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): Boolean
+
+    }
+    public? abstract [ResolvedTo(TYPES)] class Usage : R|Foo2| {
+        public? [ResolvedTo(TYPES)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            LAZY_super<<implicit>>
+        }
+
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        public? open? override [ResolvedTo(TYPES)] val str: <implicit> = LAZY_EXPRESSION
+            public? [ResolvedTo(TYPES)] [ContainingClassKey=Usage] get(): <implicit>
+
+    }
+
+STATUS:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public abstract [ResolvedTo(STATUS)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(STATUS)] fun foo([ResolvedTo(STATUS)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public abstract [ResolvedTo(STATUS)] class Usage : R|Foo2| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            LAZY_super<<implicit>>
+        }
+
+        public open override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        public open override [ResolvedTo(STATUS)] val str: <implicit> = LAZY_EXPRESSION
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Usage] get(): <implicit>
+
+    }
+
+EXPECT_ACTUAL_MATCHING:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public abstract [ResolvedTo(STATUS)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(STATUS)] fun foo([ResolvedTo(STATUS)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public abstract [ResolvedTo(STATUS)] class Usage : R|Foo2| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            LAZY_super<<implicit>>
+        }
+
+        public open override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        public open override [ResolvedTo(EXPECT_ACTUAL_MATCHING)] val str: <implicit> = LAZY_EXPRESSION
+            public [ResolvedTo(EXPECT_ACTUAL_MATCHING)] [ContainingClassKey=Usage] get(): <implicit>
+
+    }
+
+ARGUMENTS_OF_ANNOTATIONS:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public abstract [ResolvedTo(STATUS)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(STATUS)] fun foo([ResolvedTo(STATUS)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public abstract [ResolvedTo(STATUS)] class Usage : R|Foo2| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            LAZY_super<<implicit>>
+        }
+
+        public open override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        public open override [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] val str: <implicit> = LAZY_EXPRESSION
+            public [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] [ContainingClassKey=Usage] get(): <implicit>
+
+    }
+
+CONTRACTS:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public abstract [ResolvedTo(STATUS)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(STATUS)] fun foo([ResolvedTo(STATUS)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public abstract [ResolvedTo(STATUS)] class Usage : R|Foo2| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            LAZY_super<<implicit>>
+        }
+
+        public open override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        public open override [ResolvedTo(CONTRACTS)] val str: <implicit> = String()
+            public [ResolvedTo(CONTRACTS)] [ContainingClassKey=Usage] get(): <implicit>
+
+    }
+
+IMPLICIT_TYPES_BODY_RESOLVE:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public abstract [ResolvedTo(STATUS)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(STATUS)] fun foo([ResolvedTo(STATUS)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public abstract [ResolvedTo(STATUS)] class Usage : R|Foo2| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            LAZY_super<<implicit>>
+        }
+
+        public open override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        public open override [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] val str: R|kotlin/String| = String()
+            public [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] [ContainingClassKey=Usage] get(): R|kotlin/String|
+
+    }
+
+ANNOTATIONS_ARGUMENTS_MAPPING:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public abstract [ResolvedTo(STATUS)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(STATUS)] fun foo([ResolvedTo(STATUS)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public abstract [ResolvedTo(STATUS)] class Usage : R|Foo2| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            LAZY_super<<implicit>>
+        }
+
+        public open override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        public open override [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] val str: R|kotlin/String| = String()
+            public [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] [ContainingClassKey=Usage] get(): R|kotlin/String|
+
+    }
+
+BODY_RESOLVE:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public abstract [ResolvedTo(STATUS)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(STATUS)] fun foo([ResolvedTo(STATUS)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] fun bar([ResolvedTo(STATUS)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public abstract [ResolvedTo(STATUS)] class Usage : R|Foo2| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            LAZY_super<<implicit>>
+        }
+
+        public open override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+
+        public open override [ResolvedTo(BODY_RESOLVE)] val str: R|kotlin/String| = String()
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Usage] get(): R|kotlin/String|
+
+    }
+
+FILE RAW TO BODY:
+FILE: [ResolvedTo(IMPORTS)] hierarchyWithOverride.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Foo1 : R|kotlin/Any| {
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun bar(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] val str: R|kotlin/String|
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Foo2 : R|Foo1| {
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun foo([ResolvedTo(BODY_RESOLVE)] i: R|kotlin/Int|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun bar([ResolvedTo(BODY_RESOLVE)] s: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] val isBoo: R|kotlin/Boolean|
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Foo2] get(): R|kotlin/Boolean|
+
+    }
+    public abstract [ResolvedTo(BODY_RESOLVE)] class Usage : R|Foo2| {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Usage] constructor(): R|Usage| {
+            super<R|kotlin/Any|>()
+        }
+
+        public open override [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit| {
+        }
+
+        public open override [ResolvedTo(BODY_RESOLVE)] val str: R|kotlin/String| = String()
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Usage] get(): R|kotlin/String|
+
+    }

analysis/low-level-api-fir/testdata/lazyResolve/properties/hierarchyWithOverrideAndNestedClass.kt

@@ -0,0 +1,38 @@
+interface Foo1 {
+    fun foo()
+    fun bar()
+    val str: String
+
+    class ClassFromInterface
+}
+
+interface Foo2 : Foo1 {
+    fun foo(i: Int)
+    fun bar(s: String)
+    val isBoo: Boolean
+}
+
+interface Foo3 : Foo1 {
+    fun foo(i: Int)
+    fun bar(s: String)
+    val isBoo: Boolean
+}
+
+abstract class OuterClass : Foo1 {
+    val s<caret>t: String = 1
+    class SimpleNestedClass {
+        fun foo() {
+
+        }
+    }
+
+    abstract class NestedClass : Foo2 {
+        override fun foo() {}
+    }
+
+    abstract class AnotherNestedClass : NestedClass() {
+        override fun bar(s: String) {
+
+        }
+    }
+}

analysis/low-level-api-fir/testdata/lazyResolve/properties/hierarchyWithOverrideAndNestedClass2.kt

@@ -0,0 +1,38 @@
+interface Foo1 {
+    fun foo()
+    fun bar()
+    val str: String
+
+    class ClassFromInterface
+}
+
+interface Foo2 : Foo1 {
+    fun foo(i: Int)
+    fun bar(s: String)
+    val isBoo: Boolean
+}
+
+interface Foo3 : Foo1 {
+    fun foo(i: Int)
+    fun bar(s: String)
+    val isBoo: Boolean
+}
+
+abstract class OuterClass : Foo1 {
+    class SimpleNestedClass {
+        fun foo() {
+
+        }
+    }
+
+    abstract class NestedClass : Foo2 {
+        override fun foo() {}
+        override val isB<caret>oo = true
+    }
+
+    abstract class AnotherNestedClass : NestedClass() {
+        override fun bar(s: String) {
+
+        }
+    }
+}

analysis/low-level-api-fir/testdata/lazyResolve/properties/hierarchyWithOverrideAndNestedClass3.kt

@@ -0,0 +1,39 @@
+interface Foo1 {
+    fun foo()
+    fun bar()
+    val str: String
+
+    class ClassFromInterface
+}
+
+interface Foo2 : Foo1 {
+    fun foo(i: Int)
+    fun bar(s: String)
+    val isBoo: Boolean
+}
+
+interface Foo3 : Foo1 {
+    fun foo(i: Int)
+    fun bar(s: String)
+    val isBoo: Boolean
+}
+
+abstract class OuterClass : Foo1 {
+    class SimpleNestedClass {
+        fun foo() {
+
+        }
+
+        private val myPr<caret>op = 1
+    }
+
+    abstract class NestedClass : Foo2 {
+        override fun foo() {}
+    }
+
+    abstract class AnotherNestedClass : NestedClass() {
+        override fun bar(s: String) {
+
+        }
+    }
+}

analysis/low-level-api-fir/testdata/lazyResolve/properties/hierarchyWithOverrideAndNestedClass4.kt

@@ -0,0 +1,40 @@
+interface Foo1 {
+    fun foo()
+    fun bar()
+    val str: String
+
+    class ClassFromInterface
+}
+
+interface Foo2 : Foo1 {
+    fun foo(i: Int)
+    fun bar(s: String)
+    val isBoo: Boolean
+}
+
+interface Foo3 : Foo1 {
+    fun foo(i: Int)
+    fun bar(s: String)
+    val isBoo: Boolean
+}
+
+abstract class OuterClass : Foo1 {
+    class SimpleNestedClass {
+        fun foo() {
+
+        }
+    }
+
+    abstract class NestedClass : Foo2 {
+        override fun foo() {}
+        val st = ""
+    }
+
+    abstract class AnotherNestedClass : NestedClass() {
+        override fun bar(s: String) {
+
+        }
+
+        override val is<caret>Boo = false
+    }
+}

analysis/low-level-api-fir/testdata/lazyResolve/properties/simpleLoopInOverride.kt

@@ -0,0 +1,14 @@
+interface Foo1 : Foo2 {
+    override fun foo()
+    override val st<caret>r: String
+}
+
+interface Foo2 : Foo3 {
+    override fun foo()
+    override val str: String
+}
+
+interface Foo3 : Foo1 {
+    override fun foo()
+    override val str: String
+}

analysis/low-level-api-fir/testdata/lazyResolve/properties/simpleLoopInOverride.txt

@@ -0,0 +1,349 @@
+RAW_FIR:
+FILE: [ResolvedTo(RAW_FIR)] simpleLoopInOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : Foo2 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo3 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): String
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): String
+
+    }
+
+IMPORTS:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : Foo2 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo3 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): String
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): String
+
+    }
+
+COMPILER_REQUIRED_ANNOTATIONS:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : Foo2 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] val str: String
+            public? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] [ContainingClassKey=Foo1] get(): String
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo3 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): String
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): String
+
+    }
+
+COMPANION_GENERATION:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : Foo2 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(COMPANION_GENERATION)] val str: String
+            public? [ResolvedTo(COMPANION_GENERATION)] [ContainingClassKey=Foo1] get(): String
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo3 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): String
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): String
+
+    }
+
+SUPER_TYPES:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(SUPER_TYPES)] val str: String
+            public? [ResolvedTo(SUPER_TYPES)] [ContainingClassKey=Foo1] get(): String
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): String
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): String
+
+    }
+
+TYPES:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(TYPES)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(TYPES)] val str: R|kotlin/String|
+            public? [ResolvedTo(TYPES)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): String
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): String
+
+    }
+
+STATUS:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract override [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): String
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): String
+
+    }
+
+EXPECT_ACTUAL_MATCHING:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract override [ResolvedTo(EXPECT_ACTUAL_MATCHING)] val str: R|kotlin/String|
+            public [ResolvedTo(EXPECT_ACTUAL_MATCHING)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): String
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): String
+
+    }
+
+ARGUMENTS_OF_ANNOTATIONS:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract override [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] val str: R|kotlin/String|
+            public [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): String
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): String
+
+    }
+
+CONTRACTS:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract override [ResolvedTo(CONTRACTS)] val str: R|kotlin/String|
+            public [ResolvedTo(CONTRACTS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): String
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): String
+
+    }
+
+IMPLICIT_TYPES_BODY_RESOLVE:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract override [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] val str: R|kotlin/String|
+            public [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): String
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): String
+
+    }
+
+ANNOTATIONS_ARGUMENTS_MAPPING:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract override [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] val str: R|kotlin/String|
+            public [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): String
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): String
+
+    }
+
+BODY_RESOLVE:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract override [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract override [ResolvedTo(BODY_RESOLVE)] val str: R|kotlin/String|
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): String
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): String
+
+    }
+
+FILE RAW TO BODY:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract override [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit|
+
+        public abstract override [ResolvedTo(BODY_RESOLVE)] val str: R|kotlin/String|
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public abstract override [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit|
+
+        public abstract override [ResolvedTo(BODY_RESOLVE)] val str: R|kotlin/String|
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Foo2] get(): R|kotlin/String|
+
+    }
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public abstract override [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit|
+
+        public abstract override [ResolvedTo(BODY_RESOLVE)] val str: R|kotlin/String|
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Foo3] get(): R|kotlin/String|
+
+    }

analysis/low-level-api-fir/testdata/lazyResolve/properties/simpleLoopInOverride2.kt

@@ -0,0 +1,14 @@
+interface Foo1 : Foo2 {
+    fun foo()
+    val s<caret>tr: String
+}
+
+interface Foo2 : Foo3 {
+    override fun foo()
+    override val str: String
+}
+
+interface Foo3 : Foo1 {
+    override fun foo()
+    override val str: String
+}

analysis/low-level-api-fir/testdata/lazyResolve/properties/simpleLoopInOverride2.txt

@@ -0,0 +1,349 @@
+RAW_FIR:
+FILE: [ResolvedTo(RAW_FIR)] simpleLoopInOverride2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : Foo2 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo3 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): String
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): String
+
+    }
+
+IMPORTS:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : Foo2 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo1] get(): String
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo3 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): String
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): String
+
+    }
+
+COMPILER_REQUIRED_ANNOTATIONS:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : Foo2 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] val str: String
+            public? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] [ContainingClassKey=Foo1] get(): String
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo3 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): String
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): String
+
+    }
+
+COMPANION_GENERATION:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo1 : Foo2 {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(COMPANION_GENERATION)] val str: String
+            public? [ResolvedTo(COMPANION_GENERATION)] [ContainingClassKey=Foo1] get(): String
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo2 : Foo3 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): String
+
+    }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo3 : Foo1 {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): String
+
+    }
+
+SUPER_TYPES:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(SUPER_TYPES)] val str: String
+            public? [ResolvedTo(SUPER_TYPES)] [ContainingClassKey=Foo1] get(): String
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): String
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): String
+
+    }
+
+TYPES:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(TYPES)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? final? [ResolvedTo(TYPES)] val str: R|kotlin/String|
+            public? [ResolvedTo(TYPES)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): String
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): String
+
+    }
+
+STATUS:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] val str: R|kotlin/String|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): String
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): String
+
+    }
+
+EXPECT_ACTUAL_MATCHING:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(EXPECT_ACTUAL_MATCHING)] val str: R|kotlin/String|
+            public [ResolvedTo(EXPECT_ACTUAL_MATCHING)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): String
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): String
+
+    }
+
+ARGUMENTS_OF_ANNOTATIONS:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] val str: R|kotlin/String|
+            public [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): String
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): String
+
+    }
+
+CONTRACTS:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(CONTRACTS)] val str: R|kotlin/String|
+            public [ResolvedTo(CONTRACTS)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): String
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): String
+
+    }
+
+IMPLICIT_TYPES_BODY_RESOLVE:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] val str: R|kotlin/String|
+            public [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): String
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): String
+
+    }
+
+ANNOTATIONS_ARGUMENTS_MAPPING:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] val str: R|kotlin/String|
+            public [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): String
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): String
+
+    }
+
+BODY_RESOLVE:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] val str: R|kotlin/String|
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo2] get(): String
+
+    }
+    public? final? [ResolvedTo(SUPER_TYPES)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public? open? override [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit|
+
+        public? open? override [ResolvedTo(RAW_FIR)] val str: String
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo3] get(): String
+
+    }
+
+FILE RAW TO BODY:
+FILE: [ResolvedTo(IMPORTS)] simpleLoopInOverride2.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Foo1 : <ERROR TYPE REF: Loop in supertype: /Foo1 -> /Foo2> {
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] val str: R|kotlin/String|
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Foo1] get(): R|kotlin/String|
+
+    }
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Foo2 : <ERROR TYPE REF: Loop in supertype: /Foo2 -> /Foo3> {
+        public abstract override [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit|
+
+        public abstract override [ResolvedTo(BODY_RESOLVE)] val str: R|kotlin/String|
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Foo2] get(): R|kotlin/String|
+
+    }
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Foo3 : <ERROR TYPE REF: Loop in supertype: /Foo3 -> /Foo1> {
+        public abstract override [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit|
+
+        public abstract override [ResolvedTo(BODY_RESOLVE)] val str: R|kotlin/String|
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Foo3] get(): R|kotlin/String|
+
+    }