FIR: add type alias descriptors

compiler/fir/resolve/src/org/jetbrains/kotlin/descriptors/ConeClassDescriptorImpl.kt

@@ -17,5 +17,4 @@ class ConeClassDescriptorImpl(
     override val fqName: ClassId,
     override val superTypes: List<ConeKotlinType>,
     override val nestedClassifiers: List<ConeClassifierDescriptor>
-) : ConeClassDescriptor, AbstractFirBasedDescriptor<FirResolvedClass>() {
+) : ConeClassDescriptor, AbstractFirBasedDescriptor<FirResolvedClass>()
-}

compiler/fir/resolve/src/org/jetbrains/kotlin/descriptors/ConeTypeAliasDescriptorImpl.kt

@@ -0,0 +1,18 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.descriptors
+
+import org.jetbrains.kotlin.fir.declarations.FirResolvedTypeAlias
+import org.jetbrains.kotlin.fir.descriptors.ConeTypeAliasDescriptor
+import org.jetbrains.kotlin.fir.descriptors.ConeTypeParameterDescriptor
+import org.jetbrains.kotlin.fir.types.ConeKotlinType
+import org.jetbrains.kotlin.name.ClassId
+
+class ConeTypeAliasDescriptorImpl(
+    override val typeParameters: List<ConeTypeParameterDescriptor>,
+    override val fqName: ClassId,
+    override val expandedType: ConeKotlinType
+) : ConeTypeAliasDescriptor, AbstractFirBasedDescriptor<FirResolvedTypeAlias>()

compiler/fir/resolve/src/org/jetbrains/kotlin/descriptors/FirClassifierResolveTransformer.kt

@@ -7,11 +7,9 @@ package org.jetbrains.kotlin.descriptors
 
 import org.jetbrains.kotlin.fir.FirDescriptorOwner
 import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.declarations.FirClass
+import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirFile
-import org.jetbrains.kotlin.fir.declarations.FirResolvedClass
 import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedClassImpl
+import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedTypeAliasImpl
 import org.jetbrains.kotlin.fir.descriptors.ConeClassifierDescriptor
 import org.jetbrains.kotlin.fir.descriptors.ConeTypeParameterDescriptor
 import org.jetbrains.kotlin.fir.types.FirResolvedType
@@ -66,4 +64,26 @@ class FirClassifierResolveTransformer : FirTransformer<Nothing?>() {
     override fun transformResolvedClass(resolvedClass: FirResolvedClass, data: Nothing?): CompositeTransformResult<FirDeclaration> {
         return resolvedClass.compose()
     }
+
+    override fun transformTypeAlias(typeAlias: FirTypeAlias, data: Nothing?): CompositeTransformResult<FirDeclaration> {
+        typeAlias.transformChildren(this, data)
+        val expandedType = (typeAlias.expandedType as FirResolvedType).type
+        val typeParameters =
+            typeAlias.typeParameters.filterIsInstance<FirDescriptorOwner<*>>().mapNotNull { it.descriptor as? ConeTypeParameterDescriptor }
+
+        val descriptor = ConeTypeAliasDescriptorImpl(
+            typeParameters,
+            ClassId(packageFqName, className.child(typeAlias.name), false),
+            expandedType
+        )
+
+        return FirResolvedTypeAliasImpl(typeAlias, descriptor).compose()
+    }
+
+    override fun transformResolvedTypeAlias(
+        resolvedTypeAlias: FirResolvedTypeAlias,
+        data: Nothing?
+    ): CompositeTransformResult<FirDeclaration> {
+        return resolvedTypeAlias.compose()
+    }
 }

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

@@ -143,7 +143,7 @@ class FirTypeResolveTransformer(val superTypesOnly: Boolean = false) : FirTransf
                         classifier.superTypes.any { it.accept(this, data) }
                     }
                 }
-                is FirTypeAlias -> classifier.abbreviatedType.accept(this, data)
+                is FirTypeAlias -> classifier.expandedType.accept(this, data)
             }
             return true
         }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirQualifierResolverImpl.kt

@@ -48,7 +48,7 @@ class FirQualifierResolverImpl(val session: FirSession) : FirQualifierResolver {
                 ConeAbbreviatedTypeImpl(
                     abbreviationFqName = fqName,
                     typeArguments = parts.toTypeProjections(),
-                    directExpansion = (this.abbreviatedType as FirResolvedType).type
+                    directExpansion = (this.expandedType as FirResolvedType).type
                 )
 
             }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt

