From d15fb1963bece9f995292354e1728149831cb088 Mon Sep 17 00:00:00 2001 From: Mikhail Glukhikh Date: Wed, 21 Mar 2018 17:46:28 +0300 Subject: [PATCH] FIR: introduce symbols + type parameter resolve #KT-24064 Fixed --- .../kotlin/fir/descriptors/ConeDescriptors.kt | 8 ++- .../kotlin/fir/symbols/ConeSymbols.kt | 16 +++++ .../types/{ConeKotlinType.kt => ConeTypes.kt} | 26 +++++--- .../jetbrains/kotlin/fir/types/impl/Impl.kt | 21 ++++--- .../kotlin/fir/builder/RawFirBuilder.kt | 6 +- .../descriptors/ConeClassDescriptorImpl.kt | 2 +- .../ConeTypeAliasDescriptorImpl.kt | 2 +- .../ConeTypeParameterDescriptorImpl.kt | 15 +++++ .../FirClassifierResolveTransformer.kt | 43 +++++++++++-- .../descriptors/FirTypeResolveTransformer.kt | 63 ++++++++++++------- .../kotlin/fir/resolve/FirProvider.kt | 10 ++- .../fir/resolve/impl/FirProviderImpl.kt | 17 +++-- .../resolve/impl/FirQualifierResolverImpl.kt | 22 +++---- .../fir/resolve/impl/FirTypeResolverImpl.kt | 16 ++++- .../jetbrains/kotlin/fir/scopes/FirScope.kt | 4 +- .../impl/FirClassLikeTypeParameterScope.kt | 26 ++++++++ .../fir/scopes/impl/FirCompositeScope.kt | 4 +- .../scopes/impl/FirExplicitImportingScope.kt | 7 ++- .../scopes/impl/FirNestedClassifierScope.kt | 6 +- .../fir/scopes/impl/FirSelfImportingScope.kt | 12 ++-- .../org/jetbrains/kotlin/fir/FirRenderer.kt | 47 +++++++++----- .../declarations/FirResolvedTypeParameter.kt | 15 +++++ .../fir/declarations/FirTypeParameter.kt | 8 ++- .../impl/FirResolvedTypeParameterImpl.kt | 29 +++++++++ .../fir/declarations/impl/FirTypeAliasImpl.kt | 2 + .../declarations/impl/FirTypeParameterImpl.kt | 18 +++++- .../fir/symbols/AbstractFirBasedSymbol.kt | 17 +++++ .../kotlin/fir/symbols/FirBasedSymbol.kt | 14 +++++ .../kotlin/fir/symbols/FirSymbolOwner.kt | 12 ++++ .../symbols/impl/FirTypeParameterSymbol.kt | 12 ++++ .../kotlin/fir/types/FirResolvedType.kt | 2 +- .../kotlin/fir/types/impl/FirBuiltinType.kt | 4 +- .../fir/types/impl/FirFunctionTypeImpl.kt | 16 ++++- .../impl/FirTypeProjectionWithVarianceImpl.kt | 13 +++- .../kotlin/fir/types/impl/FirUserTypeImpl.kt | 13 ++++ .../fir/visitors/FirTransformerGenerated.kt | 16 +++-- .../fir/visitors/FirVisitorGenerated.kt | 4 ++ .../fir/visitors/FirVisitorVoidGenerated.kt | 16 +++-- .../declarations/genericFunctions.txt | 2 +- .../rawBuilder/declarations/simpleClass.txt | 2 +- .../declarations/typeAliasWithGeneric.txt | 2 +- compiler/testData/fir/resolve/F.txt | 2 +- .../fir/resolve/NestedOfAliasedType.txt | 6 +- .../testData/fir/resolve/NestedSuperType.txt | 8 +-- .../fir/resolve/TwoDeclarationsInSameFile.txt | 2 +- .../fir/resolve/multifile/NestedSuperType.txt | 6 +- .../resolve/multifile/simpleAliasedImport.txt | 2 +- .../fir/resolve/multifile/simpleImport.txt | 2 +- .../resolve/multifile/simpleImportNested.txt | 2 +- .../resolve/multifile/simpleImportOuter.txt | 2 +- compiler/testData/fir/resolve/simpleClass.txt | 4 +- .../testData/fir/resolve/simpleTypeAlias.txt | 4 +- .../fir/resolve/typeAliasWithGeneric.kt | 7 +++ .../fir/resolve/typeAliasWithGeneric.txt | 8 +++ .../fir/resolve/typeParameterVsNested.kt | 17 +++++ .../fir/resolve/typeParameterVsNested.txt | 22 +++++++ .../fir/FirResolveTestCaseGenerated.java | 12 ++++ 57 files changed, 549 insertions(+), 147 deletions(-) create mode 100644 compiler/fir/cones/src/org/jetbrains/kotlin/fir/symbols/ConeSymbols.kt rename compiler/fir/cones/src/org/jetbrains/kotlin/fir/types/{ConeKotlinType.kt => ConeTypes.kt} (53%) create mode 100644 compiler/fir/resolve/src/org/jetbrains/kotlin/descriptors/ConeTypeParameterDescriptorImpl.kt create mode 100644 compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassLikeTypeParameterScope.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirResolvedTypeParameter.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirResolvedTypeParameterImpl.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/AbstractFirBasedSymbol.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/FirBasedSymbol.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/FirSymbolOwner.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirTypeParameterSymbol.kt create mode 100644 compiler/testData/fir/resolve/typeAliasWithGeneric.kt create mode 100644 compiler/testData/fir/resolve/typeAliasWithGeneric.txt create mode 100644 compiler/testData/fir/resolve/typeParameterVsNested.kt create mode 100644 compiler/testData/fir/resolve/typeParameterVsNested.txt diff --git a/compiler/fir/cones/src/org/jetbrains/kotlin/fir/descriptors/ConeDescriptors.kt b/compiler/fir/cones/src/org/jetbrains/kotlin/fir/descriptors/ConeDescriptors.kt index af34b9d0687..a134726ef67 100644 --- a/compiler/fir/cones/src/org/jetbrains/kotlin/fir/descriptors/ConeDescriptors.kt +++ b/compiler/fir/cones/src/org/jetbrains/kotlin/fir/descriptors/ConeDescriptors.kt @@ -5,10 +5,10 @@ package org.jetbrains.kotlin.fir.descriptors +import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterSymbol import org.jetbrains.kotlin.fir.types.ConeKotlinType import org.jetbrains.kotlin.name.ClassId - interface ConeDescriptor interface ConeClassifierDescriptor : ConeDescriptor @@ -16,10 +16,12 @@ interface ConeClassifierDescriptor : ConeDescriptor interface ConeClassifierDescriptorWithTypeParameters : ConeClassifierDescriptor { val typeParameters: List - val fqName: ClassId + val classId: ClassId } -interface ConeTypeParameterDescriptor : ConeClassifierDescriptor +interface ConeTypeParameterDescriptor : ConeClassifierDescriptor { + val symbol: ConeTypeParameterSymbol +} interface ConeTypeAliasDescriptor : ConeClassifierDescriptorWithTypeParameters { val expandedType: ConeKotlinType diff --git a/compiler/fir/cones/src/org/jetbrains/kotlin/fir/symbols/ConeSymbols.kt b/compiler/fir/cones/src/org/jetbrains/kotlin/fir/symbols/ConeSymbols.kt new file mode 100644 index 00000000000..f55c882870b --- /dev/null +++ b/compiler/fir/cones/src/org/jetbrains/kotlin/fir/symbols/ConeSymbols.kt @@ -0,0 +1,16 @@ +/* + * 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.symbols + +import org.jetbrains.kotlin.name.ClassId + +interface ConeSymbol + +interface ConeTypeParameterSymbol : ConeSymbol + +class ConeClassLikeSymbol(val classId: ClassId) : ConeSymbol + +fun ClassId.toSymbol() = ConeClassLikeSymbol(this) diff --git a/compiler/fir/cones/src/org/jetbrains/kotlin/fir/types/ConeKotlinType.kt b/compiler/fir/cones/src/org/jetbrains/kotlin/fir/types/ConeTypes.kt similarity index 53% rename from compiler/fir/cones/src/org/jetbrains/kotlin/fir/types/ConeKotlinType.kt rename to compiler/fir/cones/src/org/jetbrains/kotlin/fir/types/ConeTypes.kt index 9dc11c92377..b289e5bb615 100644 --- a/compiler/fir/cones/src/org/jetbrains/kotlin/fir/types/ConeKotlinType.kt +++ b/compiler/fir/cones/src/org/jetbrains/kotlin/fir/types/ConeTypes.kt @@ -5,7 +5,9 @@ package org.jetbrains.kotlin.fir.types -import org.jetbrains.kotlin.name.ClassId +import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol +import org.jetbrains.kotlin.fir.symbols.ConeSymbol +import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterSymbol sealed class ConeKotlinTypeProjection(val kind: ProjectionKind) @@ -24,16 +26,24 @@ abstract class ConeKotlinTypeProjectionOut : ConeKotlinTypeProjection(Projection abstract val type: ConeKotlinType } -abstract class ConeKotlinType : ConeKotlinTypeProjection(ProjectionKind.INVARIANT) { +abstract class ConeKotlinType : ConeKotlinTypeProjection(ProjectionKind.INVARIANT) + +abstract class ConeSymbolBasedType : ConeKotlinType() { + abstract val symbol: ConeSymbol +} + +abstract class ConeClassLikeType : ConeSymbolBasedType() { + abstract override val symbol: ConeClassLikeSymbol + abstract val typeArguments: List } -abstract class ConeClassType : ConeKotlinType() { - abstract val fqName: ClassId +abstract class ConeAbbreviatedType : ConeClassLikeType() { + abstract val abbreviationSymbol: ConeClassLikeSymbol + + abstract val directExpansion: ConeClassLikeType } -abstract class ConeAbbreviatedType : ConeClassType() { - abstract val abbreviationFqName: ClassId - - abstract val directExpansion: ConeKotlinType +abstract class ConeTypeParameterType : ConeSymbolBasedType() { + abstract override val symbol: ConeTypeParameterSymbol } \ No newline at end of file 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 cff1f392043..2cbae356c81 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 @@ -5,21 +5,20 @@ package org.jetbrains.kotlin.fir.types.impl +import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol +import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterSymbol import org.jetbrains.kotlin.fir.types.* -import org.jetbrains.kotlin.name.ClassId open class ConeClassTypeImpl( - override val fqName: ClassId, + override val symbol: ConeClassLikeSymbol, override val typeArguments: List -) : ConeClassType() +) : ConeClassLikeType() class ConeKotlinTypeProjectionInImpl(override val type: ConeKotlinType) : ConeKotlinTypeProjectionIn() class ConeKotlinTypeProjectionOutImpl(override val type: ConeKotlinType) : ConeKotlinTypeProjectionOut() class ConeKotlinErrorType(val reason: String) : ConeKotlinType() { - override val typeArguments: List - get() = emptyList() override fun toString(): String { return "" @@ -27,10 +26,12 @@ class ConeKotlinErrorType(val reason: String) : ConeKotlinType() { } class ConeAbbreviatedTypeImpl( - override val abbreviationFqName: ClassId, + override val abbreviationSymbol: ConeClassLikeSymbol, override val typeArguments: List, - override val directExpansion: ConeKotlinType + override val directExpansion: ConeClassLikeType ) : ConeAbbreviatedType() { - override val fqName: ClassId - get() = abbreviationFqName -} \ No newline at end of file + override val symbol: ConeClassLikeSymbol + get() = abbreviationSymbol +} + +class ConeTypeParameterTypeImpl(override val symbol: ConeTypeParameterSymbol) : ConeTypeParameterType() \ No newline at end of file diff --git a/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt b/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt index 8a1efe20d50..b8123871bd1 100644 --- a/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt +++ b/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt @@ -17,6 +17,7 @@ import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirBody import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.impl.* +import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol import org.jetbrains.kotlin.fir.types.FirType import org.jetbrains.kotlin.fir.types.FirTypeProjection import org.jetbrains.kotlin.fir.types.impl.* @@ -274,6 +275,7 @@ class RawFirBuilder(val session: FirSession) { typeAlias.getTypeReference().toFirOrErrorType() ) typeAlias.extractAnnotationsTo(firTypeAlias) + typeAlias.extractTypeParametersTo(firTypeAlias) return firTypeAlias } @@ -433,7 +435,9 @@ class RawFirBuilder(val session: FirSession) { session, parameter, parameter.nameAsSafeName, - parameter.variance + parameter.variance, + parameter.hasModifier(KtTokens.REIFIED_KEYWORD), + FirTypeParameterSymbol() ) parameter.extractAnnotationsTo(firTypeParameter) val extendsBound = parameter.extendsBound diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/descriptors/ConeClassDescriptorImpl.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/descriptors/ConeClassDescriptorImpl.kt index 66b059062e2..7ab6471e0c0 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/descriptors/ConeClassDescriptorImpl.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/descriptors/ConeClassDescriptorImpl.kt @@ -14,7 +14,7 @@ import org.jetbrains.kotlin.name.ClassId class ConeClassDescriptorImpl( override val typeParameters: List, - override val fqName: ClassId, + override val classId: ClassId, 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/ConeTypeAliasDescriptorImpl.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/descriptors/ConeTypeAliasDescriptorImpl.kt index dafb9cd38e2..9b8ec5ccc6d 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/descriptors/ConeTypeAliasDescriptorImpl.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/descriptors/ConeTypeAliasDescriptorImpl.kt @@ -13,6 +13,6 @@ import org.jetbrains.kotlin.name.ClassId class ConeTypeAliasDescriptorImpl( override val typeParameters: List, - override val fqName: ClassId, + override val classId: ClassId, override val expandedType: ConeKotlinType ) : ConeTypeAliasDescriptor, AbstractFirBasedDescriptor() \ No newline at end of file diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/descriptors/ConeTypeParameterDescriptorImpl.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/descriptors/ConeTypeParameterDescriptorImpl.kt new file mode 100644 index 00000000000..a15a5127782 --- /dev/null +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/descriptors/ConeTypeParameterDescriptorImpl.kt @@ -0,0 +1,15 @@ +/* + * 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.FirResolvedTypeParameter +import org.jetbrains.kotlin.fir.descriptors.ConeTypeParameterDescriptor +import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterSymbol +import org.jetbrains.kotlin.name.Name + +class ConeTypeParameterDescriptorImpl( + override val symbol: ConeTypeParameterSymbol +) : ConeTypeParameterDescriptor, 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 index 3279a3f6bec..476577a4cfb 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/descriptors/FirClassifierResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/descriptors/FirClassifierResolveTransformer.kt @@ -10,14 +10,18 @@ import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedClassImpl import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedTypeAliasImpl +import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedTypeParameterImpl import org.jetbrains.kotlin.fir.descriptors.ConeClassifierDescriptor import org.jetbrains.kotlin.fir.descriptors.ConeTypeParameterDescriptor +import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterSymbol +import org.jetbrains.kotlin.fir.symbols.toSymbol import org.jetbrains.kotlin.fir.types.FirResolvedType 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.ClassId import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.name.Name class FirClassifierResolveTransformer : FirTransformer() { override fun transformElement(element: E, data: Nothing?): CompositeTransformResult { @@ -31,11 +35,11 @@ class FirClassifierResolveTransformer : FirTransformer() { return file.also { it.transformChildren(this, null) }.compose() } - var className: FqName = FqName.ROOT + private var classLikeName: FqName = FqName.ROOT override fun transformClass(klass: FirClass, data: Nothing?): CompositeTransformResult { - val actualClassName = className.child(klass.name) - className = actualClassName + val actualClassName = classLikeName.child(klass.name) + classLikeName = actualClassName klass.transformChildren(this, data) @@ -43,7 +47,7 @@ class FirClassifierResolveTransformer : FirTransformer() { (it as FirResolvedType).type } - className = className.parent() + classLikeName = classLikeName.parent() val typeParameters = klass.typeParameters.filterIsInstance>().mapNotNull { it.descriptor as? ConeTypeParameterDescriptor } @@ -65,15 +69,30 @@ class FirClassifierResolveTransformer : FirTransformer() { return resolvedClass.compose() } + var memberName: Name? = null + + override fun transformNamedFunction(namedFunction: FirNamedFunction, data: Nothing?): CompositeTransformResult { + memberName = namedFunction.name + return super.transformNamedFunction(namedFunction, data).also { + memberName = null + } + } + override fun transformTypeAlias(typeAlias: FirTypeAlias, data: Nothing?): CompositeTransformResult { + val actualClassName = classLikeName.child(typeAlias.name) + classLikeName = actualClassName + typeAlias.transformChildren(this, data) + + classLikeName = classLikeName.parent() + val expandedType = (typeAlias.expandedType as FirResolvedType).type val typeParameters = typeAlias.typeParameters.filterIsInstance>().mapNotNull { it.descriptor as? ConeTypeParameterDescriptor } val descriptor = ConeTypeAliasDescriptorImpl( typeParameters, - ClassId(packageFqName, className.child(typeAlias.name), false), + ClassId(packageFqName, classLikeName.child(typeAlias.name), false), expandedType ) @@ -86,4 +105,18 @@ class FirClassifierResolveTransformer : FirTransformer() { ): CompositeTransformResult { return resolvedTypeAlias.compose() } + + override fun transformResolvedTypeParameter( + resolvedTypeParameter: FirResolvedTypeParameter, + data: Nothing? + ): CompositeTransformResult { + return resolvedTypeParameter.compose() + } + + override fun transformTypeParameter(typeParameter: FirTypeParameter, data: Nothing?): CompositeTransformResult { + typeParameter.transformChildren(this, data) + + val descriptor = ConeTypeParameterDescriptorImpl(typeParameter.symbol) + return FirResolvedTypeParameterImpl(typeParameter, descriptor).compose() + } } \ No newline at end of file diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/descriptors/FirTypeResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/descriptors/FirTypeResolveTransformer.kt index 3964e4c1aa3..e198ee52651 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/descriptors/FirTypeResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/descriptors/FirTypeResolveTransformer.kt @@ -6,16 +6,11 @@ package org.jetbrains.kotlin.descriptors import org.jetbrains.kotlin.fir.FirElement -import org.jetbrains.kotlin.fir.declarations.FirClass -import org.jetbrains.kotlin.fir.declarations.FirDeclaration -import org.jetbrains.kotlin.fir.declarations.FirFile -import org.jetbrains.kotlin.fir.declarations.FirTypeAlias +import org.jetbrains.kotlin.fir.FirRenderer +import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.resolve.FirProvider import org.jetbrains.kotlin.fir.resolve.FirTypeResolver -import org.jetbrains.kotlin.fir.scopes.impl.FirCompositeScope -import org.jetbrains.kotlin.fir.scopes.impl.FirExplicitImportingScope -import org.jetbrains.kotlin.fir.scopes.impl.FirNestedClassifierScope -import org.jetbrains.kotlin.fir.scopes.impl.FirSelfImportingScope +import org.jetbrains.kotlin.fir.scopes.impl.* import org.jetbrains.kotlin.fir.transformSingle import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeImpl @@ -26,6 +21,8 @@ import org.jetbrains.kotlin.fir.visitors.compose import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName +fun FirElement.render(): String = buildString { this@render.accept(FirRenderer(this)) } + class FirTypeResolveTransformer(val superTypesOnly: Boolean = false) : FirTransformer() { override fun transformElement(element: E, data: Nothing?): CompositeTransformResult { return if (superTypesOnly) { @@ -37,7 +34,7 @@ class FirTypeResolveTransformer(val superTypesOnly: Boolean = false) : FirTransf lateinit var scope: FirCompositeScope lateinit var packageFqName: FqName - var className: FqName = FqName.ROOT + private var classLikeName: FqName = FqName.ROOT override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult { scope = FirCompositeScope( @@ -56,26 +53,48 @@ class FirTypeResolveTransformer(val superTypesOnly: Boolean = false) : FirTransf return superTypesBuilder.classes } - override fun transformClass(klass: FirClass, data: Nothing?): CompositeTransformResult { - klass.transformChildren(SuperTypeResolver(), null) - className = className.child(klass.name) + private fun resolveSuperTypesAndExpansions(element: FirMemberDeclaration) { + try { + element.transformChildren(SuperTypeResolver(), null) + } catch (e: Exception) { + class SuperTypeResolveException(cause: Exception) : Exception(element.render(), cause) + throw SuperTypeResolveException(e) + } + } - scope.scopes += FirNestedClassifierScope(ClassId(packageFqName, className, false), klass.session) - scope.scopes.addAll(lookupSuperTypes(klass).map { FirNestedClassifierScope(it, klass.session) }) + override fun transformClass(klass: FirClass, data: Nothing?): CompositeTransformResult { + classLikeName = classLikeName.child(klass.name) + val classId = ClassId(packageFqName, classLikeName, false) + scope = FirCompositeScope(mutableListOf(scope)) + scope.scopes += FirClassLikeTypeParameterScope(classId, klass.session) + resolveSuperTypesAndExpansions(klass) + + scope.scopes += FirNestedClassifierScope(classId, klass.session) + val superTypeScopes = lookupSuperTypes(klass).map { FirNestedClassifierScope(it, klass.session) } + scope.scopes.addAll(superTypeScopes) val result = super.transformClass(klass, data) - scope.scopes.also { it.removeAt(it.lastIndex) } - className = className.parent() + scope = scope.scopes[0] as FirCompositeScope + classLikeName = classLikeName.parent() return result } override fun transformTypeAlias(typeAlias: FirTypeAlias, data: Nothing?): CompositeTransformResult { - typeAlias.transformChildren(SuperTypeResolver(), null) + classLikeName = classLikeName.child(typeAlias.name) + val classId = ClassId(packageFqName, classLikeName, false) + scope = FirCompositeScope(mutableListOf(scope)) + scope.scopes += FirClassLikeTypeParameterScope(classId, typeAlias.session) + + resolveSuperTypesAndExpansions(typeAlias) + + scope = scope.scopes[0] as FirCompositeScope + classLikeName = classLikeName.parent() return super.transformTypeAlias(typeAlias, data) } override fun transformType(type: FirType, data: Nothing?): CompositeTransformResult { val typeResolver = FirTypeResolver.getInstance(type.session) + type.transformChildren(this, data) return FirResolvedTypeImpl( type.session, type.psi, @@ -98,7 +117,7 @@ class FirTypeResolveTransformer(val superTypesOnly: Boolean = false) : FirTransf override fun transformType(type: FirType, data: Nothing?): CompositeTransformResult { val transformedType = this@FirTypeResolveTransformer.transformType(type, data).single as FirResolvedType - val classId = (transformedType.type as? ConeClassType)?.fqName ?: return transformedType.compose() + val classId = (transformedType.type as? ConeClassLikeType)?.symbol?.classId ?: return transformedType.compose() val firProvider = FirProvider.getInstance(transformedType.session) val classes = generateSequence(classId) { it.outerClassId }.toList() @@ -123,10 +142,10 @@ class FirTypeResolveTransformer(val superTypesOnly: Boolean = false) : FirTransf return false } - private tailrec fun ConeClassType.computePartialExpansion(): ClassId { + private tailrec fun ConeClassLikeType.computePartialExpansion(): ClassId { return when (this) { - !is ConeAbbreviatedType -> this.fqName - else -> (this.directExpansion as ConeClassType).computePartialExpansion() + !is ConeAbbreviatedType -> this.symbol.classId + else -> this.directExpansion.computePartialExpansion() } } @@ -134,7 +153,7 @@ class FirTypeResolveTransformer(val superTypesOnly: Boolean = false) : FirTransf override fun visitResolvedType(resolvedType: FirResolvedType, data: Nothing?): Boolean { val provider = FirProvider.getInstance(resolvedType.session) - val targetClassId = resolvedType.coneTypeSafe()?.computePartialExpansion() ?: return false + val targetClassId = resolvedType.coneTypeSafe()?.computePartialExpansion() ?: return false val classifier = provider.getFirClassifierByFqName(targetClassId)!! when (classifier) { is FirClass -> { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirProvider.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirProvider.kt index d590c895c89..1a812cd087c 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirProvider.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirProvider.kt @@ -6,22 +6,20 @@ package org.jetbrains.kotlin.fir.resolve import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirFile import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration -import org.jetbrains.kotlin.fir.declarations.FirTypeParameter import org.jetbrains.kotlin.fir.service +import org.jetbrains.kotlin.fir.symbols.ConeSymbol import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName -import org.jetbrains.kotlin.name.Name interface FirProvider { - fun getFirClassifierByFqName(fqName: ClassId): FirMemberDeclaration? - - fun getFirTypeParameterByFqName(fqName: ClassId, parameterName: Name): FirTypeParameter? + fun getFirClassifierByFqName(fqName: ClassId): FirMemberDeclaration? // FirSymbol? fun getFirClassifierContainerFile(fqName: ClassId): FirFile + fun getFirClassifierBySymbol(symbol: ConeSymbol): FirMemberDeclaration? + companion object { fun getInstance(session: FirSession): FirProvider = session.service() } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirProviderImpl.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirProviderImpl.kt index c5353be4e92..3b0b4954af7 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirProviderImpl.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirProviderImpl.kt @@ -9,12 +9,22 @@ import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.resolve.FirProvider +import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol +import org.jetbrains.kotlin.fir.symbols.ConeSymbol +import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName -import org.jetbrains.kotlin.name.Name class FirProviderImpl(val session: FirSession) : FirProvider { + override fun getFirClassifierBySymbol(symbol: ConeSymbol): FirMemberDeclaration? { + return when(symbol) { + is FirBasedSymbol<*> -> symbol.fir as? FirMemberDeclaration + is ConeClassLikeSymbol -> getFirClassifierByFqName(symbol.classId) + else -> error("!") + } + } + override fun getFirClassifierContainerFile(fqName: ClassId): FirFile { return classifierContainerFileMap[fqName] ?: error("Couldn't find container for $fqName") } @@ -60,9 +70,4 @@ class FirProviderImpl(val session: FirSession) : FirProvider { return classifierMap[fqName] } - override fun getFirTypeParameterByFqName(fqName: ClassId, parameterName: Name): FirTypeParameter? { - val typeParameterContainer = (getFirClassifierByFqName(fqName) as? FirTypeParameterContainer) ?: return null - // TODO: Optimize search here - return typeParameterContainer.typeParameters.find { it.name == parameterName } - } } \ No newline at end of file diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirQualifierResolverImpl.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirQualifierResolverImpl.kt index 4641fddedef..f3014c66311 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirQualifierResolverImpl.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirQualifierResolverImpl.kt @@ -11,11 +11,9 @@ import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration import org.jetbrains.kotlin.fir.declarations.FirTypeAlias import org.jetbrains.kotlin.fir.resolve.FirProvider import org.jetbrains.kotlin.fir.resolve.FirQualifierResolver +import org.jetbrains.kotlin.fir.symbols.toSymbol import org.jetbrains.kotlin.fir.types.* -import org.jetbrains.kotlin.fir.types.impl.ConeAbbreviatedTypeImpl -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.fir.types.impl.* import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.types.Variance @@ -42,15 +40,17 @@ class FirQualifierResolverImpl(val session: FirSession) : FirQualifierResolver { private fun FirMemberDeclaration.toConeKotlinType(fqName: ClassId, parts: List): ConeKotlinType? { return when (this) { is FirClass -> { - ConeClassTypeImpl(fqName, parts.toTypeProjections()) + ConeClassTypeImpl(fqName.toSymbol(), parts.toTypeProjections()) } is FirTypeAlias -> { - ConeAbbreviatedTypeImpl( - abbreviationFqName = fqName, - typeArguments = parts.toTypeProjections(), - directExpansion = (this.expandedType as FirResolvedType).type - ) + val expansion = expandedType.coneTypeSafe() + ?: return ConeKotlinErrorType("Couldn't resolve expansion") + ConeAbbreviatedTypeImpl( + abbreviationSymbol = fqName.toSymbol(), + typeArguments = parts.toTypeProjections(), + directExpansion = expansion + ) } else -> error("!") } @@ -61,7 +61,7 @@ class FirQualifierResolverImpl(val session: FirSession) : FirQualifierResolver { val fqName = ClassId( prefix.packageFqName, - parts.fold(prefix.relativeClassName) { prefix, suffix -> prefix.child(suffix.name) }, + parts.drop(1).fold(prefix.relativeClassName) { prefix, suffix -> prefix.child(suffix.name) }, false ) val foundClassifier = firProvider.getFirClassifierByFqName(fqName) 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 index 3a5a3d70f0b..d0910dbe8ab 100644 --- 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 @@ -8,8 +8,11 @@ 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.scopes.FirScope +import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol +import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterSymbol import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.types.impl.ConeKotlinErrorType +import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl class FirTypeResolverImpl : FirTypeResolver { override fun resolveType(type: FirType, scope: FirScope): ConeKotlinType { @@ -20,8 +23,17 @@ class FirTypeResolverImpl : FirTypeResolver { val qualifierResolver = FirQualifierResolver.getInstance(type.session) var resolvedType: ConeKotlinType? = null - scope.processClassifiersByName(type.qualifier.first().name) { fqName -> - resolvedType = qualifierResolver.resolveTypeWithPrefix(type.qualifier.drop(1), fqName) + scope.processClassifiersByName(type.qualifier.first().name) { symbol -> + resolvedType = when (symbol) { + is ConeClassLikeSymbol -> { + qualifierResolver.resolveTypeWithPrefix(type.qualifier, symbol.classId) + } + is ConeTypeParameterSymbol -> { + assert(type.qualifier.size == 1) + ConeTypeParameterTypeImpl(symbol) + } + else -> error("!") + } resolvedType == null } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/FirScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/FirScope.kt index 78ee8082756..064720b075a 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/FirScope.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/FirScope.kt @@ -5,9 +5,9 @@ package org.jetbrains.kotlin.fir.scopes -import org.jetbrains.kotlin.name.ClassId +import org.jetbrains.kotlin.fir.symbols.ConeSymbol import org.jetbrains.kotlin.name.Name interface FirScope { - fun processClassifiersByName(name: Name, processor: (ClassId) -> Boolean): Boolean + fun processClassifiersByName(name: Name, processor: (ConeSymbol) -> Boolean): Boolean } \ No newline at end of file diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassLikeTypeParameterScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassLikeTypeParameterScope.kt new file mode 100644 index 00000000000..95d3f32e6de --- /dev/null +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassLikeTypeParameterScope.kt @@ -0,0 +1,26 @@ +/* + * 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.scopes.impl + +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.resolve.FirProvider +import org.jetbrains.kotlin.fir.scopes.FirScope +import org.jetbrains.kotlin.fir.symbols.ConeSymbol +import org.jetbrains.kotlin.name.ClassId +import org.jetbrains.kotlin.name.Name + +class FirClassLikeTypeParameterScope(val classId: ClassId, val session: FirSession) : FirScope { + + private val firProvider = FirProvider.getInstance(session) + + val typeParameters = firProvider.getFirClassifierByFqName(classId)?.typeParameters.orEmpty().groupBy { it.name } + + override fun processClassifiersByName(name: Name, processor: (ConeSymbol) -> Boolean): Boolean { + val matchedTypeParameters = typeParameters[name] ?: return true + + return matchedTypeParameters.all { processor(it.symbol) } + } +} \ No newline at end of file diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirCompositeScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirCompositeScope.kt index 305438a1929..83ed45329ce 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirCompositeScope.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirCompositeScope.kt @@ -6,11 +6,11 @@ package org.jetbrains.kotlin.fir.scopes.impl import org.jetbrains.kotlin.fir.scopes.FirScope -import org.jetbrains.kotlin.name.ClassId +import org.jetbrains.kotlin.fir.symbols.ConeSymbol import org.jetbrains.kotlin.name.Name class FirCompositeScope(val scopes: MutableList) : FirScope { - override fun processClassifiersByName(name: Name, processor: (ClassId) -> Boolean): Boolean { + override fun processClassifiersByName(name: Name, processor: (ConeSymbol) -> Boolean): Boolean { for (scope in scopes) { if (!scope.processClassifiersByName(name, processor)) { return false diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirExplicitImportingScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirExplicitImportingScope.kt index 3612967b21c..d497ad538a4 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirExplicitImportingScope.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirExplicitImportingScope.kt @@ -8,7 +8,8 @@ package org.jetbrains.kotlin.fir.scopes.impl import org.jetbrains.kotlin.fir.declarations.FirImport import org.jetbrains.kotlin.fir.declarations.FirResolvedImport import org.jetbrains.kotlin.fir.scopes.FirScope -import org.jetbrains.kotlin.name.ClassId +import org.jetbrains.kotlin.fir.symbols.ConeSymbol +import org.jetbrains.kotlin.fir.symbols.toSymbol import org.jetbrains.kotlin.name.Name class FirExplicitImportingScope(imports: List) : FirScope { @@ -19,10 +20,10 @@ class FirExplicitImportingScope(imports: List) : FirScope { .filter { !it.isAllUnder } .groupBy { it.aliasName ?: it.resolvedFqName.shortClassName } - override fun processClassifiersByName(name: Name, processor: (ClassId) -> Boolean): Boolean { + override fun processClassifiersByName(name: Name, processor: (ConeSymbol) -> Boolean): Boolean { val imports = simpleImports[name] ?: return true for (import in imports) { - if (!processor(import.resolvedFqName)) { + if (!processor(import.resolvedFqName.toSymbol())) { return false } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirNestedClassifierScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirNestedClassifierScope.kt index f7484e54911..82ea0399e4f 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirNestedClassifierScope.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirNestedClassifierScope.kt @@ -9,6 +9,8 @@ import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration import org.jetbrains.kotlin.fir.resolve.FirProvider import org.jetbrains.kotlin.fir.scopes.FirScope +import org.jetbrains.kotlin.fir.symbols.ConeSymbol +import org.jetbrains.kotlin.fir.symbols.toSymbol import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.Name @@ -20,8 +22,8 @@ class FirNestedClassifierScope(val classId: ClassId, val session: FirSession) : return firProvider.getFirClassifierByFqName(this) } - override fun processClassifiersByName(name: Name, processor: (ClassId) -> Boolean): Boolean { + override fun processClassifiersByName(name: Name, processor: (ConeSymbol) -> Boolean): Boolean { val child = ClassId(classId.packageFqName, classId.relativeClassName.child(name), false) - return child.getFir() == null || processor(child) + return child.getFir() == null || processor(child.toSymbol()) } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirSelfImportingScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirSelfImportingScope.kt index aa8cae7f15d..368dee13510 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirSelfImportingScope.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirSelfImportingScope.kt @@ -9,22 +9,22 @@ import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.resolve.FirProvider import org.jetbrains.kotlin.fir.scopes.FirScope import org.jetbrains.kotlin.fir.service +import org.jetbrains.kotlin.fir.symbols.ConeSymbol +import org.jetbrains.kotlin.fir.symbols.toSymbol import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name class FirSelfImportingScope(val fqName: FqName, val session: FirSession) : FirScope { - override fun processClassifiersByName(name: Name, processor: (ClassId) -> Boolean): Boolean { - - + override fun processClassifiersByName(name: Name, processor: (ConeSymbol) -> Boolean): Boolean { val unambiguousFqName = ClassId(fqName, name) val firProvider = session.service() - if (firProvider.getFirClassifierByFqName(unambiguousFqName) != null) { - return processor(unambiguousFqName) + return if (firProvider.getFirClassifierByFqName(unambiguousFqName) != null) { + processor(unambiguousFqName.toSymbol()) } else { - return true + true } } } \ 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 9ae8a2ae527..4db6af88a39 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt @@ -9,6 +9,9 @@ import org.jetbrains.kotlin.descriptors.Visibilities import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.expressions.* +import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol +import org.jetbrains.kotlin.fir.symbols.ConeSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.types.impl.ConeKotlinErrorType import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid @@ -293,6 +296,11 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() { println() } + override fun visitResolvedTypeParameter(resolvedTypeParameter: FirResolvedTypeParameter) { + print("(resolved) ") + visitTypeParameter(resolvedTypeParameter) + } + override fun visitTypeParameter(typeParameter: FirTypeParameter) { typeParameter.annotations.renderAnnotations() typeParameter.variance.renderVariance() @@ -399,33 +407,38 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() { visitTypeWithNullability(functionType) } + private fun ConeSymbol.asString(): String { + return when (this) { + is ConeClassLikeSymbol -> classId.asString() + is FirTypeParameterSymbol -> fir.name.asString() + else -> "Unsupported: ${this::class}" + } + } + private fun ConeKotlinType.asString(): String { return when (this) { is ConeKotlinErrorType -> "error: $reason" - is ConeClassType -> { + is ConeClassLikeType -> { val sb = StringBuilder() - val fqName = fqName - val packageFqName = fqName.packageFqName - if (packageFqName.isRoot) { - sb.append("") - } else { - sb.append(packageFqName.asString().replace('.', '/')) + sb.append(symbol.classId.asString()) + if (typeArguments.isNotEmpty()) { + sb.append(typeArguments.joinToString(prefix = "<", postfix = ">") { it -> + when (it) { + StarProjection -> "*" + is ConeKotlinTypeProjectionIn -> "in ${it.type.asString()}" + is ConeKotlinTypeProjectionOut -> "out ${it.type.asString()}" + is ConeKotlinType -> it.asString() + } + }) } - sb.append('.') - sb.append(fqName.relativeClassName.asString()) - sb.append(typeArguments.joinToString { it -> - when (it) { - StarProjection -> "*" - is ConeKotlinTypeProjectionIn -> "in ${it.type.asString()}" - is ConeKotlinTypeProjectionOut -> "out ${it.type.asString()}" - is ConeKotlinType -> it.asString() - } - }) if (this is ConeAbbreviatedType) { sb.append(" = ${this.directExpansion.asString()}") } sb.toString() } + is ConeTypeParameterType -> { + symbol.asString() + } else -> "Unsupported: $this" } } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirResolvedTypeParameter.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirResolvedTypeParameter.kt new file mode 100644 index 00000000000..e1d6cdec4ca --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirResolvedTypeParameter.kt @@ -0,0 +1,15 @@ +/* + * 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 FirResolvedTypeParameter : FirTypeParameter, FirDescriptorOwner { + + override fun accept(visitor: FirVisitor, data: D): R = + visitor.visitResolvedTypeParameter(this, data) +} \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirTypeParameter.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirTypeParameter.kt index 8a6e9c9de9b..46ef90537fe 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirTypeParameter.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirTypeParameter.kt @@ -7,16 +7,22 @@ package org.jetbrains.kotlin.fir.declarations import org.jetbrains.kotlin.fir.BaseTransformedType import org.jetbrains.kotlin.fir.expressions.FirAnnotationContainer +import org.jetbrains.kotlin.fir.symbols.FirSymbolOwner +import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol import org.jetbrains.kotlin.fir.types.FirType import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.types.Variance @BaseTransformedType -interface FirTypeParameter : FirNamedDeclaration, FirAnnotationContainer { +interface FirTypeParameter : FirNamedDeclaration, FirAnnotationContainer, FirSymbolOwner { val variance: Variance + val isReified: Boolean + val bounds: List + override val symbol: FirTypeParameterSymbol + override fun accept(visitor: FirVisitor, data: D): R = visitor.visitTypeParameter(this, data) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirResolvedTypeParameterImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirResolvedTypeParameterImpl.kt new file mode 100644 index 00000000000..95801dbe3fe --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirResolvedTypeParameterImpl.kt @@ -0,0 +1,29 @@ +/* + * 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.FirResolvedTypeParameter +import org.jetbrains.kotlin.fir.declarations.FirTypeParameter +import org.jetbrains.kotlin.fir.visitors.FirVisitor +import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid + +class FirResolvedTypeParameterImpl(val delegate: FirTypeParameter, override val descriptor: FirBasedDescriptor) : + FirResolvedTypeParameter, FirTypeParameter by delegate { + + init { + symbol.bind(this) + descriptor.bind(this) + } + + override fun accept(visitor: FirVisitorVoid) { + return super.accept(visitor) + } + + override fun accept(visitor: FirVisitor, data: D): R { + return super.accept(visitor, data) + } +} \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirTypeAliasImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirTypeAliasImpl.kt index 45eb16b0093..bf7833409f5 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirTypeAliasImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirTypeAliasImpl.kt @@ -11,6 +11,7 @@ import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirTypeAlias +import org.jetbrains.kotlin.fir.transformInplace import org.jetbrains.kotlin.fir.transformSingle import org.jetbrains.kotlin.fir.types.FirType import org.jetbrains.kotlin.fir.visitors.FirTransformer @@ -24,6 +25,7 @@ class FirTypeAliasImpl( override var expandedType: FirType ) : FirAbstractMemberDeclaration(session, psi, name, visibility, Modality.FINAL), FirTypeAlias { override fun transformChildren(transformer: FirTransformer, data: D): FirElement { + typeParameters.transformInplace(transformer, data) expandedType = expandedType.transformSingle(transformer, data) return this diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirTypeParameterImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirTypeParameterImpl.kt index 5c2ee988c30..84b5ecb2339 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirTypeParameterImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirTypeParameterImpl.kt @@ -6,9 +6,13 @@ package org.jetbrains.kotlin.fir.declarations.impl import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirTypeParameter +import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol +import org.jetbrains.kotlin.fir.transformInplace import org.jetbrains.kotlin.fir.types.FirType +import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.types.Variance @@ -16,7 +20,19 @@ class FirTypeParameterImpl( session: FirSession, psi: PsiElement?, name: Name, - override val variance: Variance + override val variance: Variance, + override val isReified: Boolean, + override val symbol: FirTypeParameterSymbol ) : FirAbstractNamedAnnotatedDeclaration(session, psi, name), FirTypeParameter { + init { + symbol.bind(this) + } + override val bounds = mutableListOf() + + override fun transformChildren(transformer: FirTransformer, data: D): FirElement { + bounds.transformInplace(transformer, data) + + return this + } } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/AbstractFirBasedSymbol.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/AbstractFirBasedSymbol.kt new file mode 100644 index 00000000000..abe58b45aa5 --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/AbstractFirBasedSymbol.kt @@ -0,0 +1,17 @@ +/* + * 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.symbols + +import org.jetbrains.kotlin.fir.FirElement + +abstract class AbstractFirBasedSymbol : FirBasedSymbol where E : FirElement, E : FirSymbolOwner { + + override lateinit var fir: E + + override fun bind(e: E) { + fir = e + } +} \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/FirBasedSymbol.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/FirBasedSymbol.kt new file mode 100644 index 00000000000..e166aa6666d --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/FirBasedSymbol.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.symbols + +import org.jetbrains.kotlin.fir.FirElement + +interface FirBasedSymbol : ConeSymbol where E : FirElement, E : FirSymbolOwner { + val fir: E + + fun bind(e: E) +} \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/FirSymbolOwner.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/FirSymbolOwner.kt new file mode 100644 index 00000000000..94f8e34b46a --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/FirSymbolOwner.kt @@ -0,0 +1,12 @@ +/* + * 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.symbols + +import org.jetbrains.kotlin.fir.FirElement + +interface FirSymbolOwner where E : FirElement, E : FirSymbolOwner { + val symbol: FirBasedSymbol +} \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirTypeParameterSymbol.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirTypeParameterSymbol.kt new file mode 100644 index 00000000000..82dee7519b6 --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirTypeParameterSymbol.kt @@ -0,0 +1,12 @@ +/* + * 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.symbols.impl + +import org.jetbrains.kotlin.fir.declarations.FirTypeParameter +import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol +import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterSymbol + +class FirTypeParameterSymbol : AbstractFirBasedSymbol(), ConeTypeParameterSymbol \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirResolvedType.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirResolvedType.kt index 24c877fcbf1..8e2986bed67 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirResolvedType.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirResolvedType.kt @@ -15,4 +15,4 @@ interface FirResolvedType : FirTypeWithNullability { } inline fun FirType.coneTypeUnsafe() = (this as FirResolvedType).type as T -inline fun FirType.coneTypeSafe() = (this as FirResolvedType).type as? T \ No newline at end of file +inline fun FirType.coneTypeSafe() = (this as? FirResolvedType)?.type as? T \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirBuiltinType.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirBuiltinType.kt index 434fb32f9e2..6db3dd8a5c0 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirBuiltinType.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirBuiltinType.kt @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir.types.impl import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall +import org.jetbrains.kotlin.fir.symbols.toSymbol import org.jetbrains.kotlin.fir.types.ConeKotlinType import org.jetbrains.kotlin.fir.types.FirResolvedType import org.jetbrains.kotlin.name.ClassId @@ -23,7 +24,8 @@ sealed class FirBuiltinType( ClassId( KOTLIN_PACKAGE_FQ_NAME, Name.identifier(name) - ), emptyList() + ).toSymbol(), + emptyList() ) final override val isNullable = false diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirFunctionTypeImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirFunctionTypeImpl.kt index 6a8225aaf3f..7930861e0fd 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirFunctionTypeImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirFunctionTypeImpl.kt @@ -6,17 +6,29 @@ package org.jetbrains.kotlin.fir.types.impl import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirValueParameter +import org.jetbrains.kotlin.fir.transformInplace +import org.jetbrains.kotlin.fir.transformSingle import org.jetbrains.kotlin.fir.types.FirFunctionType import org.jetbrains.kotlin.fir.types.FirType +import org.jetbrains.kotlin.fir.visitors.FirTransformer class FirFunctionTypeImpl( session: FirSession, psi: PsiElement?, isNullable: Boolean, - override val receiverType: FirType?, - override val returnType: FirType + override var receiverType: FirType?, + override var returnType: FirType ) : FirAbstractAnnotatedType(session, psi, isNullable), FirFunctionType { override val valueParameters = mutableListOf() + + override fun transformChildren(transformer: FirTransformer, data: D): FirElement { + receiverType = receiverType?.transformSingle(transformer, data) + returnType = returnType.transformSingle(transformer, data) + valueParameters.transformInplace(transformer, data) + + return this + } } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirTypeProjectionWithVarianceImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirTypeProjectionWithVarianceImpl.kt index f63c48c18b2..9fe1180167f 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirTypeProjectionWithVarianceImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirTypeProjectionWithVarianceImpl.kt @@ -6,14 +6,23 @@ package org.jetbrains.kotlin.fir.types.impl import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.transformSingle import org.jetbrains.kotlin.fir.types.FirType import org.jetbrains.kotlin.fir.types.FirTypeProjectionWithVariance +import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.types.Variance class FirTypeProjectionWithVarianceImpl( override val session: FirSession, override val psi: PsiElement?, override val variance: Variance, - override val type: FirType -) : FirTypeProjectionWithVariance \ No newline at end of file + override var type: FirType +) : FirTypeProjectionWithVariance { + override fun transformChildren(transformer: FirTransformer, data: D): FirElement { + type = type.transformSingle(transformer, data) + + return this + } +} \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirUserTypeImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirUserTypeImpl.kt index 60cf73c45af..aa389aa1360 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirUserTypeImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirUserTypeImpl.kt @@ -6,9 +6,14 @@ package org.jetbrains.kotlin.fir.types.impl import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.transformInplace import org.jetbrains.kotlin.fir.types.FirQualifierPart +import org.jetbrains.kotlin.fir.types.FirTypeProjection import org.jetbrains.kotlin.fir.types.FirUserType +import org.jetbrains.kotlin.fir.visitors.FirTransformer +import org.jetbrains.kotlin.types.TypeProjectionBase import java.util.* class FirUserTypeImpl( @@ -17,4 +22,12 @@ class FirUserTypeImpl( isNullable: Boolean ) : FirAbstractAnnotatedType(session, psi, isNullable), FirUserType { override val qualifier = LinkedList() + + override fun transformChildren(transformer: FirTransformer, data: D): FirElement { + for (part in qualifier) { + (part.typeArguments as MutableList).transformInplace(transformer, data) + } + + return 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 e8b7b9de542..dcf139042b2 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 @@ -82,6 +82,10 @@ abstract class FirTransformer : FirVisitor { + return transformTypeParameter(resolvedTypeParameter, data) + } + open fun transformProperty(property: FirProperty, data: D): CompositeTransformResult { return transformDeclaration(property, data) } @@ -246,6 +250,10 @@ abstract class FirTransformer : FirVisitor { + return transformTypeParameter(typeParameter, data) + } + final override fun visitTypeProjection(typeProjection: FirTypeProjection, data: D): CompositeTransformResult { return transformTypeProjection(typeProjection, data) } @@ -322,10 +330,6 @@ abstract class FirTransformer : FirVisitor { - return transformTypeParameter(typeParameter, data) - } - final override fun visitFile(file: FirFile, data: D): CompositeTransformResult { return transformFile(file, data) } @@ -346,6 +350,10 @@ abstract class FirTransformer : FirVisitor { + return transformResolvedTypeParameter(resolvedTypeParameter, data) + } + final override fun visitStarProjection(starProjection: FirStarProjection, data: D): CompositeTransformResult { return transformStarProjection(starProjection, 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 f0cbacb7e60..8bd83c655a1 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 @@ -82,6 +82,10 @@ abstract class FirVisitor { return visitNamedDeclaration(typeParameter, data) } + open fun visitResolvedTypeParameter(resolvedTypeParameter: FirResolvedTypeParameter, data: D): R { + return visitTypeParameter(resolvedTypeParameter, data) + } + open fun visitProperty(property: FirProperty, data: D): R { return visitDeclaration(property, 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 28c313e3391..f123113e535 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 @@ -82,6 +82,10 @@ abstract class FirVisitorVoid : FirVisitor() { visitNamedDeclaration(typeParameter, null) } + open fun visitResolvedTypeParameter(resolvedTypeParameter: FirResolvedTypeParameter) { + visitTypeParameter(resolvedTypeParameter, null) + } + open fun visitProperty(property: FirProperty) { visitDeclaration(property, null) } @@ -246,6 +250,10 @@ abstract class FirVisitorVoid : FirVisitor() { visitTypeAlias(typeAlias) } + final override fun visitTypeParameter(typeParameter: FirTypeParameter, data: Nothing?) { + visitTypeParameter(typeParameter) + } + final override fun visitTypeProjection(typeProjection: FirTypeProjection, data: Nothing?) { visitTypeProjection(typeProjection) } @@ -322,10 +330,6 @@ abstract class FirVisitorVoid : FirVisitor() { visitResolvedImport(resolvedImport) } - final override fun visitTypeParameter(typeParameter: FirTypeParameter, data: Nothing?) { - visitTypeParameter(typeParameter) - } - final override fun visitFile(file: FirFile, data: Nothing?) { visitFile(file) } @@ -346,6 +350,10 @@ abstract class FirVisitorVoid : FirVisitor() { visitResolvedTypeAlias(resolvedTypeAlias) } + final override fun visitResolvedTypeParameter(resolvedTypeParameter: FirResolvedTypeParameter, data: Nothing?) { + visitResolvedTypeParameter(resolvedTypeParameter) + } + final override fun visitStarProjection(starProjection: FirStarProjection, data: Nothing?) { visitStarProjection(starProjection) } diff --git a/compiler/testData/fir/rawBuilder/declarations/genericFunctions.txt b/compiler/testData/fir/rawBuilder/declarations/genericFunctions.txt index 909b4c05547..d710b2eb7d3 100644 --- a/compiler/testData/fir/rawBuilder/declarations/genericFunctions.txt +++ b/compiler/testData/fir/rawBuilder/declarations/genericFunctions.txt @@ -1,7 +1,7 @@ FILE: genericFunctions.kt public? final? interface Any() { } - public? final? inline function safeAsAny.(): T? { + public? final? inline function safeAsAny.(): T? { STUB } public? abstract class Summator() { diff --git a/compiler/testData/fir/rawBuilder/declarations/simpleClass.txt b/compiler/testData/fir/rawBuilder/declarations/simpleClass.txt index 7e0fc7ed641..f7eb78b5b93 100644 --- a/compiler/testData/fir/rawBuilder/declarations/simpleClass.txt +++ b/compiler/testData/fir/rawBuilder/declarations/simpleClass.txt @@ -22,6 +22,6 @@ FILE: simpleClass.kt public? final? property fau(var): Double public? get(): Double - public? set(value: Double): R/kotlin.Unit/ + public? set(value: Double): R/kotlin/Unit/ } diff --git a/compiler/testData/fir/rawBuilder/declarations/typeAliasWithGeneric.txt b/compiler/testData/fir/rawBuilder/declarations/typeAliasWithGeneric.txt index cc6bd819142..bdd46713318 100644 --- a/compiler/testData/fir/rawBuilder/declarations/typeAliasWithGeneric.txt +++ b/compiler/testData/fir/rawBuilder/declarations/typeAliasWithGeneric.txt @@ -3,6 +3,6 @@ FILE: typeAliasWithGeneric.kt } public? final? interface B() { } - public? final typealias C = B + public? final typealias C = B public? final? class D() : C { } diff --git a/compiler/testData/fir/resolve/F.txt b/compiler/testData/fir/resolve/F.txt index 0d25cec804b..8145d6eb076 100644 --- a/compiler/testData/fir/resolve/F.txt +++ b/compiler/testData/fir/resolve/F.txt @@ -1,5 +1,5 @@ FILE: F.kt (resolved) public? open class A() { } - (resolved) public? final class B() : R/.A/ { + (resolved) public? final class B() : R/A/ { } diff --git a/compiler/testData/fir/resolve/NestedOfAliasedType.txt b/compiler/testData/fir/resolve/NestedOfAliasedType.txt index a9609ce84c1..e45727ff829 100644 --- a/compiler/testData/fir/resolve/NestedOfAliasedType.txt +++ b/compiler/testData/fir/resolve/NestedOfAliasedType.txt @@ -4,9 +4,9 @@ FILE: NestedOfAliasedType.kt } } - (resolved) public? final typealias TA = R/.A/ - (resolved) public? final class B() : R/.TA = .A/ { - (resolved) public? final class NestedInB() : R/.A.Nested/ { + (resolved) public? final typealias TA = R/A/ + (resolved) public? final class B() : R/TA = A/ { + (resolved) public? final class NestedInB() : R/A.Nested/ { } } diff --git a/compiler/testData/fir/resolve/NestedSuperType.txt b/compiler/testData/fir/resolve/NestedSuperType.txt index c31ada7b645..28fc4b341f6 100644 --- a/compiler/testData/fir/resolve/NestedSuperType.txt +++ b/compiler/testData/fir/resolve/NestedSuperType.txt @@ -1,14 +1,14 @@ FILE: NestedSuperType.kt (resolved) public? abstract class My() { - (resolved) public? abstract class NestedOne() : R/p.My/ { - (resolved) public? abstract class NestedTwo() : R/p.My.NestedOne/ { + (resolved) public? abstract class NestedOne() : R/p/My/ { + (resolved) public? abstract class NestedTwo() : R/p/My.NestedOne/ { } } } - (resolved) public? final class Your() : R/p.My/ { - (resolved) public? final class NestedThree() : R/p.My.NestedOne/ { + (resolved) public? final class Your() : R/p/My/ { + (resolved) public? final class NestedThree() : R/p/My.NestedOne/ { } } diff --git a/compiler/testData/fir/resolve/TwoDeclarationsInSameFile.txt b/compiler/testData/fir/resolve/TwoDeclarationsInSameFile.txt index 0ab93fdf803..519c60acd84 100644 --- a/compiler/testData/fir/resolve/TwoDeclarationsInSameFile.txt +++ b/compiler/testData/fir/resolve/TwoDeclarationsInSameFile.txt @@ -1,5 +1,5 @@ FILE: TwoDeclarationsInSameFile.kt (resolved) public? open class A() { } - (resolved) public? final class B() : R/p.A/ { + (resolved) public? final class B() : R/p/A/ { } diff --git a/compiler/testData/fir/resolve/multifile/NestedSuperType.txt b/compiler/testData/fir/resolve/multifile/NestedSuperType.txt index bd7fc695fb9..4c9ef9c49e1 100644 --- a/compiler/testData/fir/resolve/multifile/NestedSuperType.txt +++ b/compiler/testData/fir/resolve/multifile/NestedSuperType.txt @@ -1,9 +1,9 @@ FILE: NestedSuperType.kt - (resolved) public? final class A() : R/b.B/ { - (resolved) public? final class NestedInA1() : R/b.B.NestedInB/ { + (resolved) public? final class A() : R/b/B/ { + (resolved) public? final class NestedInA1() : R/b/B.NestedInB/ { } - (resolved) public? final class NestedInA2() : R/c.C.NestedInC/ { + (resolved) public? final class NestedInA2() : R/c/C.NestedInC/ { } } diff --git a/compiler/testData/fir/resolve/multifile/simpleAliasedImport.txt b/compiler/testData/fir/resolve/multifile/simpleAliasedImport.txt index adf3de7d4c7..f24d433d31f 100644 --- a/compiler/testData/fir/resolve/multifile/simpleAliasedImport.txt +++ b/compiler/testData/fir/resolve/multifile/simpleAliasedImport.txt @@ -1,3 +1,3 @@ FILE: simpleAliasedImport.kt - (resolved) public? final class YourClass() : R/b.MyClass/ { + (resolved) public? final class YourClass() : R/b/MyClass/ { } diff --git a/compiler/testData/fir/resolve/multifile/simpleImport.txt b/compiler/testData/fir/resolve/multifile/simpleImport.txt index 6bcf374f37a..8191fdff2d6 100644 --- a/compiler/testData/fir/resolve/multifile/simpleImport.txt +++ b/compiler/testData/fir/resolve/multifile/simpleImport.txt @@ -1,3 +1,3 @@ FILE: simpleImport.kt - (resolved) public? final class YourClass() : R/b.MyClass/ { + (resolved) public? final class YourClass() : R/b/MyClass/ { } diff --git a/compiler/testData/fir/resolve/multifile/simpleImportNested.txt b/compiler/testData/fir/resolve/multifile/simpleImportNested.txt index 4d9e3c5dbdc..d4e1de13ad1 100644 --- a/compiler/testData/fir/resolve/multifile/simpleImportNested.txt +++ b/compiler/testData/fir/resolve/multifile/simpleImportNested.txt @@ -1,3 +1,3 @@ FILE: simpleImportNested.kt - (resolved) public? final class YourClass() : R/a.MyClass.MyNested/ { + (resolved) public? final class YourClass() : R/a/MyClass.MyNested/ { } diff --git a/compiler/testData/fir/resolve/multifile/simpleImportOuter.txt b/compiler/testData/fir/resolve/multifile/simpleImportOuter.txt index 75de7c522af..12a1a122eab 100644 --- a/compiler/testData/fir/resolve/multifile/simpleImportOuter.txt +++ b/compiler/testData/fir/resolve/multifile/simpleImportOuter.txt @@ -1,3 +1,3 @@ FILE: simpleImportOuter.kt - (resolved) public? final class My() : R/a.Outer.Nested/ { + (resolved) public? final class My() : R/a/Outer.Nested/ { } diff --git a/compiler/testData/fir/resolve/simpleClass.txt b/compiler/testData/fir/resolve/simpleClass.txt index a303fc1a7bb..0c4c10a086f 100644 --- a/compiler/testData/fir/resolve/simpleClass.txt +++ b/compiler/testData/fir/resolve/simpleClass.txt @@ -6,7 +6,7 @@ FILE: simpleClass.kt public? get(): R/error: Failed to resolve qualified type/ } - (resolved) public? final class SomeClass() : R/.SomeInterface/ { + (resolved) public? final class SomeClass() : R/SomeInterface/ { private final? property baz(val): R/error: Not supported: FirImplicitTypeImpl/ = STUB public? get(): R/error: Not supported: FirImplicitTypeImpl/ @@ -22,6 +22,6 @@ FILE: simpleClass.kt public? final? property fau(var): R/error: Failed to resolve qualified type/ public? get(): R/error: Failed to resolve qualified type/ - public? set(value: R/error: Failed to resolve qualified type/): R/kotlin.Unit/ + public? set(value: R/error: Failed to resolve qualified type/): R/kotlin/Unit/ } diff --git a/compiler/testData/fir/resolve/simpleTypeAlias.txt b/compiler/testData/fir/resolve/simpleTypeAlias.txt index 4ce5113dcd4..2e730b73240 100644 --- a/compiler/testData/fir/resolve/simpleTypeAlias.txt +++ b/compiler/testData/fir/resolve/simpleTypeAlias.txt @@ -1,6 +1,6 @@ FILE: simpleTypeAlias.kt (resolved) public? abstract interface B() { } - (resolved) public? final typealias C = R/.B/ - (resolved) public? final class D() : R/.C = .B/ { + (resolved) public? final typealias C = R/B/ + (resolved) public? final class D() : R/C = B/ { } diff --git a/compiler/testData/fir/resolve/typeAliasWithGeneric.kt b/compiler/testData/fir/resolve/typeAliasWithGeneric.kt new file mode 100644 index 00000000000..c9c9eadadb0 --- /dev/null +++ b/compiler/testData/fir/resolve/typeAliasWithGeneric.kt @@ -0,0 +1,7 @@ +open class A + +interface B + +typealias C = B + +class D : C diff --git a/compiler/testData/fir/resolve/typeAliasWithGeneric.txt b/compiler/testData/fir/resolve/typeAliasWithGeneric.txt new file mode 100644 index 00000000000..a0076e68841 --- /dev/null +++ b/compiler/testData/fir/resolve/typeAliasWithGeneric.txt @@ -0,0 +1,8 @@ +FILE: typeAliasWithGeneric.kt + (resolved) public? open class A() { + } + (resolved) <(resolved) S, (resolved) T : R/A/> public? abstract interface B() { + } + (resolved) <(resolved) T> public? final typealias C = R/B/ + (resolved) public? final class D() : R/C = B/ { + } diff --git a/compiler/testData/fir/resolve/typeParameterVsNested.kt b/compiler/testData/fir/resolve/typeParameterVsNested.kt new file mode 100644 index 00000000000..df1765a2f4f --- /dev/null +++ b/compiler/testData/fir/resolve/typeParameterVsNested.kt @@ -0,0 +1,17 @@ +package test + +interface Some + +abstract class My { + inner class T + + abstract val x: T + + abstract fun foo(arg: T) + + abstract val y: My.T + + abstract val z: test.My.T + + class Some : T() +} \ No newline at end of file diff --git a/compiler/testData/fir/resolve/typeParameterVsNested.txt b/compiler/testData/fir/resolve/typeParameterVsNested.txt new file mode 100644 index 00000000000..f1bd9df9669 --- /dev/null +++ b/compiler/testData/fir/resolve/typeParameterVsNested.txt @@ -0,0 +1,22 @@ +FILE: typeParameterVsNested.kt + (resolved) public? abstract interface Some() { + } + (resolved) <(resolved) T : R/test/Some/> public? abstract class My() { + (resolved) public? final class T(inner) { + } + + public? abstract property x(val): R/T/ + public? get(): R/T/ + + public? abstract function foo(arg: R/T/): R/error: Not supported: FirImplicitTypeImpl/ + + public? abstract property y(val): R/test/My.T/ + public? get(): R/test/My.T/ + + public? abstract property z(val): R/test/My.T/ + public? get(): R/test/My.T/ + + (resolved) public? final class Some() : R/T/ { + } + + } diff --git a/compiler/tests/org/jetbrains/kotlin/fir/FirResolveTestCaseGenerated.java b/compiler/tests/org/jetbrains/kotlin/fir/FirResolveTestCaseGenerated.java index 4afbdd3d867..f2a41ffa05e 100644 --- a/compiler/tests/org/jetbrains/kotlin/fir/FirResolveTestCaseGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/fir/FirResolveTestCaseGenerated.java @@ -61,6 +61,18 @@ public class FirResolveTestCaseGenerated extends AbstractFirResolveTestCase { doTest(fileName); } + @TestMetadata("typeAliasWithGeneric.kt") + public void testTypeAliasWithGeneric() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/fir/resolve/typeAliasWithGeneric.kt"); + doTest(fileName); + } + + @TestMetadata("typeParameterVsNested.kt") + public void testTypeParameterVsNested() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/fir/resolve/typeParameterVsNested.kt"); + doTest(fileName); + } + @TestMetadata("compiler/testData/fir/resolve/multifile") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class)