FIR override resolve: lookup also interfaces

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

@@ -29,8 +29,11 @@ abstract class FirAbstractTreeTransformerWithSuperTypes(reversedScopePriority: B
         return result
     }
 
-    protected fun lookupSuperTypes(klass: FirRegularClass): List<ConeClassLikeType> {
+    protected fun lookupSuperTypes(klass: FirRegularClass, lookupInterfaces: Boolean): List<ConeClassLikeType> {
-        return mutableListOf<ConeClassLikeType>().also { klass.symbol.collectSuperTypes(it) }
+        return mutableListOf<ConeClassLikeType>().also {
+            if (lookupInterfaces) klass.symbol.collectSuperTypes(it)
+            else klass.symbol.collectSuperClasses(it)
+        }
     }
 
     private tailrec fun ConeClassLikeType.computePartialExpansion(): ConeClassLikeType? {
@@ -40,7 +43,7 @@ abstract class FirAbstractTreeTransformerWithSuperTypes(reversedScopePriority: B
         }
     }
 
-    private tailrec fun ConeClassLikeSymbol.collectSuperTypes(list: MutableList<ConeClassLikeType>) {
+    private tailrec fun ConeClassLikeSymbol.collectSuperClasses(list: MutableList<ConeClassLikeType>) {
         when (this) {
             is ConeClassSymbol -> {
                 val superClassType =
@@ -50,7 +53,27 @@ abstract class FirAbstractTreeTransformerWithSuperTypes(reversedScopePriority: B
                             it !is ConeClassErrorType && (it?.symbol as? ConeClassSymbol)?.kind == ClassKind.CLASS
                         } ?: return
                 list += superClassType
-                superClassType.symbol.collectSuperTypes(list)
+                superClassType.symbol.collectSuperClasses(list)
+            }
+            is ConeTypeAliasSymbol -> {
+                val expansion = expansionType?.computePartialExpansion() ?: return
+                expansion.symbol.collectSuperClasses(list)
+            }
+            else -> error("?!id:1")
+        }
+    }
+
+    private fun ConeClassLikeSymbol.collectSuperTypes(list: MutableList<ConeClassLikeType>) {
+        when (this) {
+            is ConeClassSymbol -> {
+                val superClassTypes =
+                    this.superTypes.mapNotNull { it.computePartialExpansion() }
+                list += superClassTypes
+                superClassTypes.forEach {
+                    if (it !is ConeClassErrorType) {
+                        it.symbol.collectSuperTypes(list)
+                    }
+                }
             }
             is ConeTypeAliasSymbol -> {
                 val expansion = expansionType?.computePartialExpansion() ?: return

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

@@ -12,16 +12,12 @@ import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
 import org.jetbrains.kotlin.fir.references.FirResolvedCallableReferenceImpl
-import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider
 import org.jetbrains.kotlin.fir.scopes.FirPosition
 import org.jetbrains.kotlin.fir.scopes.impl.FirClassDeclaredMemberScope
 import org.jetbrains.kotlin.fir.scopes.impl.FirTopLevelDeclaredMemberScope
 import org.jetbrains.kotlin.fir.symbols.ConeCallableSymbol
-import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol
-import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
-import org.jetbrains.kotlin.fir.types.impl.ConeAbbreviatedTypeImpl
+import org.jetbrains.kotlin.fir.types.ConeClassErrorType
-import org.jetbrains.kotlin.fir.types.impl.ConeClassTypeImpl
 import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
 import org.jetbrains.kotlin.fir.visitors.compose
 
@@ -37,8 +33,9 @@ class FirAccessResolveTransformer : FirAbstractTreeTransformerWithSuperTypes(rev
     override fun transformRegularClass(regularClass: FirRegularClass, data: Nothing?): CompositeTransformResult<FirDeclaration> {
         return withScopeCleanup {
             val useSiteSession = regularClass.session
-            lookupSuperTypes(regularClass).asReversed()
+            lookupSuperTypes(regularClass, lookupInterfaces = true).asReversed()
                 .mapNotNullTo(towerScope.scopes) { useSiteSuperType ->
+                    if (useSiteSuperType is ConeClassErrorType) return@mapNotNullTo null
                     val symbol = useSiteSuperType.symbol
                     if (symbol is FirClassSymbol) {
                         FirClassDeclaredMemberScope(symbol.fir, useSiteSession)

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

@@ -63,7 +63,7 @@ open class FirTypeResolveTransformer(
         return withScopeCleanup {
             val firProvider = FirProvider.getInstance(regularClass.session)
             val classId = regularClass.symbol.classId
-            lookupSuperTypes(regularClass).asReversed().mapTo(towerScope.scopes) {
+            lookupSuperTypes(regularClass, lookupInterfaces = false).asReversed().mapTo(towerScope.scopes) {
                 val symbol = it.symbol
                 if (symbol is FirBasedSymbol<*>) {
                     FirNestedClassifierScope(symbol.classId, FirProvider.getInstance(symbol.fir.session))

idea/testData/fir/multiModule/mppSuperTypes/jvm/jvm.kt

@@ -13,9 +13,8 @@ actual open class A : X(), Y {
 class C : B() {
     fun test() {
         foo()
-        // This cannot be resolved yet due to lack of search symbols / projections
+        // This and next cannot be resolved yet due to lack of search symbols / projections
         bar()
-        // This cannot be resolved yet due to lack of interface lookup
         baz()
     }
 }
@@ -24,7 +23,6 @@ class D : A() {
     fun test() {
         foo()
         bar()
-        // This cannot be resolved yet due to lack of interface lookup
         baz()
     }
 }

idea/testData/fir/multiModule/mppSuperTypes/jvm/jvm.txt

@@ -34,7 +34,7 @@ FILE: jvm.kt
         public final function test(): R|kotlin/Unit| {
             R|/A.foo|()
             R|/X.bar|()
-            <Unresolved name: baz>#()
+            R|/Y.baz|()
         }
 
     }