@@ -155,6 +155,11 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
         visitClass(enumEntry)
     }
 
+    override fun visitResolvedClass(resolvedClass: FirResolvedClass) {
+        print("(resolved) ")
+        visitClass(resolvedClass)
+    }
+
     override fun visitClass(klass: FirClass) {
         visitMemberDeclaration(klass)
         val attributes = listOfNotNull(
@@ -257,11 +262,16 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
         println("}")
     }
 
+    override fun visitResolvedTypeAlias(resolvedTypeAlias: FirResolvedTypeAlias) {
+        print("(resolved) ")
+        visitTypeAlias(resolvedTypeAlias)
+    }
+
     override fun visitTypeAlias(typeAlias: FirTypeAlias) {
         typeAlias.annotations.renderAnnotations()
         visitMemberDeclaration(typeAlias)
         print(" = ")
-        typeAlias.abbreviatedType.accept(this)
+        typeAlias.expandedType.accept(this)
         println()
     }
 

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirResolvedTypeAlias.kt

@@ -0,0 +1,14 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.declarations
+
+import org.jetbrains.kotlin.fir.FirDescriptorOwner
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
+
+interface FirResolvedTypeAlias : FirTypeAlias, FirDescriptorOwner<FirResolvedTypeAlias> {
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitResolvedTypeAlias(this, data)
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirTypeAlias.kt

@@ -9,13 +9,13 @@ import org.jetbrains.kotlin.fir.types.FirType
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 interface FirTypeAlias : FirMemberDeclaration {
-    val abbreviatedType: FirType
+    val expandedType: FirType
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitTypeAlias(this, data)
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         super.acceptChildren(visitor, data)
-        abbreviatedType.accept(visitor, data)
+        expandedType.accept(visitor, data)
     }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirResolvedClassImpl.kt

@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir.declarations.impl
 import org.jetbrains.kotlin.fir.FirBasedDescriptor
 import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirResolvedClass
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 class FirResolvedClassImpl(val delegate: FirClass, override val descriptor: FirBasedDescriptor<FirResolvedClass>) :
     FirResolvedClass, FirClass by delegate {
@@ -16,4 +17,7 @@ class FirResolvedClassImpl(val delegate: FirClass, override val descriptor: FirB
         descriptor.bind(this)
     }
 
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R {
+        return super<FirResolvedClass>.accept(visitor, data)
+    }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirResolvedTypeAliasImpl.kt

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.declarations.impl
+
+import org.jetbrains.kotlin.fir.FirBasedDescriptor
+import org.jetbrains.kotlin.fir.declarations.FirResolvedTypeAlias
+import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
+
+class FirResolvedTypeAliasImpl(val delegate: FirTypeAlias, override val descriptor: FirBasedDescriptor<FirResolvedTypeAlias>) :
+    FirResolvedTypeAlias, FirTypeAlias by delegate {
+
+    init {
+        descriptor.bind(this)
+    }
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R {
+        return super<FirResolvedTypeAlias>.accept(visitor, data)
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirTypeAliasImpl.kt

@@ -21,10 +21,10 @@ class FirTypeAliasImpl(
     psi: PsiElement?,
     name: Name,
     visibility: Visibility,
-    override var abbreviatedType: FirType
+    override var expandedType: FirType
 ) : FirAbstractMemberDeclaration(session, psi, name, visibility, Modality.FINAL), FirTypeAlias {
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
-        abbreviatedType = abbreviatedType.transformSingle(transformer, data)
+        expandedType = expandedType.transformSingle(transformer, data)
 
         return this
     }

compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirTransformerGenerated.kt

@@ -74,6 +74,10 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformMemberDeclaration(typeAlias, data)
     }
 
+    open fun transformResolvedTypeAlias(resolvedTypeAlias: FirResolvedTypeAlias, data: D): CompositeTransformResult<FirDeclaration> {
+        return transformTypeAlias(resolvedTypeAlias, data)
+    }
+
     open fun transformTypeParameter(typeParameter: FirTypeParameter, data: D): CompositeTransformResult<FirDeclaration> {
         return transformNamedDeclaration(typeParameter, data)
     }
@@ -238,6 +242,10 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformType(type, data)
     }
 
+    final override fun visitTypeAlias(typeAlias: FirTypeAlias, data: D): CompositeTransformResult<FirElement> {
+        return transformTypeAlias(typeAlias, data)
+    }
+
     final override fun visitTypeProjection(typeProjection: FirTypeProjection, data: D): CompositeTransformResult<FirElement> {
         return transformTypeProjection(typeProjection, data)
     }
@@ -314,10 +322,6 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformResolvedImport(resolvedImport, data)
     }
 
-    final override fun visitTypeAlias(typeAlias: FirTypeAlias, data: D): CompositeTransformResult<FirElement> {
-        return transformTypeAlias(typeAlias, data)
-    }
-
     final override fun visitTypeParameter(typeParameter: FirTypeParameter, data: D): CompositeTransformResult<FirElement> {
         return transformTypeParameter(typeParameter, data)
     }
@@ -338,6 +342,10 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformImplicitType(implicitType, data)
     }
 
+    final override fun visitResolvedTypeAlias(resolvedTypeAlias: FirResolvedTypeAlias, data: D): CompositeTransformResult<FirElement> {
+        return transformResolvedTypeAlias(resolvedTypeAlias, data)
+    }
+
     final override fun visitStarProjection(starProjection: FirStarProjection, data: D): CompositeTransformResult<FirElement> {
         return transformStarProjection(starProjection, data)
     }

compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorGenerated.kt

@@ -74,6 +74,10 @@ abstract class FirVisitor<out R, in D> {
         return visitMemberDeclaration(typeAlias, data)
     }
 
+    open fun visitResolvedTypeAlias(resolvedTypeAlias: FirResolvedTypeAlias, data: D): R {
+        return visitTypeAlias(resolvedTypeAlias, data)
+    }
+
     open fun visitTypeParameter(typeParameter: FirTypeParameter, data: D): R {
         return visitNamedDeclaration(typeParameter, data)
     }

compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorVoidGenerated.kt

@@ -74,6 +74,10 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitMemberDeclaration(typeAlias, null)
     }
 
