FIR: introduce type resolvers #KT-24019 Fixed

compiler/fir/cones/src/org/jetbrains/kotlin/fir/types/impl/Impl.kt

@@ -13,7 +13,7 @@ class ConeClassTypeImpl(
     override val typeArguments: List<ConeKotlinTypeProjection>
 ) : ConeClassType()
 
-class NewKotlinTypeProjectionInImpl(override val type: ConeKotlinType) : ConeKotlinTypeProjectionIn()
+class ConeKotlinTypeProjectionInImpl(override val type: ConeKotlinType) : ConeKotlinTypeProjectionIn()
 
 class ConeKotlinTypeProjectionOutImpl(override val type: ConeKotlinType) : ConeKotlinTypeProjectionOut()
 

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

@@ -0,0 +1,21 @@
+/*
+ * 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.UnambiguousFqName
+import org.jetbrains.kotlin.fir.declarations.FirResolvedClass
+import org.jetbrains.kotlin.fir.descriptors.ConeClassDescriptor
+import org.jetbrains.kotlin.fir.descriptors.ConeClassifierDescriptor
+import org.jetbrains.kotlin.fir.descriptors.ConeTypeParameterDescriptor
+import org.jetbrains.kotlin.fir.types.ConeKotlinType
+
+class ConeClassDescriptorImpl(
+    override val typeParameters: List<ConeTypeParameterDescriptor>,
+    override val fqName: UnambiguousFqName,
+    override val superTypes: List<ConeKotlinType>,
+    override val nestedClassifiers: List<ConeClassifierDescriptor>
+) : ConeClassDescriptor, AbstractFirBasedDescriptor<FirResolvedClass>() {
+}

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

@@ -0,0 +1,80 @@
+/*
+ * 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.FirDescriptorOwner
+import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.UnambiguousFqName
+import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedClassImpl
+import org.jetbrains.kotlin.fir.descriptors.ConeClassifierDescriptor
+import org.jetbrains.kotlin.fir.descriptors.ConeTypeParameterDescriptor
+import org.jetbrains.kotlin.fir.resolve.FirTypeResolver
+import org.jetbrains.kotlin.fir.types.FirResolvedType
+import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeImpl
+import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
+import org.jetbrains.kotlin.fir.visitors.compose
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.name.FqNameUnsafe
+
+class FirClassifierResolveTransformer : FirTransformer<Nothing?>() {
+    override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> {
+        return element.compose()
+    }
+
+    lateinit var packageFqName: FqNameUnsafe
+
+    override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult<FirFile> {
+        packageFqName = file.packageFqName.toUnsafe()
+        return file.also { it.acceptChildren(this, null) }.compose()
+    }
+
+    // TODO: Extract to separate transformer?
+    override fun transformType(type: FirType, data: Nothing?): CompositeTransformResult<FirType> {
+        val typeResolver = FirTypeResolver.getInstance(type.session)
+        return FirResolvedTypeImpl(type.session, type.psi, typeResolver.resolveType(type), false, type.annotations).compose()
+    }
+
+    override fun transformResolvedType(resolvedType: FirResolvedType, data: Nothing?): CompositeTransformResult<FirType> {
+        return resolvedType.compose()
+    }
+
+    var className: FqName = FqName.ROOT
+
+    override fun transformClass(klass: FirClass, data: Nothing?): CompositeTransformResult<FirDeclaration> {
+        val actualClassName = className.child(klass.name)
+        className = actualClassName
+
+        klass.transformChildren(this, data)
+
+        val superTypes = klass.superTypes.map {
+            (it as FirResolvedType).type
+        }
+
+        className = className.parent()
+
+        val typeParameters =
+            klass.typeParameters.filterIsInstance<FirDescriptorOwner<*>>().mapNotNull { it.descriptor as? ConeTypeParameterDescriptor }
+
+        val nestedClassifiers =
+            klass.declarations.filterIsInstance<FirDescriptorOwner<*>>().mapNotNull { it.descriptor as? ConeClassifierDescriptor }
+
+        val descriptor = ConeClassDescriptorImpl(
+            typeParameters,
+            UnambiguousFqName(packageFqName, actualClassName),
+            superTypes,
+            nestedClassifiers
+        )
+
+        return FirResolvedClassImpl(klass, descriptor).compose()
+    }
+
+    override fun transformResolvedClass(resolvedClass: FirResolvedClass, data: Nothing?): CompositeTransformResult<FirDeclaration> {
+        return resolvedClass.compose()
+    }
+}

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

@@ -0,0 +1,21 @@
+/*
+ * 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.resolve
+
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.service
+import org.jetbrains.kotlin.fir.types.ConeKotlinType
+import org.jetbrains.kotlin.fir.types.FirQualifierPart
+
+interface FirQualifierResolver {
+
+    fun resolveType(parts: List<FirQualifierPart>): ConeKotlinType?
+
+    companion object {
+        fun getInstance(session: FirSession): FirQualifierResolver = session.service()
+    }
+}
+

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

@@ -0,0 +1,61 @@
+/*
+ * 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.resolve
+
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.UnambiguousFqName
+import org.jetbrains.kotlin.fir.types.*
+import org.jetbrains.kotlin.fir.types.impl.ConeClassTypeImpl
+import org.jetbrains.kotlin.fir.types.impl.ConeKotlinTypeProjectionInImpl
+import org.jetbrains.kotlin.fir.types.impl.ConeKotlinTypeProjectionOutImpl
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.types.Variance
+
+class FirQualifierResolverImpl(val session: FirSession) : FirQualifierResolver {
+    override fun resolveType(parts: List<FirQualifierPart>): ConeKotlinType? {
+        val firProvider = FirProvider.getInstance(session)
+
+        if (parts.isNotEmpty()) {
+            val lastPart = mutableListOf<FirQualifierPart>()
+            val firstPart = parts.toMutableList()
+
+            while (firstPart.isNotEmpty()) {
+                lastPart.add(0, firstPart.last())
+                firstPart.removeAt(firstPart.lastIndex)
+
+                val fqName = UnambiguousFqName(firstPart.toFqNameUnsafe(), lastPart.toFqName())
+                val foundClassifier = firProvider.getFirClassifierByFqName(fqName)
+
+                if (foundClassifier != null) {
+                    return ConeClassTypeImpl(fqName, parts.flatMap {
+                        it.typeArguments.map {
+                            when (it) {
+                                is FirStarProjection -> StarProjection
+                                is FirTypeProjectionWithVariance -> {
+                                    val type = (it.type as FirResolvedType).type
+                                    when (it.variance) {
+                                        Variance.INVARIANT -> type
+                                        Variance.IN_VARIANCE -> ConeKotlinTypeProjectionInImpl(type)
+                                        Variance.OUT_VARIANCE -> ConeKotlinTypeProjectionOutImpl(type)
+                                    }
+                                }
+                                else -> error("!")
+                            }
+                        }
+                    })
+                }
+            }
+            return null
+        } else {
+            return null
+        }
+    }
+
+    private fun List<FirQualifierPart>.toFqNameUnsafe() = toFqName().toUnsafe()
+    private fun List<FirQualifierPart>.toFqName() = fold(FqName.ROOT) { a, b -> a.child(b.name) }
+
+
+}

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

@@ -5,6 +5,16 @@
 
 package org.jetbrains.kotlin.fir.resolve
 
-class FirTypeResolver {
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.service
+import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.ConeKotlinType
 
+interface FirTypeResolver {
+
+    fun resolveType(type: FirType): ConeKotlinType
+
+    companion object {
+        fun getInstance(session: FirSession): FirTypeResolver = session.service()
+    }
 }

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

@@ -0,0 +1,31 @@
+/*
+ * 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.resolve.impl
+
+import org.jetbrains.kotlin.fir.resolve.FirQualifierResolver
+import org.jetbrains.kotlin.fir.resolve.FirTypeResolver
+import org.jetbrains.kotlin.fir.types.*
+import org.jetbrains.kotlin.fir.types.impl.ConeKotlinErrorType
+
+class FirTypeResolverImpl : FirTypeResolver {
+    override fun resolveType(type: FirType): ConeKotlinType {
+        return when (type) {
+            is FirResolvedType -> type.type
+            is FirUserType -> {
+                val qualifierResolver = FirQualifierResolver.getInstance(type.session)
+                // TODO: Imports
+                qualifierResolver.resolveType(type.qualifier) ?: ConeKotlinErrorType("Failed to resolve qualified type")
+            }
+            is FirErrorType -> {
+                ConeKotlinErrorType(type.reason)
+            }
+            is FirFunctionType, is FirDynamicType, is FirImplicitType, is FirDelegatedType -> {
+                ConeKotlinErrorType("Not supported: $type")
+            }
+            else -> error("!")
+        }
+    }
+}

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

@@ -371,7 +371,12 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
             is ConeClassType -> {
                 val sb = StringBuilder()
                 val fqName = fqName
-                sb.append(fqName.packageFqName.asString().replace('.', '/'))
+                val packageFqName = fqName.packageFqName
+                if (packageFqName.isRoot) {
+                    sb.append("<root>")
+                } else {
+                    sb.append(packageFqName.asString().replace('.', '/'))
+                }
                 sb.append('.')
                 sb.append(fqName.classFqName.asString())
                 sb.append(typeArguments.joinToString { it ->

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

@@ -0,0 +1,10 @@
+/*
+ * 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
+
+interface FirResolvedClass : FirClass, FirDescriptorOwner<FirResolvedClass>

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

@@ -0,0 +1,19 @@
+/*
+ * 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.FirClass
+import org.jetbrains.kotlin.fir.declarations.FirResolvedClass
+
+class FirResolvedClassImpl(val delegate: FirClass, override val descriptor: FirBasedDescriptor<FirResolvedClass>) :
+    FirResolvedClass, FirClass by delegate {
+
+    init {
+        descriptor.bind(this)
+    }
+
+}

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

@@ -66,6 +66,10 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformClass(enumEntry, data)
     }
 
+    open fun transformResolvedClass(resolvedClass: FirResolvedClass, data: D): CompositeTransformResult<FirDeclaration> {
+        return transformClass(resolvedClass, data)
+    }
+
     open fun transformTypeAlias(typeAlias: FirTypeAlias, data: D): CompositeTransformResult<FirDeclaration> {
         return transformMemberDeclaration(typeAlias, data)
     }
@@ -246,6 +250,10 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformEnumEntry(enumEntry, data)
     }
 
+    final override fun visitResolvedClass(resolvedClass: FirResolvedClass, data: D): CompositeTransformResult<FirElement> {
+        return transformResolvedClass(resolvedClass, data)
+    }
+
     final override fun visitCallableMember(callableMember: FirCallableMember, data: D): CompositeTransformResult<FirElement> {
         return transformCallableMember(callableMember, data)
     }

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

@@ -66,6 +66,10 @@ abstract class FirVisitor<out R, in D> {
         return visitClass(enumEntry, data)
     }
 
+    open fun visitResolvedClass(resolvedClass: FirResolvedClass, data: D): R {
+        return visitClass(resolvedClass, data)
+    }
+
     open fun visitTypeAlias(typeAlias: FirTypeAlias, data: D): R {
         return visitMemberDeclaration(typeAlias, data)
     }

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

@@ -66,6 +66,10 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitClass(enumEntry, null)
     }
 
+    open fun visitResolvedClass(resolvedClass: FirResolvedClass) {
+        visitClass(resolvedClass, null)
+    }
+
     open fun visitTypeAlias(typeAlias: FirTypeAlias) {
         visitMemberDeclaration(typeAlias, null)
     }
@@ -246,6 +250,10 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitEnumEntry(enumEntry)
     }
 
+    final override fun visitResolvedClass(resolvedClass: FirResolvedClass, data: Nothing?) {
+        visitResolvedClass(resolvedClass)
+    }
+
     final override fun visitCallableMember(callableMember: FirCallableMember, data: Nothing?) {
         visitCallableMember(callableMember)
     }

compiler/testData/fir/resolve/F.kt

@@ -0,0 +1,4 @@
+open class A
+
+
+class B : A

compiler/testData/fir/resolve/F.txt

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

compiler/tests-common/build.gradle.kts

@@ -12,6 +12,8 @@ dependencies {
     testCompile(project(":compiler:backend"))
     testCompile(project(":compiler:fir:tree"))
     testCompile(project(":compiler:fir:psi2fir"))
+    testCompile(project(":compiler:fir:cones"))
+    testCompile(project(":compiler:fir:resolve"))
     testCompile(project(":compiler:ir.ir2cfg"))
     testCompile(project(":compiler:frontend"))
     testCompile(project(":compiler:frontend.java"))

compiler/tests-common/build.gradle.kts.173

@@ -12,6 +12,8 @@ dependencies {
     testCompile(project(":compiler:backend"))
     testCompile(project(":compiler:fir:tree"))
     testCompile(project(":compiler:fir:psi2fir"))
+    testCompile(project(":compiler:fir:cones"))
+    testCompile(project(":compiler:fir:resolve"))
     testCompile(project(":compiler:ir.ir2cfg"))
     testCompile(project(":compiler:frontend"))
     testCompile(project(":compiler:frontend.java"))

compiler/tests-common/build.gradle.kts.181

@@ -12,6 +12,8 @@ dependencies {
     testCompile(project(":compiler:backend"))
     testCompile(project(":compiler:fir:tree"))
     testCompile(project(":compiler:fir:psi2fir"))
+    testCompile(project(":compiler:fir:cones"))
+    testCompile(project(":compiler:fir:resolve"))
     testCompile(project(":compiler:ir.ir2cfg"))
     testCompile(project(":compiler:frontend"))
     testCompile(project(":compiler:frontend.java"))

compiler/tests/org/jetbrains/kotlin/fir/AbstractFirResolveTestCase.kt

@@ -0,0 +1,52 @@
+/*
+ * 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
+
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.descriptors.FirClassifierResolveTransformer
+import org.jetbrains.kotlin.fir.builder.RawFirBuilder
+import org.jetbrains.kotlin.fir.declarations.FirFile
+import org.jetbrains.kotlin.fir.resolve.*
+import org.jetbrains.kotlin.fir.resolve.impl.FirProviderImpl
+import org.jetbrains.kotlin.fir.resolve.impl.FirTypeResolverImpl
+import org.jetbrains.kotlin.test.ConfigurationKind
+import org.jetbrains.kotlin.test.KotlinTestUtils
+import org.jetbrains.kotlin.test.KotlinTestWithEnvironment
+import java.io.File
+
+abstract class AbstractFirResolveTestCase : KotlinTestWithEnvironment() {
+    override fun createEnvironment(): KotlinCoreEnvironment {
+        return createEnvironmentWithMockJdk(ConfigurationKind.JDK_NO_RUNTIME)
+    }
+
+    fun doTest(path: String) {
+        val file = File(path)
+        val text = KotlinTestUtils.doLoadFile(file)
+
+        val ktFile = KotlinTestUtils.createFile(file.name, text, project)
+
+
+        val session = object : FirSessionBase() {
+            init {
+                registerComponent(FirProvider::class, FirProviderImpl(this))
+                registerComponent(FirQualifierResolver::class, FirQualifierResolverImpl(this))
+                registerComponent(FirTypeResolver::class, FirTypeResolverImpl())
+            }
+        }
+
+        val builder = RawFirBuilder(session)
+        val firFile = builder.buildFirFile(ktFile)
+
+        (session.service<FirProvider>() as FirProviderImpl).recordFile(firFile)
+
+        val transformer = FirClassifierResolveTransformer()
+        firFile.transform<FirFile, Nothing?>(transformer, null)
+
+        val firFileDump = StringBuilder().also { firFile.accept(FirRenderer(it), null) }.toString()
+        val expectedPath = path.replace(".kt", ".txt")
+        KotlinTestUtils.assertEqualsToFile(File(expectedPath), firFileDump)
+    }
+}

compiler/tests/org/jetbrains/kotlin/fir/FirResolveTestCaseGenerated.java

@@ -0,0 +1,33 @@
+/*
+ * 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;
+
+import com.intellij.testFramework.TestDataPath;
+import org.jetbrains.kotlin.test.JUnit3RunnerWithInners;
+import org.jetbrains.kotlin.test.KotlinTestUtils;
+import org.jetbrains.kotlin.test.TargetBackend;
+import org.jetbrains.kotlin.test.TestMetadata;
+import org.junit.runner.RunWith;
+
+import java.io.File;
+import java.util.regex.Pattern;
+
+/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */
+@SuppressWarnings("all")
+@TestMetadata("compiler/testData/fir/resolve")
+@TestDataPath("$PROJECT_ROOT")
+@RunWith(JUnit3RunnerWithInners.class)
+public class FirResolveTestCaseGenerated extends AbstractFirResolveTestCase {
+    public void testAllFilesPresentInResolve() throws Exception {
+        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/fir/resolve"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+    }
+
+    @TestMetadata("F.kt")
+    public void testF() throws Exception {
+        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/fir/resolve/F.kt");
+        doTest(fileName);
+    }
+}

compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt

@@ -17,6 +17,7 @@ import org.jetbrains.kotlin.codegen.*
 import org.jetbrains.kotlin.codegen.defaultConstructor.AbstractDefaultArgumentsReflectionTest
 import org.jetbrains.kotlin.codegen.flags.AbstractWriteFlagsTest
 import org.jetbrains.kotlin.codegen.ir.*
+import org.jetbrains.kotlin.fir.AbstractFirResolveTestCase
 import org.jetbrains.kotlin.fir.builder.AbstractRawFirBuilderTestCase
 import org.jetbrains.kotlin.generators.tests.generator.testGroup
 import org.jetbrains.kotlin.generators.util.KT_OR_KTS_WITHOUT_DOTS_IN_NAME
@@ -202,6 +203,10 @@ fun main(args: Array<String>) {
             model("fir/rawBuilder", testMethod = "doRawFirTest")
         }
 
+        testClass<AbstractFirResolveTestCase> {
+            model("fir/resolve")
+        }
+
         testClass<AbstractBytecodeListingTest> {
             model("codegen/bytecodeListing")
         }