From 3e7b9c4e2713b96f174801e41f75e304ec4af6e0 Mon Sep 17 00:00:00 2001 From: Simon Ogorodnik Date: Tue, 20 Mar 2018 01:25:51 +0300 Subject: [PATCH] FIR: introduce type resolvers #KT-24019 Fixed --- ...sifierDescriptor.kt => ConeDescriptors.kt} | 0 .../jetbrains/kotlin/fir/types/impl/Impl.kt | 2 +- .../descriptors/ConeClassDescriptorImpl.kt | 21 +++++ .../FirClassifierResolveTransformer.kt | 80 +++++++++++++++++++ .../fir/resolve/FirQualifierResolver.kt | 21 +++++ .../fir/resolve/FirQualifierResolverImpl.kt | 61 ++++++++++++++ .../kotlin/fir/resolve/FirTypeResolver.kt | 12 ++- .../fir/resolve/impl/FirTypeResolverImpl.kt | 31 +++++++ .../org/jetbrains/kotlin/fir/FirRenderer.kt | 7 +- .../fir/declarations/FirResolvedClass.kt | 10 +++ .../declarations/impl/FirResolvedClassImpl.kt | 19 +++++ .../fir/visitors/FirTransformerGenerated.kt | 8 ++ .../fir/visitors/FirVisitorGenerated.kt | 4 + .../fir/visitors/FirVisitorVoidGenerated.kt | 8 ++ compiler/testData/fir/resolve/F.kt | 4 + compiler/testData/fir/resolve/F.txt | 5 ++ compiler/tests-common/build.gradle.kts | 2 + compiler/tests-common/build.gradle.kts.173 | 2 + compiler/tests-common/build.gradle.kts.181 | 2 + .../kotlin/fir/AbstractFirResolveTestCase.kt | 52 ++++++++++++ .../fir/FirResolveTestCaseGenerated.java | 33 ++++++++ .../generators/tests/GenerateCompilerTests.kt | 5 ++ 22 files changed, 386 insertions(+), 3 deletions(-) rename compiler/fir/cones/src/org/jetbrains/kotlin/fir/descriptors/{ConeClassifierDescriptor.kt => ConeDescriptors.kt} (100%) create mode 100644 compiler/fir/resolve/src/org/jetbrains/kotlin/descriptors/ConeClassDescriptorImpl.kt create mode 100644 compiler/fir/resolve/src/org/jetbrains/kotlin/descriptors/FirClassifierResolveTransformer.kt create mode 100644 compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirQualifierResolver.kt create mode 100644 compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirQualifierResolverImpl.kt create mode 100644 compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirTypeResolverImpl.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirResolvedClass.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirResolvedClassImpl.kt create mode 100644 compiler/testData/fir/resolve/F.kt create mode 100644 compiler/testData/fir/resolve/F.txt create mode 100644 compiler/tests/org/jetbrains/kotlin/fir/AbstractFirResolveTestCase.kt create mode 100644 compiler/tests/org/jetbrains/kotlin/fir/FirResolveTestCaseGenerated.java diff --git a/compiler/fir/cones/src/org/jetbrains/kotlin/fir/descriptors/ConeClassifierDescriptor.kt b/compiler/fir/cones/src/org/jetbrains/kotlin/fir/descriptors/ConeDescriptors.kt similarity index 100% rename from compiler/fir/cones/src/org/jetbrains/kotlin/fir/descriptors/ConeClassifierDescriptor.kt rename to compiler/fir/cones/src/org/jetbrains/kotlin/fir/descriptors/ConeDescriptors.kt diff --git a/compiler/fir/cones/src/org/jetbrains/kotlin/fir/types/impl/Impl.kt b/compiler/fir/cones/src/org/jetbrains/kotlin/fir/types/impl/Impl.kt index 5f7f4f34e84..391aadc3c35 100644 --- a/compiler/fir/cones/src/org/jetbrains/kotlin/fir/types/impl/Impl.kt +++ b/compiler/fir/cones/src/org/jetbrains/kotlin/fir/types/impl/Impl.kt @@ -13,7 +13,7 @@ class ConeClassTypeImpl( override val typeArguments: List ) : ConeClassType() -class NewKotlinTypeProjectionInImpl(override val type: ConeKotlinType) : ConeKotlinTypeProjectionIn() +class ConeKotlinTypeProjectionInImpl(override val type: ConeKotlinType) : ConeKotlinTypeProjectionIn() class ConeKotlinTypeProjectionOutImpl(override val type: ConeKotlinType) : ConeKotlinTypeProjectionOut() diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/descriptors/ConeClassDescriptorImpl.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/descriptors/ConeClassDescriptorImpl.kt new file mode 100644 index 00000000000..b434c8aa098 --- /dev/null +++ b/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, + override val fqName: UnambiguousFqName, + override val superTypes: List, + override val nestedClassifiers: List +) : ConeClassDescriptor, AbstractFirBasedDescriptor() { +} \ No newline at end of file diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/descriptors/FirClassifierResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/descriptors/FirClassifierResolveTransformer.kt new file mode 100644 index 00000000000..31ce397b465 --- /dev/null +++ b/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() { + override fun transformElement(element: E, data: Nothing?): CompositeTransformResult { + return element.compose() + } + + lateinit var packageFqName: FqNameUnsafe + + override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult { + 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 { + 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 { + return resolvedType.compose() + } + + var className: FqName = FqName.ROOT + + override fun transformClass(klass: FirClass, data: Nothing?): CompositeTransformResult { + 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>().mapNotNull { it.descriptor as? ConeTypeParameterDescriptor } + + val nestedClassifiers = + klass.declarations.filterIsInstance>().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 { + return resolvedClass.compose() + } +} \ No newline at end of file diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirQualifierResolver.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirQualifierResolver.kt new file mode 100644 index 00000000000..74259ce7584 --- /dev/null +++ b/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): ConeKotlinType? + + companion object { + fun getInstance(session: FirSession): FirQualifierResolver = session.service() + } +} + diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirQualifierResolverImpl.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirQualifierResolverImpl.kt new file mode 100644 index 00000000000..f232febb736 --- /dev/null +++ b/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): ConeKotlinType? { + val firProvider = FirProvider.getInstance(session) + + if (parts.isNotEmpty()) { + val lastPart = mutableListOf() + 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.toFqNameUnsafe() = toFqName().toUnsafe() + private fun List.toFqName() = fold(FqName.ROOT) { a, b -> a.child(b.name) } + + +} \ No newline at end of file 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 56abdb2fdd0..57190ee47a0 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 @@ -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() + } } \ No newline at end of file diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirTypeResolverImpl.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirTypeResolverImpl.kt new file mode 100644 index 00000000000..c754fd3b4c8 --- /dev/null +++ b/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("!") + } + } +} \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt index ed886a3961c..3febb638877 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt +++ b/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("") + } else { + sb.append(packageFqName.asString().replace('.', '/')) + } sb.append('.') sb.append(fqName.classFqName.asString()) sb.append(typeArguments.joinToString { it -> diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirResolvedClass.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirResolvedClass.kt new file mode 100644 index 00000000000..769f2405387 --- /dev/null +++ b/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 \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirResolvedClassImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirResolvedClassImpl.kt new file mode 100644 index 00000000000..163b6d0d697 --- /dev/null +++ b/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, FirClass by delegate { + + init { + descriptor.bind(this) + } + +} \ No newline at end of file diff --git a/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirTransformerGenerated.kt b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirTransformerGenerated.kt index 055000807c2..f61be433e01 100644 --- a/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirTransformerGenerated.kt +++ b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirTransformerGenerated.kt @@ -66,6 +66,10 @@ abstract class FirTransformer : FirVisitor { + return transformClass(resolvedClass, data) + } + open fun transformTypeAlias(typeAlias: FirTypeAlias, data: D): CompositeTransformResult { return transformMemberDeclaration(typeAlias, data) } @@ -246,6 +250,10 @@ abstract class FirTransformer : FirVisitor { + return transformResolvedClass(resolvedClass, data) + } + final override fun visitCallableMember(callableMember: FirCallableMember, data: D): CompositeTransformResult { return transformCallableMember(callableMember, data) } diff --git a/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorGenerated.kt b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorGenerated.kt index 7342006c509..f0f38803a8b 100644 --- a/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorGenerated.kt +++ b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorGenerated.kt @@ -66,6 +66,10 @@ abstract class FirVisitor { 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) } diff --git a/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorVoidGenerated.kt b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorVoidGenerated.kt index 62f2ef571fa..a9e2769307c 100644 --- a/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorVoidGenerated.kt +++ b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorVoidGenerated.kt @@ -66,6 +66,10 @@ abstract class FirVisitorVoid : FirVisitor() { 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() { visitEnumEntry(enumEntry) } + final override fun visitResolvedClass(resolvedClass: FirResolvedClass, data: Nothing?) { + visitResolvedClass(resolvedClass) + } + final override fun visitCallableMember(callableMember: FirCallableMember, data: Nothing?) { visitCallableMember(callableMember) } diff --git a/compiler/testData/fir/resolve/F.kt b/compiler/testData/fir/resolve/F.kt new file mode 100644 index 00000000000..3b2748ad007 --- /dev/null +++ b/compiler/testData/fir/resolve/F.kt @@ -0,0 +1,4 @@ +open class A + + +class B : A \ No newline at end of file diff --git a/compiler/testData/fir/resolve/F.txt b/compiler/testData/fir/resolve/F.txt new file mode 100644 index 00000000000..f720d9aa1a9 --- /dev/null +++ b/compiler/testData/fir/resolve/F.txt @@ -0,0 +1,5 @@ +FILE: F.kt + unknown open class A() { + } + unknown final class B() : R/.A/ { + } diff --git a/compiler/tests-common/build.gradle.kts b/compiler/tests-common/build.gradle.kts index 7f1b37d8379..bd6b0dc99bf 100644 --- a/compiler/tests-common/build.gradle.kts +++ b/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")) diff --git a/compiler/tests-common/build.gradle.kts.173 b/compiler/tests-common/build.gradle.kts.173 index 0a012972bf9..91c9f95304b 100644 --- a/compiler/tests-common/build.gradle.kts.173 +++ b/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")) diff --git a/compiler/tests-common/build.gradle.kts.181 b/compiler/tests-common/build.gradle.kts.181 index e166a4cd7bc..23ca6111713 100644 --- a/compiler/tests-common/build.gradle.kts.181 +++ b/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")) diff --git a/compiler/tests/org/jetbrains/kotlin/fir/AbstractFirResolveTestCase.kt b/compiler/tests/org/jetbrains/kotlin/fir/AbstractFirResolveTestCase.kt new file mode 100644 index 00000000000..7ce6b554685 --- /dev/null +++ b/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() as FirProviderImpl).recordFile(firFile) + + val transformer = FirClassifierResolveTransformer() + firFile.transform(transformer, null) + + val firFileDump = StringBuilder().also { firFile.accept(FirRenderer(it), null) }.toString() + val expectedPath = path.replace(".kt", ".txt") + KotlinTestUtils.assertEqualsToFile(File(expectedPath), firFileDump) + } +} \ No newline at end of file diff --git a/compiler/tests/org/jetbrains/kotlin/fir/FirResolveTestCaseGenerated.java b/compiler/tests/org/jetbrains/kotlin/fir/FirResolveTestCaseGenerated.java new file mode 100644 index 00000000000..2d9b6bd42b7 --- /dev/null +++ b/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); + } +} diff --git a/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt b/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt index f944333a8c5..211d0a13f8a 100644 --- a/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt +++ b/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) { model("fir/rawBuilder", testMethod = "doRawFirTest") } + testClass { + model("fir/resolve") + } + testClass { model("codegen/bytecodeListing") }