K2: build outer classes sequence in FirImplicitBodyResolve properly

Before this commit, we used classId-based methods which didn't work
correctly on local classes / objects, thus provoking exceptions.
Now we use lookupTag-based methods which don't have such problems.

#KT-67993 Fixed

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt

@@ -19,6 +19,7 @@ import org.jetbrains.kotlin.fir.resolve.FirRegularTowerDataContexts
 import org.jetbrains.kotlin.fir.resolve.ResolutionMode
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.providers.firProvider
+import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.resolve.transformers.AdapterForResolveProcessor
 import org.jetbrains.kotlin.fir.resolve.transformers.FirTransformerBasedResolveProcessor
 import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculator
@@ -311,9 +312,10 @@ open class ReturnTypeCalculatorWithJump(
             val file = provider.getFirCallableContainerFile(symbol)
             val script = file?.declarations?.firstIsInstanceOrNull<FirScript>()
 
-            val outerClasses = generateSequence(symbol.containingClassLookupTag()?.classId) { classId ->
-                classId.outerClassId
-            }.mapTo(mutableListOf()) { provider.getFirClassifierByFqName(it) }
+            val containingClassLookupTag = symbol.containingClassLookupTag()
+            val outerClasses = generateSequence(containingClassLookupTag) { lookupTag ->
+                lookupTag.toSymbol(session)?.getContainingClassLookupTag()
+            }.mapTo(mutableListOf()) { it.toSymbol(session)?.fir }
 
             if (file == null || outerClasses.any { it == null }) {
                 return buildErrorTypeRef {

compiler/testData/codegen/box/builderInference/issues/kt67993.kt

@@ -0,0 +1,32 @@
+// ISSUE: KT-67993
+// IGNORE_REVERSED_RESOLVE
+// IGNORE_NON_REVERSED_RESOLVE
+// Reason: see KT-68031
+
+class Builder<T> {
+    var res: T? = null
+
+    fun add(x: T) {
+        res = x
+    }
+}
+
+fun <T> foo(build: Builder<T>.() -> Unit): T {
+    return Builder<T>().apply(build).res!!
+}
+
+class C {
+    val a = foo {
+        object {
+            fun bar() {
+                add(foo())
+            }
+
+            private fun foo() = "OK"
+        }.bar()
+    }
+}
+
+fun box(): String {
+    return C().a
+}

compiler/testData/diagnostics/tests/builderInference/issues/kt67993.kt

@@ -0,0 +1,25 @@
+// FIR_IDENTICAL
+// ISSUE: KT-67993
+// IGNORE_REVERSED_RESOLVE
+// IGNORE_NON_REVERSED_RESOLVE
+// Reason: see KT-68031
+
+class Builder<T> {
+    fun add(x: T) {}
+}
+
+fun <T> foo(build: Builder<T>.() -> Unit) {
+    Builder<T>().apply(build)
+}
+
+class C {
+    val a = foo {
+        object {
+            fun bar() {
+                add(foo())
+            }
+
+            private fun foo() = "..."
+        }
+    }
+}