[FIR] Support type aliases in double colon expression resolver

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirDoubleColonExpressionResolver.kt

@@ -10,6 +10,8 @@ package org.jetbrains.kotlin.fir.resolve
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
+import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
+import org.jetbrains.kotlin.fir.declarations.expandedConeType
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.references.FirNamedReference
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
@@ -117,16 +119,23 @@ class FirDoubleColonExpressionResolver(
         return resolve(expression)
     }
 
+    private fun FirResolvedQualifier.expandedRegularClassIfAny(): FirRegularClass? {
+        val classId = classId ?: return null
+        var fir = session.firSymbolProvider.getClassLikeSymbolByFqName(classId)?.fir
+        while (fir is FirTypeAlias) {
+            fir = fir.expandedConeType?.lookupTag?.toSymbol(session)?.fir ?: return null
+        }
+        return fir as? FirRegularClass
+    }
+
     private fun resolveExpressionOnLHS(expression: FirExpression): DoubleColonLHS.Expression? {
         val type = (expression.typeRef as? FirResolvedTypeRef)?.type ?: return null
 
         if (expression is FirResolvedQualifier) {
-            val firClass = session.firSymbolProvider
+            val firClass = expression.expandedRegularClassIfAny() ?: return null
-                .getClassLikeSymbolByFqName(expression.classId ?: return null)
+            if (firClass.classKind == ClassKind.OBJECT) {
-                ?.fir as? FirRegularClass
+                return DoubleColonLHS.Expression(type, isObjectQualifier = true)
-                ?: return null
+            }
-
-            if (firClass.classKind == ClassKind.OBJECT) return DoubleColonLHS.Expression(type, isObjectQualifier = true)
             return null
         }
 
@@ -136,14 +145,10 @@ class FirDoubleColonExpressionResolver(
     private fun resolveTypeOnLHS(
         expression: FirExpression
     ): DoubleColonLHS.Type? {
-        val resolvedExpression =
+        val resolvedExpression = expression as? FirResolvedQualifier
-            expression as? FirResolvedQualifier
+            ?: return null
-                ?: return null
 
-        val firClass = session.firSymbolProvider
+        val firClass = resolvedExpression.expandedRegularClassIfAny()
-            .getClassLikeSymbolByFqName(resolvedExpression.classId ?: return null)
-            // TODO: support type aliases
-            ?.fir as? FirRegularClass
             ?: return null
 
         val type = ConeClassLikeTypeImpl(

compiler/testData/diagnostics/tests/callableReference/typealiases.fir.kt

@@ -11,5 +11,5 @@ inline fun <T, R> Iterable<T>.myMap(transform: (T) -> R): List<R> {
 }
 
 fun usesGlobal(p: List<Global>) {
-    p.<!INAPPLICABLE_CANDIDATE!>myMap<!>(Global::toUpperCase)
+    p.myMap(Global::toUpperCase)
 }

compiler/testData/diagnostics/tests/typealias/methodReference.fir.kt

@@ -4,4 +4,4 @@ class C {
 
 typealias CA = C
 
-val cf = <!UNRESOLVED_REFERENCE!>CA::foo<!>
+val cf = CA::foo

compiler/testData/diagnostics/tests/typealias/typeAliasesInQualifiers.fir.kt

@@ -50,7 +50,7 @@ fun foo(
     test.ClassAlias::Nested
 
     test.ClassSample::func
-    <!UNRESOLVED_REFERENCE!>test.ClassAlias::func<!>
+    test.ClassAlias::func
 
     test.ClassSample.Nested::func
     test.ClassAlias.Nested::func
@@ -68,7 +68,7 @@ fun foo(
     test.EnumAlias::Nested
 
     test.EnumSample::func
-    <!UNRESOLVED_REFERENCE!>test.EnumAlias::func<!>
+    test.EnumAlias::func
 
     test.EnumSample.Nested::func
     test.EnumAlias.Nested::func