diff --git a/compiler/fir/analysis-tests/testData/resolve/typeParameterVsNested.kt b/compiler/fir/analysis-tests/testData/resolve/typeParameterVsNested.kt
index cfa08ca9bf9..e8bc2326708 100644
--- a/compiler/fir/analysis-tests/testData/resolve/typeParameterVsNested.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/typeParameterVsNested.kt
@@ -9,9 +9,9 @@ abstract class My<T : Some> {
 
     abstract fun foo(arg: T)
 
-    abstract val y: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>My.T<!>
+    abstract val y: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>My<!>.T
 
-    abstract val z: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>test.My.T<!>
+    abstract val z: test.<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>My<!>.T
 
     class Some : <!SUPERTYPE_NOT_A_CLASS_OR_INTERFACE, UNRESOLVED_REFERENCE!>T<!>()
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/types/capturedParametersOfInnerClasses.kt b/compiler/fir/analysis-tests/testData/resolve/types/capturedParametersOfInnerClasses.kt
index 87bfbb31db0..5367402bf99 100644
--- a/compiler/fir/analysis-tests/testData/resolve/types/capturedParametersOfInnerClasses.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/types/capturedParametersOfInnerClasses.kt
@@ -10,4 +10,4 @@ class A<T1, T2> {
 
 fun <R1, R2, R3> foo(c: A<R1, R1>.B<R2, R2>.C<R3, R3>) {}
 
-fun <R3> foo(c: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A.B.C<R3, R3><!>) {}
+fun <R3> foo(c: A.<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>B<!>.C<R3, R3>) {}
diff --git a/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt b/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt
index e00a9cd1cbf..c2d91c82f94 100644
--- a/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt
+++ b/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt
@@ -446,14 +446,14 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
         val TYPE_ARGUMENTS_NOT_ALLOWED by error<PsiElement>()
         val WRONG_NUMBER_OF_TYPE_ARGUMENTS by error<PsiElement> {
             parameter<Int>("expectedCount")
-            parameter<FirClassLikeSymbol<*>>("classifier")
+            parameter<FirRegularClassSymbol>("classifier")
         }
         val NO_TYPE_ARGUMENTS_ON_RHS by error<PsiElement> {
             parameter<Int>("expectedCount")
             parameter<FirClassLikeSymbol<*>>("classifier")
         }
-        val OUTER_CLASS_ARGUMENTS_REQUIRED by error<PsiElement>() {
-            parameter<FirRegularClass>("outer")
+        val OUTER_CLASS_ARGUMENTS_REQUIRED by error<PsiElement> {
+            parameter<FirRegularClassSymbol>("outer")
         }
         val TYPE_PARAMETERS_IN_OBJECT by error<PsiElement>()
         val ILLEGAL_PROJECTION_USAGE by error<PsiElement>()
diff --git a/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt
index 1960dd208fa..3e02df8d04a 100644
--- a/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt
+++ b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt
@@ -295,9 +295,9 @@ object FirErrors {
     val UPPER_BOUND_VIOLATED by error2<PsiElement, ConeKotlinType, ConeKotlinType>()
     val UPPER_BOUND_VIOLATED_IN_TYPEALIAS_EXPANSION by error2<PsiElement, ConeKotlinType, ConeKotlinType>()
     val TYPE_ARGUMENTS_NOT_ALLOWED by error0<PsiElement>()
-    val WRONG_NUMBER_OF_TYPE_ARGUMENTS by error2<PsiElement, Int, FirClassLikeSymbol<*>>()
+    val WRONG_NUMBER_OF_TYPE_ARGUMENTS by error2<PsiElement, Int, FirRegularClassSymbol>()
     val NO_TYPE_ARGUMENTS_ON_RHS by error2<PsiElement, Int, FirClassLikeSymbol<*>>()
-    val OUTER_CLASS_ARGUMENTS_REQUIRED by error1<PsiElement, FirRegularClass>()
+    val OUTER_CLASS_ARGUMENTS_REQUIRED by error1<PsiElement, FirRegularClassSymbol>()
     val TYPE_PARAMETERS_IN_OBJECT by error0<PsiElement>()
     val ILLEGAL_PROJECTION_USAGE by error0<PsiElement>()
     val TYPE_PARAMETERS_IN_ENUM by error0<PsiElement>()
diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOuterClassArgumentsRequiredChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOuterClassArgumentsRequiredChecker.kt
index c6475e64af2..5af5f4390eb 100644
--- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOuterClassArgumentsRequiredChecker.kt
+++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOuterClassArgumentsRequiredChecker.kt
@@ -8,14 +8,12 @@ package org.jetbrains.kotlin.fir.analysis.checkers.declaration
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.context.findClosest
 import org.jetbrains.kotlin.fir.analysis.checkers.extractArgumentTypeRefAndSource
+import org.jetbrains.kotlin.fir.analysis.checkers.getContainingClassSymbol
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
-import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRef
-import org.jetbrains.kotlin.fir.declarations.FirTypedDeclaration
-import org.jetbrains.kotlin.fir.resolve.getClassThatContainsTypeParameter
-import org.jetbrains.kotlin.fir.resolve.isValidTypeParameter
+import org.jetbrains.kotlin.fir.resolve.isValidTypeParameterFromOuterClass
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.resolve.toTypeProjections
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
@@ -23,15 +21,10 @@ import org.jetbrains.kotlin.fir.types.*
 
 object FirOuterClassArgumentsRequiredChecker : FirRegularClassChecker() {
     override fun check(declaration: FirRegularClass, context: CheckerContext, reporter: DiagnosticReporter) {
+        // Checking the rest super types that weren't resolved on the first OUTER_CLASS_ARGUMENTS_REQUIRED check in FirTypeResolver
         for (superTypeRef in declaration.superTypeRefs) {
             checkOuterClassArgumentsRequired(superTypeRef, declaration, context, reporter)
         }
-
-        for (subDecl in declaration.declarations) {
-            if (subDecl is FirTypedDeclaration) {
-                checkOuterClassArgumentsRequired(subDecl.returnTypeRef, declaration, context, reporter)
-            }
-        }
     }
 }
 
@@ -41,65 +34,29 @@ private fun checkOuterClassArgumentsRequired(
     context: CheckerContext,
     reporter: DiagnosticReporter
 ) {
-    val type: ConeKotlinType
+    if (typeRef !is FirResolvedTypeRef || typeRef is FirErrorTypeRef) {
+        return
+    }
 
-    if (typeRef is FirResolvedTypeRef) {
-        if (typeRef is FirErrorTypeRef) {
-            return
-        }
+    val type: ConeKotlinType = typeRef.type
+    val delegatedTypeRef = typeRef.delegatedTypeRef
 
-        type = typeRef.type
-        val delegatedTypeRef = typeRef.delegatedTypeRef
+    if (delegatedTypeRef is FirUserTypeRef && type is ConeClassLikeType) {
+        val symbol = type.lookupTag.toSymbol(context.session)
 
-        if (delegatedTypeRef is FirUserTypeRef) {
+        if (symbol is FirRegularClassSymbol) {
+            val typeArguments = delegatedTypeRef.qualifier.toTypeProjections()
+            val typeParameters = symbol.typeParameterSymbols
 
-            if (type is ConeClassLikeType) {
-                val symbol = type.lookupTag.toSymbol(context.session)
-
-                if (symbol is FirRegularClassSymbol) {
-                    var problemTypeParameter: FirTypeParameterRef? = null
-                    val typeArguments = delegatedTypeRef.qualifier.toTypeProjections()
-                    val argumentsFromOuterClassesAndParentsCount = symbol.fir.typeParameters.drop(typeArguments.size).sumOf {
-                        val result = if (isValidTypeParameter(it, declaration, context.session)) {
-                            1
-                        } else {
-                            if (problemTypeParameter == null) {
-                                problemTypeParameter = it
-                            }
-                            0
-                        }
-                        return@sumOf result
-                    }
-                    val finalTypeArgumentsCount = typeArguments.size + argumentsFromOuterClassesAndParentsCount
-
-                    if (finalTypeArgumentsCount != symbol.fir.typeParameters.size) {
-                        val source = typeRef.source
-                        if (problemTypeParameter != null) {
-                            var outerClass: FirRegularClass? = null
-                            context.findClosest<FirRegularClass> {
-                                outerClass = getClassThatContainsTypeParameter(it, problemTypeParameter!!)
-                                return@findClosest outerClass != null
-                            }
-                            if (outerClass != null) {
-                                reporter.reportOn(source, FirErrors.OUTER_CLASS_ARGUMENTS_REQUIRED, outerClass!!, context)
-                            }
-                        } else {
-                            reporter.reportOn(
-                                source,
-                                FirErrors.WRONG_NUMBER_OF_TYPE_ARGUMENTS,
-                                symbol.fir.typeParameters.size - argumentsFromOuterClassesAndParentsCount,
-                                symbol,
-                                context
-                            )
-                        }
-                    }
+            for (index in typeArguments.size until typeParameters.size) {
+                val typeParameter = typeParameters[index]
+                if (!isValidTypeParameterFromOuterClass(typeParameter, declaration, context.session)) {
+                    val outerClass = typeParameter.containingDeclarationSymbol as FirRegularClassSymbol
+                    reporter.reportOn(typeRef.source, FirErrors.OUTER_CLASS_ARGUMENTS_REQUIRED, outerClass, context)
+                    break
                 }
             }
         }
-    } else if (typeRef is ConeKotlinType) {
-        type = typeRef
-    } else {
-        return
     }
 
     for (index in type.typeArguments.indices) {
diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDefaultErrorMessages.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDefaultErrorMessages.kt
index 8adc13bcbe4..7e08b6b08c9 100644
--- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDefaultErrorMessages.kt
+++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDefaultErrorMessages.kt
@@ -717,7 +717,7 @@ class FirDefaultErrorMessages {
                 WRONG_NUMBER_OF_TYPE_ARGUMENTS,
                 "{0,choice,0#No type arguments|1#One type argument|1<{0,number,integer} type arguments} expected for {1}",
                 null,
-                SYMBOL
+                RENDER_CLASS_OR_OBJECT_NAME
             )
             map.put(
                 OUTER_CLASS_ARGUMENTS_REQUIRED,
diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDiagnosticRenderers.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDiagnosticRenderers.kt
index e097f284588..97094359202 100644
--- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDiagnosticRenderers.kt
+++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDiagnosticRenderers.kt
@@ -15,6 +15,7 @@ import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.*
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.resolve.dfa.cfg.isLocalClassOrAnonymousObject
+import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.firUnsafe
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.SymbolInternals
 import org.jetbrains.kotlin.fir.symbols.impl.*
@@ -80,17 +81,17 @@ object FirDiagnosticRenderers {
         "$classOrObject $name"
     }
 
-    val RENDER_CLASS_OR_OBJECT_NAME = Renderer { firClassLike: FirClassLikeDeclaration ->
+    val RENDER_CLASS_OR_OBJECT_NAME = Renderer { firClassLike: FirClassLikeSymbol<*> ->
         val name = firClassLike.classId.relativeClassName.shortName().asString()
         val prefix = when (firClassLike) {
-            is FirTypeAlias -> "typealias"
-            is FirRegularClass -> {
+            is FirTypeAliasSymbol -> "typealias"
+            is FirRegularClassSymbol -> {
                 when {
                     firClassLike.isCompanion -> "companion object"
                     firClassLike.isInterface -> "interface"
                     firClassLike.isEnumClass -> "enum class"
                     firClassLike.isFromEnumClass -> "enum entry"
-                    firClassLike.isLocalClassOrAnonymousObject() -> "object"
+                    firClassLike.isLocalClassOrAnonymousObject -> "object"
                     else -> "class"
                 }
             }
diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/coneDiagnosticToFirDiagnostic.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/coneDiagnosticToFirDiagnostic.kt
index 6babbf24959..08388b9ff99 100644
--- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/coneDiagnosticToFirDiagnostic.kt
+++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/coneDiagnosticToFirDiagnostic.kt
@@ -68,9 +68,9 @@ private fun ConeDiagnostic.toFirDiagnostic(
     is ConeUnexpectedTypeArgumentsError -> FirErrors.TYPE_ARGUMENTS_NOT_ALLOWED.createOn(this.source ?: source)
     is ConeIllegalAnnotationError -> FirErrors.NOT_AN_ANNOTATION_CLASS.createOn(source, this.name.asString())
     is ConeWrongNumberOfTypeArgumentsError ->
-        FirErrors.WRONG_NUMBER_OF_TYPE_ARGUMENTS.createOn(qualifiedAccessSource ?: source, this.desiredCount, this.type)
+        FirErrors.WRONG_NUMBER_OF_TYPE_ARGUMENTS.createOn(this.source ?: qualifiedAccessSource ?: source, this.desiredCount, this.symbol)
     is ConeOuterClassArgumentsRequired ->
-        FirErrors.OUTER_CLASS_ARGUMENTS_REQUIRED.createOn(qualifiedAccessSource ?: source, this.type)
+        FirErrors.OUTER_CLASS_ARGUMENTS_REQUIRED.createOn(qualifiedAccessSource ?: source, this.symbol)
     is ConeNoTypeArgumentsOnRhsError ->
         FirErrors.NO_TYPE_ARGUMENTS_ON_RHS.createOn(qualifiedAccessSource ?: source, this.desiredCount, this.type)
     is ConeSimpleDiagnostic -> when (source.kind) {
diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirTypeResolver.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirTypeResolver.kt
index 39f0ae62261..0ee7432c7e4 100644
--- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirTypeResolver.kt
+++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirTypeResolver.kt
@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.fir.resolve
 
 import org.jetbrains.kotlin.fir.FirSessionComponent
 import org.jetbrains.kotlin.fir.resolve.transformers.ScopeClassDeclaration
-import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 
diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt
index d2c85a31291..25638dd61df 100644
--- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt
+++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt
@@ -13,6 +13,7 @@ import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.impl.FirOuterClassTypeParameterRef
 import org.jetbrains.kotlin.fir.declarations.utils.expandedConeType
+import org.jetbrains.kotlin.fir.declarations.utils.isInner
 import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
 import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
 import org.jetbrains.kotlin.fir.diagnostics.ConeStubDiagnostic
@@ -31,6 +32,7 @@ import org.jetbrains.kotlin.fir.resolve.inference.inferenceComponents
 import org.jetbrains.kotlin.fir.resolve.inference.isBuiltinFunctionalType
 import org.jetbrains.kotlin.fir.resolve.providers.getSymbolByTypeRef
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.resultType
+import org.jetbrains.kotlin.fir.resolve.transformers.firClassLike
 import org.jetbrains.kotlin.fir.symbols.ensureResolved
 import org.jetbrains.kotlin.fir.scopes.impl.delegatedWrapperData
 import org.jetbrains.kotlin.fir.scopes.impl.importedFromObjectData
@@ -449,14 +451,17 @@ fun FirFunction.getAsForbiddenNamedArgumentsTarget(session: FirSession): Forbidd
 //  org.jetbrains.kotlin.fir.serialization.FirElementSerializer.constructorProto
 fun FirFunction.getHasStableParameterNames(session: FirSession): Boolean = getAsForbiddenNamedArgumentsTarget(session) == null
 
-fun isValidTypeParameter(typeParameter: FirTypeParameterRef, classDeclaration: FirRegularClass?, session: FirSession): Boolean {
-    if (typeParameter !is FirOuterClassTypeParameterRef || classDeclaration == null) {
-        return true
+fun isValidTypeParameterFromOuterClass(
+    typeParameterSymbol: FirTypeParameterSymbol,
+    classDeclaration: FirRegularClass?,
+    session: FirSession
+): Boolean {
+    if (classDeclaration == null) {
+        return true  // Extra check is required because of classDeclaration will be resolved later
     }
 
     fun containsTypeParameter(currentClassDeclaration: FirRegularClass): Boolean {
-        val result = currentClassDeclaration.typeParameters.any { it.symbol == typeParameter.symbol }
-        if (result) {
+        if (currentClassDeclaration.typeParameters.any { it.symbol == typeParameterSymbol }) {
             return true
         }
 
@@ -473,19 +478,29 @@ fun isValidTypeParameter(typeParameter: FirTypeParameterRef, classDeclaration: F
     return containsTypeParameter(classDeclaration)
 }
 
-fun getClassThatContainsTypeParameter(klass: FirRegularClass, typeParameter: FirTypeParameterRef): FirRegularClass? {
-    if (klass.typeParameters.any { param -> param.symbol == typeParameter.symbol }) {
-        return klass
+fun getOuterClassAndActualTypeParametersCount(klass: FirRegularClass, session: FirSession): Pair<FirRegularClass?, Int> {
+    var result = klass.typeParameters.size
+
+    if (!klass.isInner) {
+        return Pair(null, result)
     }
 
-    for (declaration in klass.declarations) {
-        if (declaration is FirRegularClass) {
-            val result = getClassThatContainsTypeParameter(declaration, typeParameter)
-            if (result != null) {
-                return result
-            }
-        }
+    val outerClass = getOuterClass(klass, session)
+    if (outerClass != null) {
+        result -= outerClass.typeParameters.size
+    }
+
+    return Pair(outerClass, result)
+}
+
+fun getOuterClass(klass: FirRegularClass, session: FirSession): FirRegularClass? {
+    val classId = klass.symbol.classId
+    val parentId = classId.relativeClassName.parent()
+    if (!parentId.isRoot) {
+        val outerClassId = ClassId(classId.packageFqName, parentId, false)
+        val parentSymbol = session.symbolProvider.getClassLikeSymbolByFqName(outerClassId)
+        return (parentSymbol as? FirRegularClassSymbol)?.fir
     }
 
     return null
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/diagnostics/FirDiagnostics.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/diagnostics/FirDiagnostics.kt
index 82468946a00..1d0749cef72 100644
--- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/diagnostics/FirDiagnostics.kt
+++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/diagnostics/FirDiagnostics.kt
@@ -6,16 +6,14 @@
 package org.jetbrains.kotlin.fir.resolve.diagnostics
 
 import kotlinx.collections.immutable.ImmutableList
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.resolve.calls.Candidate
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.name.ClassId
@@ -101,9 +99,10 @@ class ConeIllegalAnnotationError(val name: Name) : ConeDiagnostic() {
 abstract class ConeUnmatchedTypeArgumentsError(val desiredCount: Int, val type: FirClassLikeSymbol<*>) : ConeDiagnostic()
 
 class ConeWrongNumberOfTypeArgumentsError(
-    desiredCount: Int,
-    type: FirClassLikeSymbol<*>
-) : ConeUnmatchedTypeArgumentsError(desiredCount, type) {
+    val desiredCount: Int,
+    val symbol: FirRegularClassSymbol,
+    val source: FirSourceElement?
+) : ConeDiagnostic() {
     override val reason: String get() = "Wrong number of type arguments"
 }
 
@@ -115,7 +114,7 @@ class ConeNoTypeArgumentsOnRhsError(
 }
 
 class ConeOuterClassArgumentsRequired(
-    val type: FirRegularClass,
+    val symbol: FirRegularClassSymbol,
 ) : ConeDiagnostic() {
     override val reason: String = "Type arguments should be specified for an outer class"
 }
diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirTypeResolverImpl.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirTypeResolverImpl.kt
index 79e52810f6a..82561a26e0a 100644
--- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirTypeResolverImpl.kt
+++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirTypeResolverImpl.kt
@@ -6,12 +6,11 @@
 package org.jetbrains.kotlin.fir.resolve.providers.impl
 
 import org.jetbrains.kotlin.builtins.StandardNames
-import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.ThreadSafeMutableState
-import org.jetbrains.kotlin.fir.declarations.FirRegularClass
-import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRef
+import org.jetbrains.kotlin.fir.*
+import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.impl.FirOuterClassTypeParameterRef
+import org.jetbrains.kotlin.fir.declarations.utils.classId
 import org.jetbrains.kotlin.fir.diagnostics.ConeUnexpectedTypeArgumentsError
-import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.resolve.*
 import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeOuterClassArgumentsRequired
 import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeUnresolvedQualifierError
@@ -19,6 +18,7 @@ import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeUnsupportedDynamicType
 import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeWrongNumberOfTypeArgumentsError
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.resolve.transformers.ScopeClassDeclaration
+import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterLookupTag
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.*
@@ -48,7 +48,7 @@ class FirTypeResolverImpl(private val session: FirSession) : FirTypeResolver() {
 
     private fun resolveToSymbol(
         typeRef: FirTypeRef,
-        scopeClassDeclaration: ScopeClassDeclaration
+        scope: FirScope,
     ): Pair<FirClassifierSymbol<*>?, ConeSubstitutor?> {
         return when (typeRef) {
             is FirResolvedTypeRef -> {
@@ -60,7 +60,7 @@ class FirTypeResolverImpl(private val session: FirSession) : FirTypeResolver() {
                 val qualifierResolver = session.qualifierResolver
                 var resolvedSymbol: FirClassifierSymbol<*>? = null
                 var substitutor: ConeSubstitutor? = null
-                scopeClassDeclaration.scope.processClassifiersByNameWithSubstitution(typeRef.qualifier.first().name) { symbol, substitutorFromScope ->
+                scope.processClassifiersByNameWithSubstitution(typeRef.qualifier.first().name) { symbol, substitutorFromScope ->
                     if (resolvedSymbol != null) return@processClassifiersByNameWithSubstitution
                     resolvedSymbol = when (symbol) {
                         is FirClassLikeSymbol<*> -> {
@@ -97,7 +97,7 @@ class FirTypeResolverImpl(private val session: FirSession) : FirTypeResolver() {
         symbol: FirClassifierSymbol<*>?,
         substitutor: ConeSubstitutor?,
         areBareTypesAllowed: Boolean,
-        scopeClassDeclaration: ScopeClassDeclaration
+        topDeclaration: FirRegularClass?
     ): ConeKotlinType {
         if (symbol == null) {
             return ConeKotlinErrorType(ConeUnresolvedQualifierError(typeRef.render()))
@@ -111,57 +111,78 @@ class FirTypeResolverImpl(private val session: FirSession) : FirTypeResolver() {
                 }
             }
         }
-        var typeArguments = typeRef.qualifier.toTypeProjections()
-        if (symbol is FirRegularClassSymbol) {
-            val isPossibleBareType = areBareTypesAllowed && typeArguments.isEmpty()
-            if (typeArguments.size != symbol.fir.typeParameters.size && !isPossibleBareType) {
-                @Suppress("NAME_SHADOWING")
-                if (symbol.fir.typeParameters.size < typeArguments.size) {
-                    return ConeClassErrorType(ConeWrongNumberOfTypeArgumentsError(symbol.fir.typeParameters.size, symbol))
-                } else {
-                    val substitutor = substitutor ?: ConeSubstitutor.Empty
-                    var problemTypeParameter: FirTypeParameterRef? = null
-                    val classDeclarations = scopeClassDeclaration.classDeclarations
-                    val argumentsFromOuterClassesAndParents = symbol.fir.typeParameters.drop(typeArguments.size).mapNotNull {
-                        if (isValidTypeParameter(it, classDeclarations.lastOrNull(), session)) {
-                            val type = ConeTypeParameterTypeImpl(ConeTypeParameterLookupTag(it.symbol), isNullable = false)
-                            // we should report ConeSimpleDiagnostic(..., WrongNumberOfTypeArguments)
-                            // but genericArgumentNumberMismatch.kt test fails with
-                            // index out of bounds exception for start offset of
-                            // the source
-                            substitutor.substituteOrNull(type)
-                        } else {
-                            if (problemTypeParameter == null) {
-                                problemTypeParameter = it
-                            }
-                            null
-                        }
-                    }.toTypedArray<ConeTypeProjection>()
-                    typeArguments += argumentsFromOuterClassesAndParents
 
-                    if (typeArguments.size != symbol.fir.typeParameters.size) {
-                        if (problemTypeParameter != null) {
-                            var outerClass: FirRegularClass? = null
-                            classDeclarations.forEach {
-                                getClassThatContainsTypeParameter(it, problemTypeParameter!!)?.let { result ->
-                                    outerClass = result
-                                    return@forEach
-                                }
-                            }
-                            return ConeClassErrorType(ConeOuterClassArgumentsRequired(outerClass!!))
+        val allTypeArguments = mutableListOf<ConeTypeProjection>()
+        var typeArgumentsCount = 0
+
+        val qualifier = typeRef.qualifier
+        for (qualifierIndex in qualifier.size - 1 downTo 0) {
+            val qualifierTypeArguments = qualifier[qualifierIndex].typeArgumentList.typeArguments
+
+            for (qualifierTypeArgument in qualifierTypeArguments) {
+                allTypeArguments.add(qualifierTypeArgument.toConeTypeProjection())
+                typeArgumentsCount++
+            }
+        }
+
+        if (symbol is FirRegularClassSymbol) {
+            val isPossibleBareType = areBareTypesAllowed && allTypeArguments.isEmpty()
+            if (!isPossibleBareType) {
+                val actualSubstitutor = substitutor ?: ConeSubstitutor.Empty
+                val typeParameters = symbol.fir.typeParameters
+
+                val (typeParametersAlignedToQualifierParts, outerClasses) = getClassesAlignedToQualifierParts(symbol, qualifier, session)
+
+                for ((index, typeParameter) in typeParameters.withIndex()) {
+                    val (parameterClass, qualifierPartIndex) = typeParametersAlignedToQualifierParts[typeParameter.symbol] ?: continue
+
+                    if (index < typeArgumentsCount) {
+                        // Check if type argument matches type parameter in respective qualifier part
+                        val qualifierPartArgumentsCount = qualifier[qualifierPartIndex].typeArgumentList.typeArguments.size
+                        createDiagnosticsIfExists(
+                            parameterClass,
+                            qualifierPartIndex,
+                            symbol,
+                            typeRef,
+                            qualifierPartArgumentsCount
+                        )?.let { return it }
+                        continue
+                    }
+
+                    if (typeParameter !is FirOuterClassTypeParameterRef ||
+                        isValidTypeParameterFromOuterClass(typeParameter.symbol, topDeclaration, session)
+                    ) {
+                        val type = ConeTypeParameterTypeImpl(ConeTypeParameterLookupTag(typeParameter.symbol), isNullable = false)
+                        val substituted = actualSubstitutor.substituteOrNull(type)
+                        if (substituted == null) {
+                            createDiagnosticsIfExists(parameterClass, qualifierPartIndex, symbol, typeRef)?.let { return it }
                         } else {
-                            return ConeClassErrorType(
-                                ConeWrongNumberOfTypeArgumentsError(
-                                    desiredCount = symbol.fir.typeParameters.size - argumentsFromOuterClassesAndParents.size,
-                                    type = symbol
-                                )
-                            )
+                            allTypeArguments.add(substituted)
+                        }
+                    } else {
+                        return ConeClassErrorType(ConeOuterClassArgumentsRequired(parameterClass.symbol))
+                    }
+                }
+
+                // Check rest type arguments
+                if (typeArgumentsCount > typeParameters.size) {
+                    for (index in qualifier.indices) {
+                        if (qualifier[index].typeArgumentList.typeArguments.isNotEmpty()) {
+                            val parameterClass = outerClasses.elementAtOrNull(index)
+                            createDiagnosticsIfExists(
+                                parameterClass,
+                                index,
+                                symbol,
+                                typeRef,
+                                ignoreOuterClassCheck = true
+                            )?.let { return it }
                         }
                     }
                 }
             }
         }
-        return symbol.constructType(typeArguments, typeRef.isMarkedNullable, typeRef.annotations.computeTypeAttributes())
+
+        return symbol.constructType(allTypeArguments.toTypedArray(), typeRef.isMarkedNullable, typeRef.annotations.computeTypeAttributes())
             .also {
                 val lookupTag = it.lookupTag
                 if (lookupTag is ConeClassLikeLookupTagImpl && symbol is FirClassLikeSymbol<*>) {
@@ -170,6 +191,102 @@ class FirTypeResolverImpl(private val session: FirSession) : FirTypeResolver() {
             }
     }
 
+    private fun getClassesAlignedToQualifierParts(
+        symbol: FirRegularClassSymbol,
+        qualifier: List<FirQualifierPart>,
+        session: FirSession
+    ): ParametersMapAndOuterClasses {
+        var currentClass: FirRegularClass? = null
+        val outerClasses = mutableListOf<FirRegularClass?>()
+
+        // Try to get at least qualifier.size classes that match qualifier parts
+        var qualifierPartIndex = 0
+        while (qualifierPartIndex < qualifier.size || currentClass != null) {
+            if (qualifierPartIndex == 0) {
+                currentClass = symbol.fir
+            } else {
+                if (currentClass != null) {
+                    currentClass = getOuterClass(currentClass, session)
+                }
+            }
+
+            outerClasses.add(currentClass)
+            qualifierPartIndex++
+        }
+
+        val outerArgumentsCount = outerClasses.size - qualifier.size
+        val reversedOuterClasses = outerClasses.asReversed()
+        val result = mutableMapOf<FirTypeParameterSymbol, ClassWithQualifierPartIndex>()
+
+        for (index in reversedOuterClasses.indices) {
+            currentClass = reversedOuterClasses[index]
+            if (currentClass != null) {
+                for (typeParameter in currentClass.typeParameters) {
+                    val typeParameterSymbol = typeParameter.symbol
+                    if (!result.containsKey(typeParameterSymbol)) {
+                        result[typeParameterSymbol] = ClassWithQualifierPartIndex(currentClass, index - outerArgumentsCount)
+                    }
+                }
+            }
+        }
+
+        return ParametersMapAndOuterClasses(result, reversedOuterClasses.drop(outerArgumentsCount))
+    }
+
+    private data class ParametersMapAndOuterClasses(
+        val parameters: Map<FirTypeParameterSymbol, ClassWithQualifierPartIndex>,
+        val outerClasses: List<FirRegularClass?>
+    )
+
+    private data class ClassWithQualifierPartIndex(
+        val klass: FirRegularClass,
+        val index: Int
+    )
+
+    private fun createDiagnosticsIfExists(
+        parameterClass: FirRegularClass?,
+        qualifierPartIndex: Int,
+        symbol: FirRegularClassSymbol,
+        userTypeRef: FirUserTypeRef,
+        qualifierPartArgumentsCount: Int? = null,
+        ignoreOuterClassCheck: Boolean = false
+    ): ConeClassErrorType? {
+        // TODO: It should be TYPE_ARGUMENTS_NOT_ALLOWED diagnostics when parameterClass is null
+        val (outerClass, actualTypeParametersCount) = getOuterClassAndActualTypeParametersCount(
+            parameterClass ?: symbol.fir,
+            session
+        )
+
+        if (qualifierPartArgumentsCount == null || actualTypeParametersCount != qualifierPartArgumentsCount) {
+            // TODO: fix obtaining outer class for cases like
+            //  https://github.com/JetBrains/kotlin/blob/master/compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesLocal.kt#L16
+            if (ignoreOuterClassCheck ||
+                (parameterClass != null && parameterClass.classId.relativeClassName.parent().isRoot)
+                || outerClass != null
+            ) {
+                return ConeClassErrorType(
+                    ConeWrongNumberOfTypeArgumentsError(
+                        actualTypeParametersCount,
+                        parameterClass?.symbol ?: symbol,
+                        getTypeArgumentsOrNameSource(userTypeRef, qualifierPartIndex)
+                    )
+                )
+            }
+        }
+
+        return null
+    }
+
+    private fun getTypeArgumentsOrNameSource(typeRef: FirUserTypeRef, qualifierIndex: Int?): FirSourceElement? {
+        val qualifierPart = if (qualifierIndex != null) typeRef.qualifier.elementAtOrNull(qualifierIndex) else null
+        val typeArgumentsList = qualifierPart?.typeArgumentList
+        return if (typeArgumentsList == null || typeArgumentsList.typeArguments.isEmpty()) {
+            qualifierPart?.source ?: typeRef.source
+        } else {
+            typeArgumentsList.source
+        }
+    }
+
     private fun createFunctionalType(typeRef: FirFunctionTypeRef): ConeClassLikeType {
         val parameters =
             listOfNotNull(typeRef.receiverTypeRef?.coneType) +
@@ -202,8 +319,8 @@ class FirTypeResolverImpl(private val session: FirSession) : FirTypeResolver() {
         return when (typeRef) {
             is FirResolvedTypeRef -> typeRef.type
             is FirUserTypeRef -> {
-                val (symbol, substitutor) = resolveToSymbol(typeRef, scopeClassDeclaration)
-                resolveUserType(typeRef, symbol, substitutor, areBareTypesAllowed, scopeClassDeclaration)
+                val (symbol, substitutor) = resolveToSymbol(typeRef, scopeClassDeclaration.scope)
+                resolveUserType(typeRef, symbol, substitutor, areBareTypesAllowed, scopeClassDeclaration.topDeclaration)
             }
             is FirFunctionTypeRef -> createFunctionalType(typeRef)
             is FirDynamicTypeRef -> ConeKotlinErrorType(ConeUnsupportedDynamicType())
diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractTreeTransformerWithSuperTypes.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractTreeTransformerWithSuperTypes.kt
index 67cf4bbcc54..0232c06e1eb 100644
--- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractTreeTransformerWithSuperTypes.kt
+++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractTreeTransformerWithSuperTypes.kt
@@ -30,7 +30,7 @@ abstract class FirAbstractTreeTransformerWithSuperTypes(
     protected val scopeSession: ScopeSession
 ) : FirAbstractTreeTransformer<Any?>(phase) {
     protected val scopes = mutableListOf<FirScope>()
-    protected val classDeclarations = mutableListOf<FirRegularClass>()
+    protected val classDeclarationsStack = ArrayDeque<FirRegularClass>()
     protected val towerScope = FirCompositeScope(scopes.asReversed())
 
     protected open fun needReplacePhase(firDeclaration: FirDeclaration): Boolean = transformerPhase > firDeclaration.resolvePhase
@@ -47,10 +47,9 @@ abstract class FirAbstractTreeTransformerWithSuperTypes(
     }
 
     protected inline fun <T> withClassDeclarationCleanup(declaration: FirRegularClass, crossinline l: () -> T): T {
-        classDeclarations.add(declaration)
-        val result = l()
-        classDeclarations.removeAt(classDeclarations.lastIndex)
-        return result
+        withClassDeclarationCleanup(classDeclarationsStack, declaration) {
+            return l()
+        }
     }
 
     protected fun resolveNestedClassesSupertypes(
diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSpecificTypeResolverTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSpecificTypeResolverTransformer.kt
index ec2622ca5ef..80a20de6481 100644
--- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSpecificTypeResolverTransformer.kt
+++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSpecificTypeResolverTransformer.kt
@@ -11,7 +11,6 @@ import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
 import org.jetbrains.kotlin.fir.diagnostics.ConeUnexpectedTypeArgumentsError
 import org.jetbrains.kotlin.fir.resolve.typeResolver
-import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.builder.buildErrorTypeRef
 import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt
index f23052d2694..1cc46c8c50c 100644
--- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt
+++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt
@@ -215,7 +215,7 @@ open class FirSupertypeResolverVisitor(
     private val firProviderInterceptor: FirProviderInterceptor? = null,
 ) : FirDefaultVisitor<Unit, Any?>() {
     private val supertypeGenerationExtensions = session.extensionService.supertypeGenerators
-    private val classDeclarations = mutableListOf<FirRegularClass>()
+    private val classDeclarationsStack = ArrayDeque<FirRegularClass>()
 
     private fun getFirClassifierContainerFileIfAny(symbol: FirClassLikeSymbol<*>): FirFile? =
         if (firProviderInterceptor != null) firProviderInterceptor.getFirClassifierContainerFileIfAny(symbol)
@@ -309,7 +309,10 @@ open class FirSupertypeResolverVisitor(
         val scopes = prepareScopes(classLikeDeclaration)
 
         val transformer = FirSpecificTypeResolverTransformer(session)
-        val resolvedTypesRefs = resolveSuperTypeRefs(transformer, ScopeClassDeclaration(FirCompositeScope(scopes), classDeclarations))
+        val resolvedTypesRefs = resolveSuperTypeRefs(
+            transformer,
+            ScopeClassDeclaration(FirCompositeScope(scopes), classDeclarationsStack.lastOrNull())
+        )
 
         supertypeComputationSession.storeSupertypes(classLikeDeclaration, resolvedTypesRefs)
         return resolvedTypesRefs
@@ -320,10 +323,10 @@ open class FirSupertypeResolverVisitor(
     }
 
     override fun visitRegularClass(regularClass: FirRegularClass, data: Any?) {
-        classDeclarations.add(regularClass)
-        resolveSpecificClassLikeSupertypes(regularClass, regularClass.superTypeRefs)
-        visitDeclarationContent(regularClass, null)
-        classDeclarations.removeAt(classDeclarations.lastIndex)
+        withClassDeclarationCleanup(classDeclarationsStack, regularClass) {
+            resolveSpecificClassLikeSupertypes(regularClass, regularClass.superTypeRefs)
+            visitDeclarationContent(regularClass, null)
+        }
     }
 
     override fun visitAnonymousObject(anonymousObject: FirAnonymousObject, data: Any?) {
diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeResolveTransformer.kt
index d95b1713640..13a8c393aaf 100644
--- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeResolveTransformer.kt
+++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeResolveTransformer.kt
@@ -190,7 +190,7 @@ open class FirTypeResolveTransformer(
         return typeResolverTransformer.withFile(currentFile) {
             typeRef.transform(
                 typeResolverTransformer,
-                ScopeClassDeclaration(towerScope, classDeclarations)
+                ScopeClassDeclaration(towerScope, classDeclarationsStack.lastOrNull())
             )
         }
     }
diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ScopeClassDeclaration.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ScopeClassDeclaration.kt
index 58d90ea50f6..0e055cd98a4 100644
--- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ScopeClassDeclaration.kt
+++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ScopeClassDeclaration.kt
@@ -8,5 +8,7 @@ package org.jetbrains.kotlin.fir.resolve.transformers
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.scopes.FirScope
 
-data class ScopeClassDeclaration(val scope: FirScope, val classDeclarations: List<FirRegularClass>) {
-}
\ No newline at end of file
+data class ScopeClassDeclaration(
+    val scope: FirScope,
+    val topDeclaration: FirRegularClass?
+)
\ No newline at end of file
diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/TransformUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/TransformUtils.kt
index c5718751af9..03725fa6dba 100644
--- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/TransformUtils.kt
+++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/TransformUtils.kt
@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir.resolve.transformers
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
 import org.jetbrains.kotlin.fir.copyWithNewSourceKind
+import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.FirTypedDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.expressions.FirExpression
@@ -132,3 +133,16 @@ inline fun <T> withScopeCleanup(scopes: MutableList<*>, l: () -> T): T {
         }
     }
 }
+
+inline fun <T> withClassDeclarationCleanup(
+    classDeclarations: ArrayDeque<FirRegularClass>,
+    topClassDeclaration: FirRegularClass,
+    l: () -> T
+): T {
+    classDeclarations.addLast(topClassDeclaration)
+    return try {
+        l()
+    } finally {
+        classDeclarations.removeLast()
+    }
+}
diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/BodyResolveContext.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/BodyResolveContext.kt
index 9db9bad0697..15512d5ffae 100644
--- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/BodyResolveContext.kt
+++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/BodyResolveContext.kt
@@ -87,13 +87,17 @@ class BodyResolveContext(
 
     val anonymousFunctionsAnalyzedInDependentContext: MutableSet<FirFunctionSymbol<*>> = mutableSetOf()
 
+    var containingClassDeclarations: ArrayDeque<FirRegularClass> = ArrayDeque()
+
+    val topClassDeclaration: FirRegularClass?
+        get() = containingClassDeclarations.lastOrNull()
+
     private inline fun <T> withNewTowerDataForClassParts(newContexts: FirTowerDataContextsForClassParts, f: () -> T): T {
         val old = towerDataContextsForClassParts
         towerDataContextsForClassParts = newContexts
         return try {
             f()
         } finally {
-
             towerDataContextsForClassParts = old
         }
     }
@@ -130,6 +134,15 @@ class BodyResolveContext(
         }
     }
 
+    inline fun <T> withContainingClass(declaration: FirRegularClass, f: () -> T): T {
+        containingClassDeclarations.add(declaration)
+        return try {
+            f()
+        } finally {
+            containingClassDeclarations.removeLast()
+        }
+    }
+
     @PrivateForInline
     inline fun <R> withTowerDataCleanup(l: () -> R): R {
         val initialContext = towerDataContext
diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformer.kt
index f433501694e..da0163f1d82 100644
--- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformer.kt
+++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformer.kt
@@ -15,10 +15,7 @@ import org.jetbrains.kotlin.fir.resolve.ResolutionMode
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.calls.ResolutionContext
 import org.jetbrains.kotlin.fir.resolve.dfa.DataFlowAnalyzerContext
-import org.jetbrains.kotlin.fir.resolve.transformers.FirProviderInterceptor
-import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculator
-import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculatorForFullBodyResolve
-import org.jetbrains.kotlin.fir.resolve.transformers.ScopeClassDeclaration
+import org.jetbrains.kotlin.fir.resolve.transformers.*
 import org.jetbrains.kotlin.fir.scopes.FirCompositeScope
 import org.jetbrains.kotlin.fir.scopes.impl.createCurrentScopeList
 import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
@@ -47,7 +44,6 @@ open class FirBodyResolveTransformer(
     internal open val expressionsTransformer = FirExpressionsResolveTransformer(this)
     protected open val declarationsTransformer = FirDeclarationsResolveTransformer(this)
     private val controlFlowStatementsTransformer = FirControlFlowStatementsResolveTransformer(this)
-    private val classDeclarations = mutableListOf<FirRegularClass>()
 
     override fun transformFile(file: FirFile, data: ResolutionMode): FirFile {
         checkSessionConsistency(file)
@@ -70,7 +66,13 @@ open class FirBodyResolveTransformer(
             typeRef
         } else {
             typeResolverTransformer.withFile(context.file) {
-                transformTypeRef(typeRef, ScopeClassDeclaration(FirCompositeScope(components.createCurrentScopeList()), classDeclarations))
+                transformTypeRef(
+                    typeRef,
+                    ScopeClassDeclaration(
+                        FirCompositeScope(components.createCurrentScopeList()),
+                        context.topClassDeclaration
+                    )
+                )
             }
         }
         return resolvedTypeRef.transformAnnotations(this, data)
@@ -263,10 +265,7 @@ open class FirBodyResolveTransformer(
     }
 
     override fun transformRegularClass(regularClass: FirRegularClass, data: ResolutionMode): FirStatement {
-        classDeclarations.add(regularClass)
-        val result = declarationsTransformer.transformRegularClass(regularClass, data)
-        classDeclarations.removeAt(classDeclarations.lastIndex)
-        return result
+        return declarationsTransformer.transformRegularClass(regularClass, data)
     }
 
     override fun transformAnonymousObject(
diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt
index 17ce9e2c442..c2cec2fc6bc 100644
--- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt
+++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt
@@ -356,18 +356,20 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
     }
 
     override fun transformRegularClass(regularClass: FirRegularClass, data: ResolutionMode): FirStatement {
-        if (regularClass.isLocal && regularClass !in context.targetedLocalClasses) {
-            return regularClass.runAllPhasesForLocalClass(
-                transformer,
-                components,
-                data,
-                transformer.firTowerDataContextCollector,
-                transformer.firProviderInterceptor
-            )
-        }
+        context.withContainingClass(regularClass) {
+            if (regularClass.isLocal && regularClass !in context.targetedLocalClasses) {
+                return regularClass.runAllPhasesForLocalClass(
+                    transformer,
+                    components,
+                    data,
+                    transformer.firTowerDataContextCollector,
+                    transformer.firProviderInterceptor
+                )
+            }
 
-        doTransformTypeParameters(regularClass)
-        return doTransformRegularClass(regularClass, data)
+            doTransformTypeParameters(regularClass)
+            return doTransformRegularClass(regularClass, data)
+        }
     }
 
     override fun transformTypeAlias(typeAlias: FirTypeAlias, data: ResolutionMode): FirTypeAlias {
diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirPluginAnnotationsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirPluginAnnotationsResolveTransformer.kt
index 1496f6440c7..7b39215f54b 100644
--- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirPluginAnnotationsResolveTransformer.kt
+++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirPluginAnnotationsResolveTransformer.kt
@@ -90,7 +90,7 @@ private class FirAnnotationResolveTransformer(
     )
 
     private var owners: PersistentList<FirAnnotatedDeclaration> = persistentListOf()
-    protected val classDeclarations = mutableListOf<FirRegularClass>()
+    private val classDeclarationsStack = ArrayDeque<FirRegularClass>()
 
     override fun beforeChildren(declaration: FirAnnotatedDeclaration): PersistentList<FirAnnotatedDeclaration> {
         val current = owners
@@ -107,24 +107,26 @@ private class FirAnnotationResolveTransformer(
         annotationCall: FirAnnotationCall,
         data: Multimap<AnnotationFqn, FirRegularClass>
     ): FirStatement {
-        return annotationCall.transformAnnotationTypeRef(typeResolverTransformer, ScopeClassDeclaration(scope, listOf()))
+        return annotationCall.transformAnnotationTypeRef(
+            typeResolverTransformer,
+            ScopeClassDeclaration(scope, classDeclarationsStack.lastOrNull())
+        )
     }
 
     override fun transformRegularClass(
         regularClass: FirRegularClass,
         data: Multimap<AnnotationFqn, FirRegularClass>
     ): FirStatement {
-        classDeclarations.add(regularClass)
-        val result = super.transformRegularClass(regularClass, data).also {
-            if (regularClass.classKind == ClassKind.ANNOTATION_CLASS && metaAnnotations.isNotEmpty()) {
-                val annotations = regularClass.annotations.mapNotNull { it.fqName(session) }
-                for (annotation in annotations.filter { it in metaAnnotations }) {
-                    data.put(annotation, regularClass)
+        withClassDeclarationCleanup(classDeclarationsStack, classDeclarationsStack.last()) {
+            return super.transformRegularClass(regularClass, data).also {
+                if (regularClass.classKind == ClassKind.ANNOTATION_CLASS && metaAnnotations.isNotEmpty()) {
+                    val annotations = regularClass.annotations.mapNotNull { it.fqName(session) }
+                    for (annotation in annotations.filter { it in metaAnnotations }) {
+                        data.put(annotation, regularClass)
+                    }
                 }
             }
         }
-        classDeclarations.removeAt(classDeclarations.lastIndex)
-        return result
     }
 
     override fun transformAnnotatedDeclaration(
diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/utils/FirSymbolStatusUtils.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/utils/FirSymbolStatusUtils.kt
index 7980dcb72f5..fdc48860c05 100644
--- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/utils/FirSymbolStatusUtils.kt
+++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/utils/FirSymbolStatusUtils.kt
@@ -6,10 +6,6 @@
 package org.jetbrains.kotlin.fir.declarations.utils
 
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.fir.FirRenderer
-import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.render
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
 import org.jetbrains.kotlin.fir.symbols.impl.*
 
 // ---------------------- callables with status ----------------------
@@ -108,6 +104,9 @@ inline val FirTypeAliasSymbol.isFun: Boolean get() = resolvedStatus.isFun
 
 inline val FirClassLikeSymbol<*>.isLocal: Boolean get() = classId.isLocal
 
+inline val FirClassSymbol<*>.isLocalClassOrAnonymousObject: Boolean
+    get() = classId.isLocal || this is FirAnonymousObjectSymbol
+
 inline val FirClassSymbol<*>.isInterface: Boolean
     get() = classKind.isInterface
 
diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirTypeParameterSymbol.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirTypeParameterSymbol.kt
index 1f81b7d051e..387214f5db2 100644
--- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirTypeParameterSymbol.kt
+++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirTypeParameterSymbol.kt
@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir.symbols.impl
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
 import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterLookupTag
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.ensureResolved
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
 import org.jetbrains.kotlin.name.Name
@@ -35,5 +36,8 @@ class FirTypeParameterSymbol : FirClassifierSymbol<FirTypeParameter>() {
 
     val isReified: Boolean
         get() = fir.isReified
+
+    val containingDeclarationSymbol: FirBasedSymbol<*>?
+        get() = fir.containingDeclarationSymbol
 }
 
diff --git a/compiler/testData/diagnostics/tests/Unresolved.fir.kt b/compiler/testData/diagnostics/tests/Unresolved.fir.kt
index 99eb21fab03..3d3385e9ada 100644
--- a/compiler/testData/diagnostics/tests/Unresolved.fir.kt
+++ b/compiler/testData/diagnostics/tests/Unresolved.fir.kt
@@ -3,7 +3,7 @@ package unresolved
 class Pair<A, B>(val a: A, val b: B)
 
 fun testGenericArgumentsCount() {
-    val p1: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Pair<Int><!> = Pair(2, 2)
+    val p1: Pair<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><Int><!> = Pair(2, 2)
     val p2: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Pair<!> = Pair(2, 2)
 }
 
diff --git a/compiler/testData/diagnostics/tests/declarationChecks/finiteBoundRestriction/CasesWithOneTypeParameter.fir.kt b/compiler/testData/diagnostics/tests/declarationChecks/finiteBoundRestriction/CasesWithOneTypeParameter.fir.kt
index c81a78a162c..6c844042dee 100644
--- a/compiler/testData/diagnostics/tests/declarationChecks/finiteBoundRestriction/CasesWithOneTypeParameter.fir.kt
+++ b/compiler/testData/diagnostics/tests/declarationChecks/finiteBoundRestriction/CasesWithOneTypeParameter.fir.kt
@@ -1,8 +1,7 @@
 interface A0<T : A0<T>>
 interface A1<T : A1<*>>
 interface A2<T : A2<out T>>
-// StackOverflowError
-//interface A3<T : A3<in T>>
+interface A3<T : A3<in T>>
 interface A4<T : A4<*>?>
 
 interface B0<T : B1<*>>
@@ -11,7 +10,7 @@ interface B1<T : B0<*>>
 interface AA<T: AA<*>>
 interface BB<S : List<AA<*>>>
 
-interface A<T: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>List<T, T, T><!>>
+interface A<T: List<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><T, T, T><!>>
 
 class X<Y>
-class D<T : X<in X<out X<T>>>>
\ No newline at end of file
+class D<T : X<in X<out X<T>>>>
diff --git a/compiler/testData/diagnostics/tests/declarationChecks/finiteBoundRestriction/CasesWithOneTypeParameter.kt b/compiler/testData/diagnostics/tests/declarationChecks/finiteBoundRestriction/CasesWithOneTypeParameter.kt
index ee06ecb1f27..c08d999365c 100644
--- a/compiler/testData/diagnostics/tests/declarationChecks/finiteBoundRestriction/CasesWithOneTypeParameter.kt
+++ b/compiler/testData/diagnostics/tests/declarationChecks/finiteBoundRestriction/CasesWithOneTypeParameter.kt
@@ -1,8 +1,7 @@
 interface A0<T : A0<T>>
 interface A1<<!FINITE_BOUNDS_VIOLATION!>T : A1<*><!>>
 interface A2<<!FINITE_BOUNDS_VIOLATION!>T : A2<out T><!>>
-// StackOverflowError
-//interface A3<T : A3<in T>>
+interface A3<<!FINITE_BOUNDS_VIOLATION!>T : A3<in T><!>>
 interface A4<<!FINITE_BOUNDS_VIOLATION!>T : A4<*>?<!>>
 
 interface B0<<!FINITE_BOUNDS_VIOLATION!>T : B1<*><!>>
@@ -14,4 +13,4 @@ interface BB<S : List<AA<*>>>
 interface A<T: List<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><T, T, T><!>>
 
 class X<Y>
-class D<T : X<in X<out X<T>>>>
\ No newline at end of file
+class D<T : X<in X<out X<T>>>>
diff --git a/compiler/testData/diagnostics/tests/declarationChecks/finiteBoundRestriction/CasesWithOneTypeParameter.txt b/compiler/testData/diagnostics/tests/declarationChecks/finiteBoundRestriction/CasesWithOneTypeParameter.txt
index d43f76edcd0..9ee50fda6f4 100644
--- a/compiler/testData/diagnostics/tests/declarationChecks/finiteBoundRestriction/CasesWithOneTypeParameter.txt
+++ b/compiler/testData/diagnostics/tests/declarationChecks/finiteBoundRestriction/CasesWithOneTypeParameter.txt
@@ -24,6 +24,12 @@ public interface A2</*0*/ T : A2<out T>> {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
+public interface A3</*0*/ T : A3<in T>> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
 public interface A4</*0*/ T : A4<*>?> {
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/tests/generics/RawTypeInIsExpression.fir.kt b/compiler/testData/diagnostics/tests/generics/RawTypeInIsExpression.fir.kt
index f93981cb748..1cccbac6f89 100644
--- a/compiler/testData/diagnostics/tests/generics/RawTypeInIsExpression.fir.kt
+++ b/compiler/testData/diagnostics/tests/generics/RawTypeInIsExpression.fir.kt
@@ -1,7 +1,7 @@
 package p
 
 public fun foo(a: Any) {
-    a is <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Map<Int><!>
+    a is Map<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><Int><!>
     a is <!NO_TYPE_ARGUMENTS_ON_RHS!>Map<!>
     a is Map<out Any?, Any?>
     a is Map<*, *>
@@ -11,4 +11,4 @@ public fun foo(a: Any) {
     a is Int
 
     (a as <!NO_TYPE_ARGUMENTS_ON_RHS!>Map<!>) is Int
-}
\ No newline at end of file
+}
diff --git a/compiler/testData/diagnostics/tests/generics/RawTypeInIsPattern.fir.kt b/compiler/testData/diagnostics/tests/generics/RawTypeInIsPattern.fir.kt
index 09c35dc6f60..48305c2d3a4 100644
--- a/compiler/testData/diagnostics/tests/generics/RawTypeInIsPattern.fir.kt
+++ b/compiler/testData/diagnostics/tests/generics/RawTypeInIsPattern.fir.kt
@@ -1,6 +1,6 @@
 public fun foo(a: Any, b: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Map<!>) {
     when (a) {
-        is <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Map<Int><!> -> {}
+        is Map<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><Int><!> -> {}
         is <!NO_TYPE_ARGUMENTS_ON_RHS!>Map<!> -> {}
         is Map<out Any?, Any?> -> {}
         is Map<*, *> -> {}
@@ -10,4 +10,4 @@ public fun foo(a: Any, b: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Map<!>) {
         is Int -> {}
         else -> {}
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/testData/diagnostics/tests/generics/genericsInType.fir.kt b/compiler/testData/diagnostics/tests/generics/genericsInType.fir.kt
index f68d382f530..c5da3cbbf0f 100644
--- a/compiler/testData/diagnostics/tests/generics/genericsInType.fir.kt
+++ b/compiler/testData/diagnostics/tests/generics/genericsInType.fir.kt
@@ -23,14 +23,14 @@ fun test() {
     Foo<String>.Bar.Baz::class
 
     a<Foo<String>.Bar>()
-    a<<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Foo<String>.Bar.Baz<!>>()
+    a<Foo<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><String><!>.Bar.Baz>()
 
     a<Foo.Bar<Int>>()
-    a<<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Foo.Bar<Int>.Baz<!>>()
+    a<Foo.Bar<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><Int><!>.Baz>()
 }
 
 fun <T: Foo<<!UNRESOLVED_REFERENCE!>String.Bar<!>>> x() {}
 fun Foo<String>.Bar.ext() {}
 
-fun ex1(a: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Foo<String>.Bar<String><!>): <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Foo<String>.Bar<String><!> {
+fun ex1(a: Foo<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><String><!>.Bar<String>): Foo<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><String><!>.Bar<String> {
 }
diff --git a/compiler/testData/diagnostics/tests/generics/innerClasses/bareTypes.fir.kt b/compiler/testData/diagnostics/tests/generics/innerClasses/bareTypes.fir.kt
deleted file mode 100644
index c25f3d45412..00000000000
--- a/compiler/testData/diagnostics/tests/generics/innerClasses/bareTypes.fir.kt
+++ /dev/null
@@ -1,20 +0,0 @@
-class Outer<E> {
-    inner class Inner<F, G> {
-        inner abstract class Inner2Base
-        inner class Inner2 : Inner2Base()
-
-        inner abstract class Inner3Base<B>
-        inner class Inner3<H> : Inner3Base<H>()
-    }
-
-    fun foo(x: Outer<*>.Inner<*, *>.Inner2Base) {
-        if (x is Inner.Inner2) return
-    }
-}
-
-fun bare(x: Outer<*>.Inner<*, *>.Inner2Base, y: Outer<*>.Inner<*, *>.Inner3Base<Int>) {
-    if (x is Outer.Inner.Inner2) return
-    if (y is Outer.Inner.Inner3) return
-    if (y is <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Outer<String>.Inner.Inner3<!>) return
-    if (y is <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Outer.Inner<String, Int>.Inner3<Double><!>) return
-}
diff --git a/compiler/testData/diagnostics/tests/generics/innerClasses/bareTypes.kt b/compiler/testData/diagnostics/tests/generics/innerClasses/bareTypes.kt
index 8f4b237a12f..c4a8614191e 100644
--- a/compiler/testData/diagnostics/tests/generics/innerClasses/bareTypes.kt
+++ b/compiler/testData/diagnostics/tests/generics/innerClasses/bareTypes.kt
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 class Outer<E> {
     inner class Inner<F, G> {
         inner abstract class Inner2Base
diff --git a/compiler/testData/diagnostics/tests/generics/innerClasses/qualifiedOuter.fir.kt b/compiler/testData/diagnostics/tests/generics/innerClasses/qualifiedOuter.fir.kt
index e293e122324..a9381eb8ebd 100644
--- a/compiler/testData/diagnostics/tests/generics/innerClasses/qualifiedOuter.fir.kt
+++ b/compiler/testData/diagnostics/tests/generics/innerClasses/qualifiedOuter.fir.kt
@@ -3,7 +3,7 @@
 
 class Outer<T> {
     inner class Inner
-    fun foo(x: Outer<String>.Inner, y: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Outer.Inner<!>, z: Inner) {
+    fun foo(x: Outer<String>.Inner, y: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Outer<!>.Inner, z: Inner) {
         var inner = Inner()
         x.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Inner>() }
         x.checkType { _<Outer<String>.Inner>() }
diff --git a/compiler/testData/diagnostics/tests/generics/innerClasses/qualifiedTypesResolution.fir.kt b/compiler/testData/diagnostics/tests/generics/innerClasses/qualifiedTypesResolution.fir.kt
index 58fd1618b6d..bf58d75921c 100644
--- a/compiler/testData/diagnostics/tests/generics/innerClasses/qualifiedTypesResolution.fir.kt
+++ b/compiler/testData/diagnostics/tests/generics/innerClasses/qualifiedTypesResolution.fir.kt
@@ -40,12 +40,12 @@ fun ok5(): test.Outer.Obj.Nested2<A>.Inner5<B> = null!!
 // All arguments are resolved
 fun errorTypeWithArguments(): <!UNRESOLVED_REFERENCE!>Q<A>.W<B, C, D>.R.M<!> = null!!
 
-fun error1(): Outer<A>.Inner<B>.Inner3<C, D> = null!!
-fun error2(): <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Outer<A>.Inner<B, C, D>.Inner2<!> = null!!
-fun error3(): <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Outer.Inner<A, B>.Inner3<C><!> = null!!
+fun error1(): Outer<A>.Inner<B>.Inner3<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><C, D><!> = null!!
+fun error2(): Outer<A>.Inner<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><B, C, D><!>.Inner2 = null!!
+fun error3(): <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Outer<!>.Inner<A, B>.Inner3<C> = null!!
 
-fun error4(): <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Outer<A>.Nested<B>.Inner4<C><!> = null!!
-fun error5(): <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Outer<A>.Obj.Nested2<B>.Inner5<C><!> = null!!
-fun error6(): <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Outer.Obj<A>.Nested2<B>.Inner5<C><!> = null!!
+fun error4(): Outer<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><A><!>.Nested<B>.Inner4<C> = null!!
+fun error5(): Outer<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><A><!>.Obj.Nested2<B>.Inner5<C> = null!!
+fun error6(): Outer.Obj<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><A><!>.Nested2<B>.Inner5<C> = null!!
 
-fun error7(): <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>test<String>.Outer.Obj.Nested2<A>.Inner5<B><!> = null!!
\ No newline at end of file
+fun error7(): test<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><String><!>.Outer.Obj.Nested2<A>.Inner5<B> = null!!
diff --git a/compiler/testData/diagnostics/tests/generics/invalidArgumentsNumberInWhere.fir.kt b/compiler/testData/diagnostics/tests/generics/invalidArgumentsNumberInWhere.fir.kt
deleted file mode 100644
index e4853294bab..00000000000
--- a/compiler/testData/diagnostics/tests/generics/invalidArgumentsNumberInWhere.fir.kt
+++ /dev/null
@@ -1,19 +0,0 @@
-class A
-interface I0<T : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!>>
-interface I1<T> where T : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!>
-interface I2<<!MISPLACED_TYPE_PARAMETER_CONSTRAINTS!>T : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!><!>> where T : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!>
-
-fun <E : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!>> foo0() {}
-fun <E> foo1() where E : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!> {}
-fun <<!MISPLACED_TYPE_PARAMETER_CONSTRAINTS!>E : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!><!>> foo2() where E : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!> {}
-
-val <E : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!>> E.p1: Int
-        get() = 1
-val <E> E.p2: Int where E : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!>
-        get() = 1
-val <<!MISPLACED_TYPE_PARAMETER_CONSTRAINTS!>E : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!><!>> E.p3: Int where E : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!>
-        get() = 1
-
-// See KT-8200
-interface X
-public class EnumAttribute<<!MISPLACED_TYPE_PARAMETER_CONSTRAINTS!>T : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>X<T><!><!>>(val klass: Class<T>) where T : Enum<T>
diff --git a/compiler/testData/diagnostics/tests/generics/invalidArgumentsNumberInWhere.kt b/compiler/testData/diagnostics/tests/generics/invalidArgumentsNumberInWhere.kt
index b011ba7ca5f..84f9f0db0c3 100644
--- a/compiler/testData/diagnostics/tests/generics/invalidArgumentsNumberInWhere.kt
+++ b/compiler/testData/diagnostics/tests/generics/invalidArgumentsNumberInWhere.kt
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 class A
 interface I0<T : A<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><Int><!>>
 interface I1<T> where T : A<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><Int><!>
diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateClass/genericArgumentNumberMismatch.fir.kt b/compiler/testData/diagnostics/tests/multimodule/duplicateClass/genericArgumentNumberMismatch.fir.kt
index d7184e68c6f..535f4014269 100644
--- a/compiler/testData/diagnostics/tests/multimodule/duplicateClass/genericArgumentNumberMismatch.fir.kt
+++ b/compiler/testData/diagnostics/tests/multimodule/duplicateClass/genericArgumentNumberMismatch.fir.kt
@@ -6,7 +6,7 @@ package p
 
 public class A<X, Y>
 public class M1 {
-    public val a: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!> = A<Int, Int>()
+    public val a: A<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><Int><!> = A<Int, Int>()
 }
 
 // MODULE: m2
@@ -16,7 +16,7 @@ package p
 
 public class A<X, Y>
 
-public fun foo(a: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>A<Int><!>) {
+public fun foo(a: A<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><Int><!>) {
 }
 
 // MODULE: m3(m1, m2)
@@ -27,4 +27,4 @@ import p.*
 fun test() {
     foo(M1().a)
     foo(1) // error type on the declaration site
-}
\ No newline at end of file
+}
diff --git a/compiler/testData/diagnostics/tests/regressions/OrphanStarProjection.fir.kt b/compiler/testData/diagnostics/tests/regressions/OrphanStarProjection.fir.kt
deleted file mode 100644
index 2ec70721ce6..00000000000
--- a/compiler/testData/diagnostics/tests/regressions/OrphanStarProjection.fir.kt
+++ /dev/null
@@ -1,3 +0,0 @@
-class B {}
-
-val b : <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>B<*><!> = 1
diff --git a/compiler/testData/diagnostics/tests/regressions/OrphanStarProjection.kt b/compiler/testData/diagnostics/tests/regressions/OrphanStarProjection.kt
index 793153c8348..1bf9b47fe8b 100644
--- a/compiler/testData/diagnostics/tests/regressions/OrphanStarProjection.kt
+++ b/compiler/testData/diagnostics/tests/regressions/OrphanStarProjection.kt
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 class B {}
 
 val b : B<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><*><!> = 1
diff --git a/compiler/testData/diagnostics/tests/regressions/kt9620.fir.kt b/compiler/testData/diagnostics/tests/regressions/kt9620.fir.kt
deleted file mode 100644
index 086014b0c61..00000000000
--- a/compiler/testData/diagnostics/tests/regressions/kt9620.fir.kt
+++ /dev/null
@@ -1,14 +0,0 @@
-// KT-9620 AssertionError in checkBounds
-
-interface E1<T : D<!TYPE_ARGUMENTS_NOT_ALLOWED!><String><!>, D>
-
-interface A
-interface B
-interface D<X>
-interface E2<T : D<!TYPE_ARGUMENTS_NOT_ALLOWED!><A><!>, D<!SYNTAX!><<!><!SYNTAX!>B<!><!SYNTAX!>><!><!SYNTAX!>><!>
-
-// KT-11354 AE from DescriptorResolver
-
-open class L<E>()
-
-class M<C> : L<C<!TYPE_ARGUMENTS_NOT_ALLOWED!><C><!>>()
diff --git a/compiler/testData/diagnostics/tests/regressions/kt9620.kt b/compiler/testData/diagnostics/tests/regressions/kt9620.kt
index 086014b0c61..2143b1ac959 100644
--- a/compiler/testData/diagnostics/tests/regressions/kt9620.kt
+++ b/compiler/testData/diagnostics/tests/regressions/kt9620.kt
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // KT-9620 AssertionError in checkBounds
 
 interface E1<T : D<!TYPE_ARGUMENTS_NOT_ALLOWED!><String><!>, D>
diff --git a/compiler/testData/diagnostics/tests/typealias/kt14518.fir.kt b/compiler/testData/diagnostics/tests/typealias/kt14518.fir.kt
index eed7f53d0c1..dac0393b6ed 100644
--- a/compiler/testData/diagnostics/tests/typealias/kt14518.fir.kt
+++ b/compiler/testData/diagnostics/tests/typealias/kt14518.fir.kt
@@ -5,6 +5,6 @@ class OuterClass<T1> {
     typealias NestedType<T> = NestedClass<T>
 }
 
-typealias ON1<T1, T2> = <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>OuterClass<T1>.NestedClass<T2><!>
+typealias ON1<T1, T2> = OuterClass<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><T1><!>.NestedClass<T2>
 typealias ON2<T1, T2> = OuterClass<T1>.NestedType<T2>
-typealias ON3<T2> = OuterClass.NestedType<T2>
\ No newline at end of file
+typealias ON3<T2> = OuterClass.NestedType<T2>
diff --git a/compiler/testData/diagnostics/tests/variance/InPosition.fir.kt b/compiler/testData/diagnostics/tests/variance/InPosition.fir.kt
index 6624f7be513..642c724a5ee 100644
--- a/compiler/testData/diagnostics/tests/variance/InPosition.fir.kt
+++ b/compiler/testData/diagnostics/tests/variance/InPosition.fir.kt
@@ -41,10 +41,10 @@ interface Test<in I, out O, P> {
     fun neOk11(i: Inv<in <!TYPE_VARIANCE_CONFLICT("I; in; out; Inv<in I>")!>I<!>>)
     fun neOk12(i: Inv<out <!TYPE_VARIANCE_CONFLICT("O; out; in; Inv<out O>")!>O<!>>)
 
-    fun neOk30(i: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Pair<O, ><!>)
+    fun neOk30(i: Pair<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><O, ><!>)
     fun neOk31(i: Pair<<!TYPE_VARIANCE_CONFLICT("O; out; in; Pair<O, ERROR CLASS: Wrong number of type arguments>")!>O<!>, <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Inv<!>>)
     fun neOk32(i: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Inv<!>)
     fun neOk33(i: Inv<<!SYNTAX!><!>>)
     fun neOk34(i: Inv<<!UNRESOLVED_REFERENCE!>C<!>>)
-    fun neOk35(i: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Inv<P, P><!>)
+    fun neOk35(i: Inv<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><P, P><!>)
 }
diff --git a/compiler/testData/diagnostics/tests/variance/InvariantPosition.fir.kt b/compiler/testData/diagnostics/tests/variance/InvariantPosition.fir.kt
index 8989b7dac66..96f88544680 100644
--- a/compiler/testData/diagnostics/tests/variance/InvariantPosition.fir.kt
+++ b/compiler/testData/diagnostics/tests/variance/InvariantPosition.fir.kt
@@ -38,10 +38,10 @@ interface Test<in I, out O, P> {
     var neOk22: Inv<out <!TYPE_VARIANCE_CONFLICT("O; out; invariant; Inv<out O>")!>O<!>>
     var neOk23: Inv<out <!TYPE_VARIANCE_CONFLICT("I; in; invariant; Inv<out I>")!>I<!>>
 
-    var neOk30: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Pair<I, ><!>
+    var neOk30: Pair<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><I, ><!>
     var neOk31: Pair<<!TYPE_VARIANCE_CONFLICT("I; in; invariant; Pair<I, ERROR CLASS: Wrong number of type arguments>")!>I<!>, <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Inv<!>>
     var neOk32: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Inv<!>
     var neOk33: Inv<<!SYNTAX!><!>>
     var neOk34: Inv<<!UNRESOLVED_REFERENCE!>C<!>>
-    var neOk35: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Inv<P, P><!>
+    var neOk35: Inv<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><P, P><!>
 }
diff --git a/compiler/testData/diagnostics/tests/variance/OutPosition.fir.kt b/compiler/testData/diagnostics/tests/variance/OutPosition.fir.kt
index aab70b319be..fabb5fc5a6d 100644
--- a/compiler/testData/diagnostics/tests/variance/OutPosition.fir.kt
+++ b/compiler/testData/diagnostics/tests/variance/OutPosition.fir.kt
@@ -33,10 +33,10 @@ interface Test<in I, out O, P> {
     fun neOk10(): Inv<in <!TYPE_VARIANCE_CONFLICT("O; out; in; Inv<in O>")!>O<!>>
     fun neOk11(): Inv<out <!TYPE_VARIANCE_CONFLICT("I; in; out; Inv<out I>")!>I<!>>
 
-    fun neOk30(): <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Pair<I, ><!>
+    fun neOk30(): Pair<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><I, ><!>
     fun neOk31(): Pair<<!TYPE_VARIANCE_CONFLICT("I; in; out; Pair<I, ERROR CLASS: Wrong number of type arguments>")!>I<!>, <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Inv<!>>
     fun neOk32(): <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Inv<!>
     fun neOk33(): Inv<<!SYNTAX!><!>>
     fun neOk34(): Inv<<!UNRESOLVED_REFERENCE!>C<!>>
-    fun neOk35(): <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Inv<P, P><!>
+    fun neOk35(): Inv<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><P, P><!>
 }
diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDataClassConverters.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDataClassConverters.kt
index f5a5661321b..cd4b8da308c 100644
--- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDataClassConverters.kt
+++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDataClassConverters.kt
@@ -1336,7 +1336,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
     add(FirErrors.WRONG_NUMBER_OF_TYPE_ARGUMENTS) { firDiagnostic ->
         WrongNumberOfTypeArgumentsImpl(
             firDiagnostic.a,
-            firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(firDiagnostic.b.fir as FirClass),
+            firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(firDiagnostic.b.fir),
             firDiagnostic as FirPsiDiagnostic,
             token,
         )
@@ -1351,7 +1351,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
     }
     add(FirErrors.OUTER_CLASS_ARGUMENTS_REQUIRED) { firDiagnostic ->
         OuterClassArgumentsRequiredImpl(
-            firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(firDiagnostic.a) as KtNamedClassOrObjectSymbol,
+            firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(firDiagnostic.a.fir),
             firDiagnostic as FirPsiDiagnostic,
             token,
         )
diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnostics.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnostics.kt
index 4edebcd6880..8b1973adc84 100644
--- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnostics.kt
+++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnostics.kt
@@ -958,7 +958,7 @@ sealed class KtFirDiagnostic<PSI : PsiElement> : KtDiagnosticWithPsi<PSI> {
 
     abstract class OuterClassArgumentsRequired : KtFirDiagnostic<PsiElement>() {
         override val diagnosticClass get() = OuterClassArgumentsRequired::class
-        abstract val outer: KtNamedClassOrObjectSymbol
+        abstract val outer: KtClassLikeSymbol
     }
 
     abstract class TypeParametersInObject : KtFirDiagnostic<PsiElement>() {
diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnosticsImpl.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnosticsImpl.kt
index ca4863bfc43..44240569ff7 100644
--- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnosticsImpl.kt
+++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnosticsImpl.kt
@@ -1537,7 +1537,7 @@ internal class NoTypeArgumentsOnRhsImpl(
 }
 
 internal class OuterClassArgumentsRequiredImpl(
-    override val outer: KtNamedClassOrObjectSymbol,
+    override val outer: KtClassLikeSymbol,
     firDiagnostic: FirPsiDiagnostic,
     override val token: ValidityToken,
 ) : KtFirDiagnostic.OuterClassArgumentsRequired(), KtAbstractFirDiagnostic<PsiElement> {