[FIR] take ready implicit unit type instead of return type calculation

and assert that symbol is not a substitution/intersection override
in the `compute` method otherwise.

Because `fakeOverrideSubstitution` should be calculated for all real
implicit types, no call to this method should actually happen.

Otherwise, it can be problematic to create a session
which would contain the full designation path:
`provider.getFirCallableContainerFile(symbol)`
returns `firFile` of a super class which might be from module `a`,
when declaration and its outer classes are from module `b`.

^KTIJ-24105

compiler/fir/analysis-tests/testData/resolve/implicitTypeIntersectionOverrideFromOtherModule.fir.txt

@@ -0,0 +1,34 @@
+Module: lib
+FILE: module_lib_implicitTypeIntersectionOverrideFromOtherModule.kt
+    package dependency
+
+    public abstract class A : R|kotlin/Any| {
+        public constructor(): R|dependency/A| {
+            super<R|kotlin/Any|>()
+        }
+
+        public abstract fun foo(): R|kotlin/Unit|
+
+    }
+    public abstract interface I : R|kotlin/Any| {
+        public abstract fun foo(): R|kotlin/Unit|
+
+    }
+Module: main
+FILE: B.kt
+    package main
+
+    public abstract class B : R|dependency/A|, R|dependency/I| {
+        public constructor(): R|main/B| {
+            super<R|dependency/A|>()
+        }
+
+    }
+    public final fun usage(b: R|main/B?|): R|kotlin/Unit| {
+        when () {
+            !=(R|<local>/b|, Null(null)) ->  {
+                R|<local>/b|.R|dependency/A.foo|()
+            }
+        }
+
+    }

compiler/fir/analysis-tests/testData/resolve/implicitTypeIntersectionOverrideFromOtherModule.kt

@@ -0,0 +1,27 @@
+// SKIP_JAVAC
+// This directive is needed to skip this test in LazyBodyIsNotTouchedTilContractsPhaseTestGenerated,
+//  because it fails to parse module structure of multimodule test
+
+// MODULE: lib
+package dependency
+
+abstract class A {
+    abstract fun foo()
+}
+interface I {
+    fun foo()
+}
+
+// MODULE: main(lib)
+// FILE: B.kt
+package main
+import dependency.A
+import dependency.I
+
+abstract class B : A(), I {}
+
+fun usage(b : B?) {
+    if (b != null) {
+        b.foo()
+    }
+}

compiler/fir/analysis-tests/testData/resolve/implicitTypeSubstituteOverrideFromOtherModule.fir.txt

@@ -0,0 +1,41 @@
+Module: lib
+FILE: module_lib_implicitTypeSubstituteOverrideFromOtherModule.kt
+    package dependency
+
+    public abstract class A<T> : R|kotlin/Any| {
+        public constructor<T>(): R|dependency/A<T>| {
+            super<R|kotlin/Any|>()
+        }
+
+        public final fun foo(): R|kotlin/String| {
+            ^foo String()
+        }
+
+    }
+Module: main
+FILE: B.kt
+    package main
+
+    public abstract class B : R|dependency/A<c/C>| {
+        public constructor(): R|main/B| {
+            super<R|dependency/A<c/C>|>()
+        }
+
+    }
+    public final fun usage(b: R|main/B?|): R|kotlin/Unit| {
+        when () {
+            !=(R|<local>/b|, Null(null)) ->  {
+                R|<local>/b|.R|SubstitutionOverride<main/B.foo: R|kotlin/String|>|()
+            }
+        }
+
+    }
+FILE: C.kt
+    package c
+
+    public final class C : R|kotlin/Any| {
+        public constructor(): R|c/C| {
+            super<R|kotlin/Any|>()
+        }
+
+    }

compiler/fir/analysis-tests/testData/resolve/implicitTypeSubstituteOverrideFromOtherModule.kt

@@ -0,0 +1,27 @@
+// SKIP_JAVAC
+// This directive is needed to skip this test in LazyBodyIsNotTouchedTilContractsPhaseTestGenerated,
+//  because it fails to parse module structure of multimodule test
+
+// MODULE: lib
+package dependency
+
+abstract class A<T> {
+    fun foo() = ""
+}
+
+// MODULE: main(lib)
+// FILE: B.kt
+package main
+import c.C
+import dependency.A
+
+abstract class B : A<C>() {}
+
+fun usage(b : B?) {
+    if (b != null) {
+        b.foo()
+    }
+}
+// FILE: C.kt
+package c
+class C

compiler/fir/analysis-tests/testData/resolve/implicitTypeSubstituteOverrideInNestedClassFromOtherModule.fir.txt

@@ -0,0 +1,48 @@
+Module: lib
+FILE: module_lib_implicitTypeSubstituteOverrideInNestedClassFromOtherModule.kt
+    package dependency
+
+    public abstract class A<T> : R|kotlin/Any| {
+        public constructor<T>(): R|dependency/A<T>| {
+            super<R|kotlin/Any|>()
+        }
+
+        public final fun foo(): R|kotlin/String| {
+            ^foo String()
+        }
+
+    }
+Module: main
+FILE: B.kt
+    package main
+
+    public final class D : R|kotlin/Any| {
+        public constructor(): R|main/D| {
+            super<R|kotlin/Any|>()
+        }
+
+        public abstract class B : R|dependency/A<c/C>| {
+            public constructor(): R|main/D.B| {
+                super<R|dependency/A<c/C>|>()
+            }
+
+        }
+
+    }
+    public final fun usage(b: R|main/D.B?|): R|kotlin/Unit| {
+        when () {
+            !=(R|<local>/b|, Null(null)) ->  {
+                R|<local>/b|.R|SubstitutionOverride<main/D.B.foo: R|kotlin/String|>|()
+            }
+        }
+
+    }
+FILE: C.kt
+    package c
+
+    public final class C : R|kotlin/Any| {
+        public constructor(): R|c/C| {
+            super<R|kotlin/Any|>()
+        }
+
+    }