+    open fun visitResolvedTypeAlias(resolvedTypeAlias: FirResolvedTypeAlias) {
+        visitTypeAlias(resolvedTypeAlias, null)
+    }
+
     open fun visitTypeParameter(typeParameter: FirTypeParameter) {
         visitNamedDeclaration(typeParameter, null)
     }
@@ -238,6 +242,10 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitType(type)
     }
 
+    final override fun visitTypeAlias(typeAlias: FirTypeAlias, data: Nothing?) {
+        visitTypeAlias(typeAlias)
+    }
+
     final override fun visitTypeProjection(typeProjection: FirTypeProjection, data: Nothing?) {
         visitTypeProjection(typeProjection)
     }
@@ -314,10 +322,6 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitResolvedImport(resolvedImport)
     }
 
-    final override fun visitTypeAlias(typeAlias: FirTypeAlias, data: Nothing?) {
-        visitTypeAlias(typeAlias)
-    }
-
     final override fun visitTypeParameter(typeParameter: FirTypeParameter, data: Nothing?) {
         visitTypeParameter(typeParameter)
     }
@@ -338,6 +342,10 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitImplicitType(implicitType)
     }
 
+    final override fun visitResolvedTypeAlias(resolvedTypeAlias: FirResolvedTypeAlias, data: Nothing?) {
+        visitResolvedTypeAlias(resolvedTypeAlias)
+    }
+
     final override fun visitStarProjection(starProjection: FirStarProjection, data: Nothing?) {
         visitStarProjection(starProjection)
     }

compiler/testData/fir/resolve/F.txt

@@ -1,5 +1,5 @@
 FILE: F.kt
