[FIR IDE] Use proper FirSessions in FirSupertypesResolution

Symbols might be from other modules, so we need to use corresponding
`FirSession`s; otherwise it would be impossible to query symbols
from `firProvider`

^KTIJ-21714 Fixed

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

@@ -0,0 +1,34 @@
+Module: lib
+FILE: module_lib_inherentlyImportedTypeFromOtherModule.kt
+    package dependency
+
+    public abstract class Test : R|kotlin/Any| {
+        public constructor(): R|dependency/Test| {
+            super<R|kotlin/Any|>()
+        }
+
+        public abstract interface Result : R|kotlin/Any| {
+        }
+
+        public final class Success : R|dependency/Test.Result| {
+            public constructor(): R|dependency/Test.Success| {
+                super<R|kotlin/Any|>()
+            }
+
+        }
+
+    }
+Module: main
+FILE: module_main_inherentlyImportedTypeFromOtherModule.kt
+    package main
+
+    public final class Main : R|dependency/Test| {
+        public constructor(): R|main/Main| {
+            super<R|dependency/Test|>()
+        }
+
+        public final fun usage(): R|dependency/Test.Result| {
+            ^usage R|dependency/Test.Success.Success|()
+        }
+
+    }

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

@@ -0,0 +1,24 @@
+// 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 Test {
+    interface Result
+
+    class Success : Result
+}
+
+
+// MODULE: main(lib)
+package main
+
+import dependency.Test
+
+class Main : Test() {
+    fun usage(): Result {
+        return Success()
+    }
+}

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

@@ -0,0 +1,46 @@
+Module: lib
+FILE: module_lib_inherentlyImportedTypeFromOtherModule2.kt
+    package lib
+
+    public abstract class FirstBase : R|kotlin/Any| {
+        public constructor(): R|lib/FirstBase| {
+            super<R|kotlin/Any|>()
+        }
+
+        public abstract interface Result : R|kotlin/Any| {
+        }
+
+    }
+    public abstract class SecondBase : R|lib/FirstBase| {
+        public constructor(): R|lib/SecondBase| {
+            super<R|lib/FirstBase|>()
+        }
+
+    }
+    public abstract class Test : R|lib/SecondBase| {
+        public constructor(): R|lib/Test| {
+            super<R|lib/SecondBase|>()
+        }
+
+        public final class Success : R|lib/FirstBase.Result| {
+            public constructor(): R|lib/Test.Success| {
+                super<R|kotlin/Any|>()
+            }
+
+        }
+
+    }
+Module: main
+FILE: module_main_inherentlyImportedTypeFromOtherModule2.kt
+    package main
+
+    public final class Main : R|lib/Test| {
+        public constructor(): R|main/Main| {
+            super<R|lib/Test|>()
+        }
+
+        public final fun usage(): R|lib/FirstBase.Result| {
+            ^usage R|lib/Test.Success.Success|()
+        }
+
+    }

compiler/fir/analysis-tests/testData/resolve/inherentlyImportedTypeFromOtherModule2.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 lib
+
+abstract class FirstBase {
+    interface Result
+}
+
+abstract class SecondBase : FirstBase()
+
+abstract class Test : SecondBase() {
+    class Success : Result
+}
+
+// MODULE: main(lib)
+package main
+
+import lib.Test
+
+class Main : Test() {
+    fun usage(): Result {
+        return Success()
+    }
+}

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

@@ -0,0 +1,50 @@
+Module: lib1
+FILE: module_lib1_inherentlyImportedTypeFromOtherModule3.kt
+    package lib1
+
+    public abstract class FirstBase : R|kotlin/Any| {
+        public constructor(): R|lib1/FirstBase| {
+            super<R|kotlin/Any|>()
+        }
+
+        public abstract interface Result : R|kotlin/Any| {
+        }
+
+    }
+    public abstract class SecondBase : R|lib1/FirstBase| {
+        public constructor(): R|lib1/SecondBase| {
+            super<R|lib1/FirstBase|>()
+        }
+
+    }
+Module: lib2
+FILE: module_lib2_inherentlyImportedTypeFromOtherModule3.kt
+    package lib2
+
+    public abstract class Test : R|lib1/SecondBase| {
+        public constructor(): R|lib2/Test| {
+            super<R|lib1/SecondBase|>()
+        }
+
+        public final class Success : R|lib1/FirstBase.Result| {
+            public constructor(): R|lib2/Test.Success| {
+                super<R|kotlin/Any|>()
+            }
+
+        }
+
+    }
+Module: main
+FILE: module_main_inherentlyImportedTypeFromOtherModule3.kt
+    package main
+
+    public final class Main : R|lib2/Test| {
+        public constructor(): R|main/Main| {
+            super<R|lib2/Test|>()
+        }
+
+        public final fun usage(): R|lib1/FirstBase.Result| {
+            ^usage R|lib2/Test.Success.Success|()
+        }
+
+    }

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

@@ -0,0 +1,32 @@
+// SKIP_JAVAC
+// This directive is needed to skip this test in LazyBodyIsNotTouchedTilContractsPhaseTestGenerated,
+//  because it fails to parse module structure of multimodule test
+
+// MODULE: lib1
+package lib1
+
+abstract class FirstBase {
+    interface Result
+}
+
+abstract class SecondBase : FirstBase()
+
+// MODULE: lib2(lib1)
+package lib2
+
+import lib1.SecondBase
+
+abstract class Test : SecondBase() {
+    class Success : Result
+}
+
+// MODULE: main(lib1, lib2)
+package main
+
+import lib2.Test
+
+class Main : Test() {
+    fun usage(): Result {
+        return Success()
+    }
+}