[FIR2IR] Support type aliases properly

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrClassifierStorage.kt

@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.fir.resolve.firProvider
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.symbols.Fir2IrClassSymbol
 import org.jetbrains.kotlin.fir.symbols.Fir2IrEnumEntrySymbol
+import org.jetbrains.kotlin.fir.symbols.Fir2IrTypeAliasSymbol
 import org.jetbrains.kotlin.fir.symbols.StandardClassIds
 import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
@@ -19,6 +20,7 @@ import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.impl.IrClassImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrEnumEntryImpl
+import org.jetbrains.kotlin.ir.declarations.impl.IrTypeAliasImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrTypeParameterImpl
 import org.jetbrains.kotlin.ir.descriptors.*
 import org.jetbrains.kotlin.ir.expressions.impl.IrEnumConstructorCallImpl
@@ -167,6 +169,28 @@ class Fir2IrClassifierStorage(
         return irClass
     }
 
+    fun registerTypeAlias(
+        typeAlias: FirTypeAlias,
+        parent: IrFile
+    ): IrTypeAlias {
+        val signature = signatureComposer.composeSignature(typeAlias)!!
+        preCacheTypeParameters(typeAlias)
+        return typeAlias.convertWithOffsets { startOffset, endOffset ->
+            symbolTable.declareTypeAlias(signature, { Fir2IrTypeAliasSymbol(signature) }) { symbol ->
+                IrTypeAliasImpl(
+                    startOffset, endOffset, symbol,
+                    typeAlias.name, typeAlias.visibility,
+                    typeAlias.expandedTypeRef.toIrType(),
+                    typeAlias.isActual, IrDeclarationOrigin.DEFINED
+                ).apply {
+                    this.parent = parent
+                    setTypeParameters(typeAlias)
+                    parent.declarations += this
+                }
+            }
+        }
+    }
+
     private fun declareIrClass(signature: IdSignature?, factory: (IrClassSymbol) -> IrClass): IrClass {
         if (signature == null) {
             val descriptor = WrappedClassDescriptor()

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrConverter.kt

@@ -61,8 +61,9 @@ class Fir2IrConverter(
 
     fun processClassHeaders(file: FirFile) {
         file.declarations.forEach {
-            if (it is FirRegularClass) {
-                processClassAndNestedClassHeaders(it)
+            when (it) {
+                is FirRegularClass -> processClassAndNestedClassHeaders(it)
+                is FirTypeAlias -> classifierStorage.registerTypeAlias(it, declarationStorage.getIrFile(file))
             }
         }
     }

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/signaturer/FirBasedSignatureComposer.kt

@@ -35,6 +35,10 @@ class FirBasedSignatureComposer(private val mangler: FirMangler) : Fir2IrSignatu
             //platformSpecificClass(descriptor)
         }
 
+        override fun visitTypeAlias(typeAlias: FirTypeAlias) {
+            setExpected(typeAlias.isExpect)
+        }
+
         override fun visitConstructor(constructor: FirConstructor) {
             hashId = mangler.run { constructor.signatureMangle }
             setExpected(constructor.isExpect)
@@ -68,6 +72,10 @@ class FirBasedSignatureComposer(private val mangler: FirMangler) : Fir2IrSignatu
                 val classId = declaration.classId
                 IdSignature.PublicSignature(classId.packageFqName, classId.relativeClassName, builder.hashId, builder.mask)
             }
+            declaration is FirTypeAlias -> {
+                val classId = declaration.symbol.classId
+                IdSignature.PublicSignature(classId.packageFqName, classId.relativeClassName, builder.hashId, builder.mask)
+            }
             declaration is FirCallableMemberDeclaration<*> -> {
                 val callableId = declaration.symbol.callableId
                 IdSignature.PublicSignature(callableId.packageName, callableId.relativeCallableName, builder.hashId, builder.mask)

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/symbols/Fir2IrBindableSymbol.kt

@@ -60,6 +60,7 @@ abstract class Fir2IrBindableSymbol<out D : DeclarationDescriptor, B : IrSymbolO
                 WrappedPropertyDescriptor()
             }.apply { bind(owner) }
             is IrField -> WrappedFieldDescriptor().apply { bind(owner) }
+            is IrTypeAlias -> WrappedTypeAliasDescriptor().apply { bind(owner) }
             else -> throw IllegalStateException("Unsupported owner in Fir2IrBindableSymbol: $owner")
         } as D
     }

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/symbols/Fir2IrSymbols.kt

@@ -15,6 +15,10 @@ class Fir2IrClassSymbol(signature: IdSignature) :
     Fir2IrBindableSymbol<ClassDescriptor, IrClass>(signature),
     IrClassSymbol
 
+class Fir2IrTypeAliasSymbol(signature: IdSignature) :
+    Fir2IrBindableSymbol<TypeAliasDescriptor, IrTypeAlias>(signature),
+    IrTypeAliasSymbol
+
 class Fir2IrEnumEntrySymbol(signature: IdSignature) :
     Fir2IrBindableSymbol<ClassDescriptor, IrEnumEntry>(signature),
     IrEnumEntrySymbol