compiler/fir/analysis-tests/testData/resolve/implicitTypeSubstituteOverrideInNestedClassFromOtherModule.kt

@@ -0,0 +1,29 @@
+// SKIP_JAVAC
+// This directive is needed to skip this test in LazyBodyIsNotTouchedTilContractsPhaseTestGenerated,
+//  because it fails to parse module structure of multimodule test
+
+// MODULE: lib
+package dependency
+
+abstract class A<T> {
+    fun foo() = ""
+}
+
+// MODULE: main(lib)
+// FILE: B.kt
+package main
+import c.C
+import dependency.A
+
+class D {
+    abstract class B : A<C>() {}
+}
+
+fun usage(b : D.B?) {
+    if (b != null) {
+        b.foo()
+    }
+}
+// FILE: C.kt
+package c
+class C

compiler/fir/analysis-tests/testData/resolve/unitTypeFromOtherModule.fir.txt

@@ -0,0 +1,39 @@
+Module: lib
+FILE: module_lib_unitTypeFromOtherModule.kt
+    package dependency
+
+    public abstract class A<T> : R|kotlin/Any| {
+        public constructor<T>(): R|dependency/A<T>| {
+            super<R|kotlin/Any|>()
+        }
+
+        public abstract fun foo(): R|kotlin/Unit|
+
+    }
+Module: main
+FILE: B.kt
+    package main
+
+    public abstract class B : R|dependency/A<c/C>| {
+        public constructor(): R|main/B| {
+            super<R|dependency/A<c/C>|>()
+        }
+
+    }
+    public final fun usage(b: R|main/B?|): R|kotlin/Unit| {
+        when () {
+            !=(R|<local>/b|, Null(null)) ->  {
+                R|<local>/b|.R|SubstitutionOverride<main/B.foo: R|kotlin/Unit|>|()
+            }
+        }
+
+    }
+FILE: C.kt
+    package c
+
+    public final class C : R|kotlin/Any| {
+        public constructor(): R|c/C| {
+            super<R|kotlin/Any|>()
+        }
+
+    }

compiler/fir/analysis-tests/testData/resolve/unitTypeFromOtherModule.kt

@@ -0,0 +1,27 @@
+// SKIP_JAVAC
+// This directive is needed to skip this test in LazyBodyIsNotTouchedTilContractsPhaseTestGenerated,
+//  because it fails to parse module structure of multimodule test
+
+// MODULE: lib
+package dependency
+
+abstract class A<T> {
+    abstract fun foo()
+}
+
+// MODULE: main(lib)
+// FILE: B.kt
+package main
+import c.C
+import dependency.A
+
+abstract class B : A<C>() {}
+
+fun usage(b : B?) {
+    if (b != null) {
+        b.foo()
+    }
+}
+// FILE: C.kt
+package c
+class C

compiler/fir/analysis-tests/testData/resolve/unitTypeSubstituteOverrideInNestedClassFromOtherModule.fir.txt

@@ -0,0 +1,46 @@
+Module: lib
+FILE: module_lib_unitTypeSubstituteOverrideInNestedClassFromOtherModule.kt
+    package dependency
+
+    public abstract class A<T> : R|kotlin/Any| {
+        public constructor<T>(): R|dependency/A<T>| {
+            super<R|kotlin/Any|>()
+        }
+
+        public abstract fun foo(): R|kotlin/Unit|
+
+    }
+Module: main
+FILE: B.kt
+    package main
+
+    public final class D : R|kotlin/Any| {
+        public constructor(): R|main/D| {
+            super<R|kotlin/Any|>()
+        }
+
+        public abstract class B : R|dependency/A<c/C>| {
+            public constructor(): R|main/D.B| {
+                super<R|dependency/A<c/C>|>()
+            }
+
+        }
+
+    }
+    public final fun usage(b: R|main/D.B?|): R|kotlin/Unit| {
+        when () {
+            !=(R|<local>/b|, Null(null)) ->  {
+                R|<local>/b|.R|SubstitutionOverride<main/D.B.foo: R|kotlin/Unit|>|()
+            }
+        }
+
+    }
+FILE: C.kt
+    package c
+
+    public final class C : R|kotlin/Any| {
+        public constructor(): R|c/C| {
+            super<R|kotlin/Any|>()
+        }
+
+    }

compiler/fir/analysis-tests/testData/resolve/unitTypeSubstituteOverrideInNestedClassFromOtherModule.kt

@@ -0,0 +1,29 @@
+// SKIP_JAVAC
+// This directive is needed to skip this test in LazyBodyIsNotTouchedTilContractsPhaseTestGenerated,
+//  because it fails to parse module structure of multimodule test
+
+// MODULE: lib
+package dependency
+
+abstract class A<T> {
+    abstract fun foo()
+}
+
+// MODULE: main(lib)
+// FILE: B.kt
+package main
+import c.C
+import dependency.A
+
+class D {
+    abstract class B : A<C>() {}
+}
+
+fun usage(b : D.B?) {
+    if (b != null) {
+        b.foo()
+    }
+}
+// FILE: C.kt
+package c
+class C