-    unknown open class A() {
+    (resolved) unknown open class A() {
     }
-    unknown final class B() : R/<root>.A/ {
+    (resolved) unknown final class B() : R/<root>.A/ {
     }

compiler/testData/fir/resolve/NestedOfAliasedType.txt

@@ -1,11 +1,11 @@
 FILE: NestedOfAliasedType.kt
-    unknown abstract class A() {
+    (resolved) unknown abstract class A() {
         unknown abstract class Nested() {
         }
 
     }
-    unknown final typealias TA = R/<root>.A/
+    (resolved) unknown final typealias TA = R/<root>.A/
-    unknown final class B() : R/<root>.TA = <root>.A/ {
+    (resolved) unknown final class B() : R/<root>.TA = <root>.A/ {
         unknown final class NestedInB() : R/<root>.A.Nested/ {
         }
 

compiler/testData/fir/resolve/NestedSuperType.txt

@@ -1,5 +1,5 @@
 FILE: NestedSuperType.kt
-    unknown abstract class My() {
+    (resolved) unknown abstract class My() {
         unknown abstract class NestedOne() : R/p.My/ {
             unknown abstract class NestedTwo() : R/p.My.NestedOne/ {
             }
@@ -7,7 +7,7 @@ FILE: NestedSuperType.kt
         }
 
     }
-    unknown final class Your() : R/p.My/ {
+    (resolved) unknown final class Your() : R/p.My/ {
         unknown final class NestedThree() : R/p.My.NestedOne/ {
         }
 

compiler/testData/fir/resolve/TwoDeclarationsInSameFile.txt

@@ -1,5 +1,5 @@
 FILE: TwoDeclarationsInSameFile.kt
-    unknown open class A() {
+    (resolved) unknown open class A() {
     }
-    unknown final class B() : R/p.A/ {
+    (resolved) unknown final class B() : R/p.A/ {
     }

compiler/testData/fir/resolve/multifile/NestedSuperType.txt

@@ -1,5 +1,5 @@
 FILE: NestedSuperType.kt
-    unknown final class A() : R/b.B/ {
+    (resolved) unknown final class A() : R/b.B/ {
         unknown final class NestedInA1() : R/b.B.NestedInB/ {
         }
 

compiler/testData/fir/resolve/multifile/simpleAliasedImport.txt

@@ -1,3 +1,3 @@
 FILE: simpleAliasedImport.kt
-    unknown final class YourClass() : R/b.MyClass/ {
+    (resolved) unknown final class YourClass() : R/b.MyClass/ {
     }

compiler/testData/fir/resolve/multifile/simpleImport.txt

@@ -1,3 +1,3 @@
 FILE: simpleImport.kt
-    unknown final class YourClass() : R/b.MyClass/ {
+    (resolved) unknown final class YourClass() : R/b.MyClass/ {
     }

compiler/testData/fir/resolve/multifile/simpleImportNested.txt

@@ -1,3 +1,3 @@
 FILE: simpleImportNested.kt
-    unknown final class YourClass() : R/a.MyClass.MyNested/ {
+    (resolved) unknown final class YourClass() : R/a.MyClass.MyNested/ {
     }

compiler/testData/fir/resolve/multifile/simpleImportOuter.txt

@@ -1,3 +1,3 @@
 FILE: simpleImportOuter.kt
-    unknown final class My() : R/a.Outer.Nested/ {
+    (resolved) unknown final class My() : R/a.Outer.Nested/ {
     }

compiler/testData/fir/resolve/simpleClass.txt

@@ -1,12 +1,12 @@
 FILE: simpleClass.kt
-    unknown final interface SomeInterface() {
+    (resolved) unknown final interface SomeInterface() {
         unknown final function foo(x: R/error: Failed to resolve qualified type/, y: R/error: Failed to resolve qualified type/): R/error: Failed to resolve qualified type/
 
         unknown final property bar(val): R/error: Failed to resolve qualified type/
             unknown get(): R/error: Failed to resolve qualified type/
 
     }
-    unknown final class SomeClass() : R/<root>.SomeInterface/ {
+    (resolved) unknown final class SomeClass() : R/<root>.SomeInterface/ {
         private final property baz(val): R/error: Not supported: FirImplicitTypeImpl/ = STUB
             unknown get(): R/error: Not supported: FirImplicitTypeImpl/
 

compiler/testData/fir/resolve/simpleTypeAlias.txt

@@ -1,6 +1,6 @@
 FILE: simpleTypeAlias.kt
-    unknown final interface B() {
+    (resolved) unknown final interface B() {
     }
-    unknown final typealias C = R/<root>.B/
+    (resolved) unknown final typealias C = R/<root>.B/
-    unknown final class D() : R/<root>.C = <root>.B/ {
+    (resolved) unknown final class D() : R/<root>.C = <root>.B/ {
     }