FIR: Fix type resolution for anonymous objects

^KT-39050 Fixed

compiler/fir/analysis-tests/testData/resolve/localClasses/typesFromSuperClasses.kt

+abstract class Outer {
+    interface Nested {
+        fun bar()
+    }
+}
+
+fun main() {
+    object : Outer() {
+        fun foo(n: Nested) {
+            n.bar()
+        }
+    }
+}
+
+class Impl : Outer() {
+    fun foo(n: Nested) {
+        n.bar()
+    }
+}

compiler/fir/analysis-tests/testData/resolve/localClasses/typesFromSuperClasses.txt

+FILE: typesFromSuperClasses.kt
+    public abstract class Outer : R|kotlin/Any| {
+        public constructor(): R|Outer| {
+            super<R|kotlin/Any|>()
+        }
+
+        public abstract interface Nested : R|kotlin/Any| {
+            public abstract fun bar(): R|kotlin/Unit|
+
+        }
+
+    }
+    public final fun main(): R|kotlin/Unit| {
+        object : R|Outer| {
+            private constructor(): R|anonymous| {
+                super<R|Outer|>()
+            }
+
+            public[local] final fun foo(n: R|Outer.Nested|): R|kotlin/Unit| {
+                R|<local>/n|.R|/Outer.Nested.bar|()
+            }
+
+        }
+
+    }
+    public final class Impl : R|Outer| {
+        public constructor(): R|Impl| {
+            super<R|Outer|>()
+        }
+
+        public final fun foo(n: R|Outer.Nested|): R|kotlin/Unit| {
+            R|<local>/n|.R|/Outer.Nested.bar|()
+        }
+
+    }

compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/FirDiagnosticsTestGenerated.java

@@ -1481,6 +1481,11 @@ public class FirDiagnosticsTestGenerated extends AbstractFirDiagnosticsTest {
         public void testImplicitInLocalClasses() throws Exception {
             runTest("compiler/fir/analysis-tests/testData/resolve/localClasses/implicitInLocalClasses.kt");
         }
+
+        @TestMetadata("typesFromSuperClasses.kt")
+        public void testTypesFromSuperClasses() throws Exception {
+            runTest("compiler/fir/analysis-tests/testData/resolve/localClasses/typesFromSuperClasses.kt");
+        }
     }
 
     @TestMetadata("compiler/fir/analysis-tests/testData/resolve/multifile")

compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/FirDiagnosticsWithLightTreeTestGenerated.java

@@ -1481,6 +1481,11 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos
         public void testImplicitInLocalClasses() throws Exception {
             runTest("compiler/fir/analysis-tests/testData/resolve/localClasses/implicitInLocalClasses.kt");
         }
+
+        @TestMetadata("typesFromSuperClasses.kt")
+        public void testTypesFromSuperClasses() throws Exception {
+            runTest("compiler/fir/analysis-tests/testData/resolve/localClasses/typesFromSuperClasses.kt");
+        }
     }
 
     @TestMetadata("compiler/fir/analysis-tests/testData/resolve/multifile")

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt

@@ -57,7 +57,6 @@ fun <F : FirClass<F>> F.runSupertypeResolvePhaseForLocalClass(
     localClassesNavigationInfo: LocalClassesNavigationInfo,
 ): F {
     val supertypeComputationSession = SupertypeComputationSession()
-    val applySupertypesTransformer = FirApplySupertypesTransformer(supertypeComputationSession)
     val supertypeResolverVisitor = FirSupertypeResolverVisitor(
         session, supertypeComputationSession, scopeSession,
         FirImmutableCompositeScope(ImmutableList.ofAll(currentScopeList)),
@@ -67,6 +66,7 @@ fun <F : FirClass<F>> F.runSupertypeResolvePhaseForLocalClass(
     this.accept(supertypeResolverVisitor)
     supertypeComputationSession.breakLoops(session)
 
+    val applySupertypesTransformer = FirApplySupertypesTransformer(supertypeComputationSession)
     return this.transform<F, Nothing?>(applySupertypesTransformer, null).single
 }
 
@@ -84,15 +84,25 @@ private class FirApplySupertypesTransformer(
     }
 
     override fun transformRegularClass(regularClass: FirRegularClass, data: Nothing?): CompositeTransformResult<FirStatement> {
-        if (regularClass.superTypeRefs.any { it !is FirResolvedTypeRef }) {
-            val supertypeRefs = getResolvedSupertypeRefs(regularClass)
+        applyResolvedSupertypesToClass(regularClass)
+
+        return (regularClass.transformChildren(this, null) as FirRegularClass).compose()
+    }
+
+    private fun applyResolvedSupertypesToClass(firClass: FirClass<*>) {
+        if (firClass.superTypeRefs.any { it !is FirResolvedTypeRef }) {
+            val supertypeRefs = getResolvedSupertypeRefs(firClass)
 
             // TODO: Replace with an immutable version or transformer
-            regularClass.replaceSuperTypeRefs(supertypeRefs)
-            regularClass.replaceResolvePhase(FirResolvePhase.SUPER_TYPES)
+            firClass.replaceSuperTypeRefs(supertypeRefs)
+            firClass.replaceResolvePhase(FirResolvePhase.SUPER_TYPES)
         }
+    }
 
-        return (regularClass.transformChildren(this, null) as FirRegularClass).compose()
+    override fun transformAnonymousObject(anonymousObject: FirAnonymousObject, data: Nothing?): CompositeTransformResult<FirStatement> {
+        applyResolvedSupertypesToClass(anonymousObject)
+
+        return super.transformAnonymousObject(anonymousObject, data)
     }
 
     private fun getResolvedSupertypeRefs(classLikeDeclaration: FirClassLikeDeclaration<*>): List<FirTypeRef> {
@@ -253,6 +263,11 @@ private class FirSupertypeResolverVisitor(
         regularClass.acceptChildren(this)
     }
 
+    override fun visitAnonymousObject(anonymousObject: FirAnonymousObject) {
+        resolveSpecificClassLikeSupertypes(anonymousObject, anonymousObject.superTypeRefs)
+        anonymousObject.acceptChildren(this)
+    }
+
     fun resolveSpecificClassLikeSupertypes(
         classLikeDeclaration: FirClassLikeDeclaration<*>,
         supertypeRefs: List<FirTypeRef>