azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Extract ConeClassifierLookupTag (aka SearchSymbol)

Browse Source 
So, for classifiers there are both Symbols and LookupTags
The difference between them is that the former are assumed to have
a reference to the actual FirDeclaration while LookupTags
effectively contain only classId and
something informative may only be obtained by FirSession

#KT-24075 Fixed
This commit is contained in:
Denis Zharkov
2019-03-05 18:15:45 +03:00
committed by Mikhail Glukhikh
parent 6b5ba272a0
commit 2dbe96c853
39 changed files with 304 additions and 216 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/fir/cones/src/org/jetbrains/kotlin/fir/symbols/ConeLookupTags.kt
+29
View File
@@ -0,0 +1,29 @@
/*
* Copyright 2010-2019 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
import org.jetbrains.kotlin.name.Name
interface ConeClassifierLookupTag
interface ConeClassifierLookupTagWithFixedSymbol {
val symbol: ConeClassifierSymbol
}
interface ConeTypeParameterLookupTag : ConeClassifierLookupTag {
val name: Name
}
interface ConeClassLikeLookupTag : ConeClassifierLookupTag {
val classId: ClassId
}
interface ConeTypeAliasLookupTag : ConeClassLikeLookupTag
interface ConeClassLookupTag : ConeClassLikeLookupTag
class ConeClassLikeLookupTagImpl(override val classId: ClassId) : ConeClassLikeLookupTag
compiler/fir/cones/src/org/jetbrains/kotlin/fir/symbols/ConeSymbols.kt
+9 -4
View File
@@ -6,16 +6,21 @@
package org.jetbrains.kotlin.fir.symbols
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.Name
interface ConeSymbol
interface ConeTypeParameterSymbol : ConeSymbol {
val name: Name
interface ConeClassifierSymbol : ConeSymbol {
fun toLookupTag(): ConeClassifierLookupTag
}
interface ConeClassLikeSymbol : ConeSymbol {
interface ConeTypeParameterSymbol : ConeClassifierSymbol, ConeTypeParameterLookupTag {
override fun toLookupTag(): ConeTypeParameterLookupTag = this
}
interface ConeClassLikeSymbol : ConeClassifierSymbol {
val classId: ClassId
override fun toLookupTag(): ConeClassLikeLookupTag
}
interface ConeTypeAliasSymbol : ConeClassLikeSymbol
compiler/fir/cones/src/org/jetbrains/kotlin/fir/types/ConeTypes.kt
+10 -12
View File
@@ -5,9 +5,7 @@
package org.jetbrains.kotlin.fir.types
import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol
import org.jetbrains.kotlin.fir.symbols.ConeSymbol
import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterSymbol
import org.jetbrains.kotlin.fir.symbols.*
sealed class ConeKotlinTypeProjection {
abstract val kind: ProjectionKind
@@ -79,7 +77,7 @@ class ConeKotlinErrorType(val reason: String) : ConeKotlinType() {
}
class ConeClassErrorType(val reason: String) : ConeClassLikeType() {
override val symbol: ConeClassLikeSymbol
override val lookupTag: ConeClassLikeLookupTag
get() = error("!")
override val typeArguments: Array<out ConeKotlinTypeProjection>
@@ -93,28 +91,28 @@ class ConeClassErrorType(val reason: String) : ConeClassLikeType() {
}
}
sealed class ConeSymbolBasedType : ConeKotlinType() {
abstract val symbol: ConeSymbol
sealed class ConeLookupTagBasedType : ConeKotlinType() {
abstract val lookupTag: ConeClassifierLookupTag
}
abstract class ConeClassLikeType : ConeSymbolBasedType() {
abstract override val symbol: ConeClassLikeSymbol
abstract class ConeClassLikeType : ConeLookupTagBasedType() {
abstract override val lookupTag: ConeClassLikeLookupTag
}
abstract class ConeAbbreviatedType : ConeClassLikeType() {
abstract val abbreviationSymbol: ConeClassLikeSymbol
abstract val abbreviationLookupTag: ConeClassLikeLookupTag
abstract val directExpansion: ConeClassLikeType
}
abstract class ConeTypeParameterType : ConeSymbolBasedType() {
abstract override val symbol: ConeTypeParameterSymbol
abstract class ConeTypeParameterType : ConeLookupTagBasedType() {
abstract override val lookupTag: ConeTypeParameterLookupTag
}
abstract class ConeFunctionType : ConeClassLikeType() {
abstract override val symbol: ConeClassLikeSymbol
abstract override val lookupTag: ConeClassLikeLookupTag
abstract val receiverType: ConeKotlinType?
abstract val parameterTypes: List<ConeKotlinType>
abstract val returnType: ConeKotlinType
compiler/fir/cones/src/org/jetbrains/kotlin/fir/types/impl/ConeFunctionTypeImpl.kt
+3 -3
View File
@@ -5,7 +5,7 @@
package org.jetbrains.kotlin.fir.types.impl
import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol
import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
import org.jetbrains.kotlin.fir.types.ConeFunctionType
import org.jetbrains.kotlin.fir.types.ConeKotlinType
import org.jetbrains.kotlin.fir.types.ConeKotlinTypeProjection
@@ -15,11 +15,11 @@ class ConeFunctionTypeImpl(
override val receiverType: ConeKotlinType?,
override val parameterTypes: List<ConeKotlinType>,
override val returnType: ConeKotlinType,
override val symbol: ConeClassLikeSymbol,
override val lookupTag: ConeClassLikeLookupTag,
isNullable: Boolean
) : ConeFunctionType() {
override val typeArguments: Array<out ConeKotlinTypeProjection>
get() = EMPTY_ARRAY
override val nullability: ConeNullability = ConeNullability.create(isNullable)
}
}
compiler/fir/cones/src/org/jetbrains/kotlin/fir/types/impl/Impl.kt
+8 -8
View File
@@ -5,12 +5,12 @@
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.symbols.ConeClassLikeLookupTag
import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterLookupTag
import org.jetbrains.kotlin.fir.types.*
open class ConeClassTypeImpl(
override val symbol: ConeClassLikeSymbol,
override val lookupTag: ConeClassLikeLookupTag,
override val typeArguments: Array<ConeKotlinTypeProjection>,
isNullable: Boolean
) : ConeClassLikeType() {
@@ -18,23 +18,23 @@ open class ConeClassTypeImpl(
}
class ConeAbbreviatedTypeImpl(
override val abbreviationSymbol: ConeClassLikeSymbol,
override val abbreviationLookupTag: ConeClassLikeLookupTag,
override val typeArguments: Array<ConeKotlinTypeProjection>,
override val directExpansion: ConeClassLikeType,
isNullable: Boolean
) : ConeAbbreviatedType() {
override val symbol: ConeClassLikeSymbol
get() = abbreviationSymbol
override val lookupTag: ConeClassLikeLookupTag
get() = abbreviationLookupTag
override val nullability: ConeNullability = ConeNullability.create(isNullable)
}
class ConeTypeParameterTypeImpl(
override val symbol: ConeTypeParameterSymbol,
override val lookupTag: ConeTypeParameterLookupTag,
isNullable: Boolean
) : ConeTypeParameterType() {
override val typeArguments: Array<out ConeKotlinTypeProjection>
get() = EMPTY_ARRAY
override val nullability: ConeNullability = ConeNullability.create(isNullable)
}
}
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt
+4 -8
View File
@@ -19,10 +19,7 @@ import org.jetbrains.kotlin.fir.references.FirResolvedCallableReferenceImpl
import org.jetbrains.kotlin.fir.resolve.AbstractFirSymbolProvider
import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider
import org.jetbrains.kotlin.fir.service
import org.jetbrains.kotlin.fir.symbols.CallableId
import org.jetbrains.kotlin.fir.symbols.ConeCallableSymbol
import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol
import org.jetbrains.kotlin.fir.symbols.ConeClassSymbol
import org.jetbrains.kotlin.fir.symbols.*
import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
@@ -53,7 +50,7 @@ class JavaSymbolProvider(
annotationTypeRef = FirResolvedTypeRefImpl(
session = session,
psi = null,
type = ConeClassTypeImpl(FirClassSymbol(classId!!), emptyArray(), isNullable = false),
type = ConeClassTypeImpl(FirClassSymbol(classId!!).toLookupTag(), emptyArray(), isNullable = false),
isMarkedNullable = true,
annotations = emptyList()
)
@@ -146,9 +143,8 @@ class JavaSymbolProvider(
private fun JavaClassifierType.toFirResolvedTypeRef(): FirResolvedTypeRef {
val coneType = when (val classifier = classifier) {
is JavaClass -> {
val symbol = session.service<FirSymbolProvider>().getClassLikeSymbolByFqName(classifier.classId!!) as? ConeClassSymbol
if (symbol == null) ConeKotlinErrorType("Symbol not found, for `${classifier.classId}`")
else flexibleType { isNullable ->
val symbol = ConeClassLikeLookupTagImpl(classifier.classId!!)
flexibleType { isNullable ->
ConeClassTypeImpl(symbol, typeArguments.map { it.toConeProjection() }.toTypedArray(), isNullable)
}
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirModuleBasedSession.kt
+1 -2
View File
@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.fir
import org.jetbrains.kotlin.analyzer.ModuleInfo
import org.jetbrains.kotlin.fir.resolve.FirProvider
import org.jetbrains.kotlin.fir.resolve.FirQualifierResolver
import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider
import org.jetbrains.kotlin.fir.resolve.FirTypeResolver
import org.jetbrains.kotlin.fir.resolve.impl.*
@@ -17,6 +16,6 @@ abstract class FirModuleBasedSession(override val moduleInfo: ModuleInfo) : FirS
val firProvider = FirProviderImpl(this)
registerComponent(FirProvider::class, firProvider)
registerComponent(FirQualifierResolver::class, FirQualifierResolverImpl(this))
registerComponent(FirTypeResolver::class, FirTypeResolverImpl())
registerComponent(FirTypeResolver::class, FirTypeResolverImpl(this))
}
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/FirTypeDeserializer.kt
+13 -18
View File
@@ -6,11 +6,8 @@
package org.jetbrains.kotlin.fir.deserialization
import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider
import org.jetbrains.kotlin.fir.symbols.*
import org.jetbrains.kotlin.fir.resolve.toTypeProjection
import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol
import org.jetbrains.kotlin.fir.symbols.ConeSymbol
import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterSymbol
import org.jetbrains.kotlin.fir.symbols.LibraryTypeParameterSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
import org.jetbrains.kotlin.fir.types.*
@@ -32,10 +29,10 @@ class FirTypeDeserializer(
val parent: FirTypeDeserializer?
) {
private fun computeClassifier(fqNameIndex: Int): ConeSymbol? {
private fun computeClassifier(fqNameIndex: Int): ConeClassLikeLookupTag? {
try {
val id = nameResolver.getClassId(fqNameIndex)
return symbolProvider.getClassLikeSymbolByFqName(id)
return ConeClassLikeLookupTagImpl(id)
} catch (e: Throwable) {
throw RuntimeException("Looking up for ${nameResolver.getClassId(fqNameIndex)}", e)
}
@@ -54,21 +51,21 @@ class FirTypeDeserializer(
}
private fun typeParameterSymbol(typeParameterId: Int): ConeTypeParameterSymbol? =
private fun typeParameterSymbol(typeParameterId: Int): ConeTypeParameterLookupTag? =
typeParameterDescriptors[typeParameterId] ?: parent?.typeParameterSymbol(typeParameterId)
private val typeParameterDescriptors =
if (typeParameterProtos.isEmpty()) {
mapOf<Int, ConeTypeParameterSymbol>()
mapOf<Int, ConeTypeParameterLookupTag>()
} else {
val result = LinkedHashMap<Int, ConeTypeParameterSymbol>()
val result = LinkedHashMap<Int, ConeTypeParameterLookupTag>()
for ((index, proto) in typeParameterProtos.withIndex()) {
result[proto.id] = LibraryTypeParameterSymbol(nameResolver.getName(proto.name))
}
result
}
val ownTypeParameters: List<ConeTypeParameterSymbol>
val ownTypeParameters: List<ConeTypeParameterLookupTag>
get() = typeParameterDescriptors.values.toList()
@@ -82,7 +79,7 @@ class FirTypeDeserializer(
fun classLikeType(proto: ProtoBuf.Type): ConeClassLikeType? {
val constructor = typeSymbol(proto) as? ConeClassLikeSymbol ?: return null
val constructor = typeSymbol(proto) as? ConeClassLikeLookupTag ?: return null
// if (ErrorUtils.isError(constructor.declarationDescriptor)) {
// return ErrorUtils.createErrorTypeWithCustomConstructor(constructor.toString(), constructor)
// }
@@ -90,9 +87,7 @@ class FirTypeDeserializer(
fun ProtoBuf.Type.collectAllArguments(): List<ProtoBuf.Type.Argument> =
argumentList + outerType(typeTable)?.collectAllArguments().orEmpty()
val arguments = proto.collectAllArguments().mapIndexed { index, proto ->
typeArgument(constructor.typeParameters().getOrNull(index), proto)
}.toTypedArray()
val arguments = proto.collectAllArguments().map(this::typeArgument).toTypedArray()
val simpleType = if (Flags.SUSPEND_TYPE.get(proto.flags)) {
//createSuspendFunctionType(annotations, constructor, arguments, proto.nullable)
@@ -103,11 +98,11 @@ class FirTypeDeserializer(
val abbreviatedTypeProto = proto.abbreviatedType(typeTable) ?: return simpleType
return ConeAbbreviatedTypeImpl(typeSymbol(abbreviatedTypeProto) as ConeClassLikeSymbol, arguments, simpleType, isNullable = false)
return ConeAbbreviatedTypeImpl(typeSymbol(abbreviatedTypeProto) as ConeClassLikeLookupTag, arguments, simpleType, isNullable = false)
}
private fun typeSymbol(proto: ProtoBuf.Type): ConeSymbol? {
private fun typeSymbol(proto: ProtoBuf.Type): ConeClassifierLookupTag? {
return when {
proto.hasClassName() -> computeClassifier(proto.className)
@@ -124,7 +119,7 @@ class FirTypeDeserializer(
}
private fun typeArgument(parameter: ConeTypeParameterSymbol?, typeArgumentProto: ProtoBuf.Type.Argument): ConeKotlinTypeProjection {
private fun typeArgument(typeArgumentProto: ProtoBuf.Type.Argument): ConeKotlinTypeProjection {
if (typeArgumentProto.projection == ProtoBuf.Type.Argument.Projection.STAR) {
return StarProjection
}
@@ -136,4 +131,4 @@ class FirTypeDeserializer(
return coneType.toTypeProjection(variance)
}
}
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirProvider.kt
+1 -5
View File
@@ -8,12 +8,10 @@ package org.jetbrains.kotlin.fir.resolve
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.FirFile
import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
import org.jetbrains.kotlin.fir.declarations.FirNamedDeclaration
import org.jetbrains.kotlin.fir.service
import org.jetbrains.kotlin.fir.symbols.CallableId
import org.jetbrains.kotlin.fir.symbols.ConeCallableSymbol
import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol
import org.jetbrains.kotlin.fir.symbols.ConeSymbol
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.FqName
@@ -31,11 +29,9 @@ interface FirProvider : FirSymbolProvider {
fun getFirClassifierContainerFile(fqName: ClassId): FirFile
fun getFirClassifierBySymbol(symbol: ConeSymbol): FirNamedDeclaration?
companion object {
fun getInstance(session: FirSession): FirProvider = session.service()
}
fun getFirFilesByPackage(fqName: FqName): List<FirFile>
}
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirQualifierResolver.kt
+3 -5
View File
@@ -7,16 +7,14 @@ package org.jetbrains.kotlin.fir.resolve
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.service
import org.jetbrains.kotlin.fir.symbols.ConeSymbol
import org.jetbrains.kotlin.fir.types.ConeKotlinType
import org.jetbrains.kotlin.fir.symbols.ConeClassifierSymbol
import org.jetbrains.kotlin.fir.types.FirQualifierPart
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.FqName
interface FirQualifierResolver {
fun resolveSymbolWithPrefix(parts: List<FirQualifierPart>, prefix: ClassId): ConeSymbol?
fun resolveSymbolWithPrefix(parts: List<FirQualifierPart>, prefix: ClassId): ConeClassifierSymbol?
fun resolveSymbol(parts: List<FirQualifierPart>): ConeSymbol?
fun resolveSymbol(parts: List<FirQualifierPart>): ConeClassifierSymbol?
companion object {
fun getInstance(session: FirSession): FirQualifierResolver = session.service()
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirSymbolProvider.kt
+10 -4
View File
@@ -7,9 +7,7 @@ package org.jetbrains.kotlin.fir.resolve
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.service
import org.jetbrains.kotlin.fir.symbols.CallableId
import org.jetbrains.kotlin.fir.symbols.ConeCallableSymbol
import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol
import org.jetbrains.kotlin.fir.symbols.*
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.FqName
@@ -17,6 +15,14 @@ interface FirSymbolProvider {
fun getClassLikeSymbolByFqName(classId: ClassId): ConeClassLikeSymbol?
fun getSymbolByLookupTag(lookupTag: ConeClassifierLookupTag): ConeClassifierSymbol? {
return when (lookupTag) {
is ConeClassLikeLookupTag -> getClassLikeSymbolByFqName(lookupTag.classId)
is ConeClassifierLookupTagWithFixedSymbol -> lookupTag.symbol
else -> error("Unknown lookupTag type: ${lookupTag::class}")
}
}
fun getCallableSymbols(callableId: CallableId): List<ConeCallableSymbol>
fun getPackage(fqName: FqName): FqName? // TODO: Replace to symbol sometime
@@ -24,4 +30,4 @@ interface FirSymbolProvider {
companion object {
fun getInstance(session: FirSession) = session.service<FirSymbolProvider>()
}
}
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirTypeResolver.kt
+5 -5
View File
@@ -9,19 +9,19 @@ import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.scopes.FirPosition
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.types.FirTypeRef
import org.jetbrains.kotlin.fir.symbols.ConeClassifierSymbol
import org.jetbrains.kotlin.fir.types.ConeKotlinType
import org.jetbrains.kotlin.fir.types.FirTypeRef
import org.jetbrains.kotlin.fir.types.FirUserTypeRef
interface FirTypeResolver {
fun resolveType(typeRef: FirTypeRef, scope: FirScope, position: FirPosition): ConeKotlinType
fun resolveToSymbol(typeRef: FirTypeRef, scope: FirScope, position: FirPosition): ConeSymbol?
fun resolveToSymbol(typeRef: FirTypeRef, scope: FirScope, position: FirPosition): ConeClassifierSymbol?
companion object {
fun getInstance(session: FirSession): FirTypeResolver = session.service()
}
fun resolveUserType(typeRef: FirUserTypeRef, symbol: ConeSymbol?, scope: FirScope): ConeKotlinType
}
fun resolveUserType(typeRef: FirUserTypeRef, symbol: ConeClassifierSymbol?, scope: FirScope): ConeKotlinType
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt
+10 -6
View File
@@ -5,10 +5,11 @@
package org.jetbrains.kotlin.fir.resolve
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
import org.jetbrains.kotlin.fir.symbols.ConeClassifierSymbol
import org.jetbrains.kotlin.fir.declarations.expandedConeType
import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol
import org.jetbrains.kotlin.fir.symbols.ConeClassSymbol
import org.jetbrains.kotlin.fir.symbols.ConeSymbol
import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
import org.jetbrains.kotlin.fir.types.*
@@ -29,17 +30,20 @@ inline fun <K, V, VA : V> MutableMap<K, V>.getOrPut(key: K, defaultValue: (K) ->
}
}
fun ConeSymbol.constructType(typeArguments: Array<ConeKotlinTypeProjection>, isNullable: Boolean): ConeKotlinType {
fun ConeClassLikeLookupTag.toSymbol(useSiteSession: FirSession): ConeClassifierSymbol? =
useSiteSession.getService(FirSymbolProvider::class).getSymbolByLookupTag(this)
fun ConeClassifierSymbol.constructType(typeArguments: Array<ConeKotlinTypeProjection>, isNullable: Boolean): ConeKotlinType {
return when (this) {
is ConeTypeParameterSymbol -> {
ConeTypeParameterTypeImpl(this, isNullable)
}
is ConeClassSymbol -> {
ConeClassTypeImpl(this, typeArguments, isNullable)
ConeClassTypeImpl(this.toLookupTag(), typeArguments, isNullable)
}
is FirTypeAliasSymbol -> {
ConeAbbreviatedTypeImpl(
abbreviationSymbol = this as ConeClassLikeSymbol,
abbreviationLookupTag = this.toLookupTag(),
typeArguments = typeArguments,
directExpansion = fir.expandedConeType ?: ConeClassErrorType("Unresolved expansion"),
isNullable = isNullable
@@ -49,7 +53,7 @@ fun ConeSymbol.constructType(typeArguments: Array<ConeKotlinTypeProjection>, isN
}
}
fun ConeSymbol.constructType(parts: List<FirQualifierPart>, isNullable: Boolean): ConeKotlinType =
fun ConeClassifierSymbol.constructType(parts: List<FirQualifierPart>, isNullable: Boolean): ConeKotlinType =
constructType(parts.toTypeProjections(), isNullable)
fun ConeKotlinType.toTypeProjection(variance: Variance): ConeKotlinTypeProjection =
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirProviderImpl.kt
+3 -12
View File
@@ -15,15 +15,6 @@ import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.FqName
class FirProviderImpl(val session: FirSession) : FirProvider {
override fun getFirClassifierBySymbol(symbol: ConeSymbol): FirNamedDeclaration? {
return when (symbol) {
is FirBasedSymbol<*> -> symbol.fir as? FirNamedDeclaration
is ConeClassLikeSymbol -> getFirClassifierByFqName(symbol.classId)
else -> error("!")
}
}
override fun getClassLikeSymbolByFqName(classId: ClassId): ConeClassLikeSymbol? {
return (getFirClassifierByFqName(classId) as? FirSymbolOwner<*>)?.symbol as? ConeClassLikeSymbol
}
@@ -84,7 +75,7 @@ class FirProviderImpl(val session: FirSession) : FirProvider {
}
private val fileMap = mutableMapOf<FqName, List<FirFile>>()
private val classifierMap = mutableMapOf<ClassId, FirMemberDeclaration>()
private val classifierMap = mutableMapOf<ClassId, FirClassLikeDeclaration>()
private val classifierContainerFileMap = mutableMapOf<ClassId, FirFile>()
private val callableMap = mutableMapOf<CallableId, List<FirNamedDeclaration>>()
@@ -92,8 +83,8 @@ class FirProviderImpl(val session: FirSession) : FirProvider {
return fileMap[fqName].orEmpty()
}
override fun getFirClassifierByFqName(fqName: ClassId): FirMemberDeclaration? {
override fun getFirClassifierByFqName(fqName: ClassId): FirClassLikeDeclaration? {
return classifierMap[fqName]
}
}
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirQualifierResolverImpl.kt
+5 -5
View File
@@ -8,14 +8,14 @@ package org.jetbrains.kotlin.fir.resolve.impl
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.resolve.FirQualifierResolver
import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider
import org.jetbrains.kotlin.fir.symbols.ConeSymbol
import org.jetbrains.kotlin.fir.symbols.ConeClassifierSymbol
import org.jetbrains.kotlin.fir.types.FirQualifierPart
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.FqName
class FirQualifierResolverImpl(val session: FirSession) : FirQualifierResolver {
override fun resolveSymbolWithPrefix(parts: List<FirQualifierPart>, prefix: ClassId): ConeSymbol? {
override fun resolveSymbolWithPrefix(parts: List<FirQualifierPart>, prefix: ClassId): ConeClassifierSymbol? {
val symbolProvider = FirSymbolProvider.getInstance(session)
val fqName = ClassId(
@@ -23,10 +23,10 @@ class FirQualifierResolverImpl(val session: FirSession) : FirQualifierResolver {
parts.drop(1).fold(prefix.relativeClassName) { prefix, suffix -> prefix.child(suffix.name) },
false
)
return symbolProvider.getClassLikeSymbolByFqName(fqName) ?: return null
return symbolProvider.getClassLikeSymbolByFqName(fqName)
}
override fun resolveSymbol(parts: List<FirQualifierPart>): ConeSymbol? {
override fun resolveSymbol(parts: List<FirQualifierPart>): ConeClassifierSymbol? {
val firProvider = FirSymbolProvider.getInstance(session)
if (parts.isNotEmpty()) {
@@ -49,4 +49,4 @@ class FirQualifierResolverImpl(val session: FirSession) : FirQualifierResolver {
private fun List<FirQualifierPart>.toFqNameUnsafe() = toFqName().toUnsafe()
private fun List<FirQualifierPart>.toFqName() = fold(FqName.ROOT) { a, b -> a.child(b.name) }
}
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirTypeResolverImpl.kt
+15 -13
View File
@@ -14,24 +14,28 @@ import org.jetbrains.kotlin.fir.resolve.FirTypeResolver
import org.jetbrains.kotlin.fir.resolve.constructType
import org.jetbrains.kotlin.fir.scopes.FirPosition
import org.jetbrains.kotlin.fir.scopes.FirScope
import org.jetbrains.kotlin.fir.service
import org.jetbrains.kotlin.fir.symbols.*
import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol
import org.jetbrains.kotlin.fir.symbols.ConeClassifierSymbol
import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterSymbol
import org.jetbrains.kotlin.fir.types.*
import org.jetbrains.kotlin.fir.types.impl.*
import org.jetbrains.kotlin.name.ClassId
class FirTypeResolverImpl : FirTypeResolver {
class FirTypeResolverImpl(session: FirSession) : FirTypeResolver {
private val symbolProvider by lazy {
session.getService(FirSymbolProvider::class)
}
private data class ClassIdInSession(val session: FirSession, val id: ClassId)
private val implicitBuiltinTypeSymbols = mutableMapOf<ClassIdInSession, ConeClassLikeSymbol>()
// TODO: get rid of session used here, and may be also of the cache above (see KT-30275)
private fun resolveBuiltInQualified(id: ClassId, session: FirSession): ConeClassLikeSymbol {
val nameInSession = ClassIdInSession(session, id)
return implicitBuiltinTypeSymbols.getOrPut(nameInSession) {
session.service<FirSymbolProvider>().getClassLikeSymbolByFqName(id)!!
symbolProvider.getClassLikeSymbolByFqName(id) as ConeClassLikeSymbol
}
}
@@ -39,14 +43,14 @@ class FirTypeResolverImpl : FirTypeResolver {
typeRef: FirTypeRef,
scope: FirScope,
position: FirPosition
): ConeSymbol? {
): ConeClassifierSymbol? {
return when (typeRef) {
is FirResolvedTypeRef -> typeRef.coneTypeSafe<ConeSymbolBasedType>()?.symbol
is FirResolvedTypeRef -> typeRef.coneTypeSafe<ConeLookupTagBasedType>()?.lookupTag?.let(symbolProvider::getSymbolByLookupTag)
is FirUserTypeRef -> {
val qualifierResolver = FirQualifierResolver.getInstance(typeRef.session)
var resolvedSymbol: ConeSymbol? = null
var resolvedSymbol: ConeClassifierSymbol? = null
scope.processClassifiersByName(typeRef.qualifier.first().name, position) { symbol ->
resolvedSymbol = when (symbol) {
is ConeClassLikeSymbol -> {
@@ -73,11 +77,9 @@ class FirTypeResolverImpl : FirTypeResolver {
}
else -> null
}
}
override fun resolveUserType(typeRef: FirUserTypeRef, symbol: ConeSymbol?, scope: FirScope): ConeKotlinType {
override fun resolveUserType(typeRef: FirUserTypeRef, symbol: ConeClassifierSymbol?, scope: FirScope): ConeKotlinType {
symbol ?: return ConeKotlinErrorType("Symbol not found, for `${typeRef.render()}`")
return symbol.constructType(typeRef.qualifier, typeRef.isMarkedNullable)
}
@@ -100,7 +102,7 @@ class FirTypeResolverImpl : FirTypeResolver {
(typeRef.receiverTypeRef as FirResolvedTypeRef?)?.type,
typeRef.valueParameters.map { it.returnTypeRef.coneTypeUnsafe() },
typeRef.returnTypeRef.coneTypeUnsafe(),
resolveBuiltInQualified(KotlinBuiltIns.getFunctionClassId(typeRef.parametersCount), typeRef.session),
resolveBuiltInQualified(KotlinBuiltIns.getFunctionClassId(typeRef.parametersCount), typeRef.session).toLookupTag(),
typeRef.isMarkedNullable
)
}
@@ -113,4 +115,4 @@ class FirTypeResolverImpl : FirTypeResolver {
else -> error("!")
}
}
}
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractTreeTransformerWithSuperTypes.kt
+23 -12
View File
@@ -6,11 +6,13 @@
package org.jetbrains.kotlin.fir.resolve.transformers
import org.jetbrains.kotlin.descriptors.ClassKind
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.FirRegularClass
import org.jetbrains.kotlin.fir.declarations.expandedConeType
import org.jetbrains.kotlin.fir.declarations.superConeTypes
import org.jetbrains.kotlin.fir.resolve.toSymbol
import org.jetbrains.kotlin.fir.scopes.impl.FirCompositeScope
import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol
import org.jetbrains.kotlin.fir.symbols.ConeClassifierSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
import org.jetbrains.kotlin.fir.types.ConeAbbreviatedType
@@ -34,11 +36,12 @@ abstract class FirAbstractTreeTransformerWithSuperTypes(reversedScopePriority: B
protected fun lookupSuperTypes(
klass: FirRegularClass,
lookupInterfaces: Boolean,
deep: Boolean
deep: Boolean,
useSiteSession: FirSession
): List<ConeClassLikeType> {
return mutableListOf<ConeClassLikeType>().also {
if (lookupInterfaces) klass.symbol.collectSuperTypes(it, deep)
else klass.symbol.collectSuperClasses(it)
if (lookupInterfaces) klass.symbol.collectSuperTypes(it, deep, useSiteSession)
else klass.symbol.collectSuperClasses(it, useSiteSession)
}
}
@@ -49,27 +52,35 @@ abstract class FirAbstractTreeTransformerWithSuperTypes(reversedScopePriority: B
}
}
private tailrec fun ConeClassLikeSymbol.collectSuperClasses(list: MutableList<ConeClassLikeType>) {
private tailrec fun ConeClassifierSymbol.collectSuperClasses(
list: MutableList<ConeClassLikeType>,
useSiteSession: FirSession
) {
when (this) {
is FirClassSymbol -> {
val superClassType =
fir.superConeTypes
.map { it.computePartialExpansion() }
.firstOrNull {
it !is ConeClassErrorType && (it?.symbol as? FirClassSymbol)?.fir?.classKind == ClassKind.CLASS
it !is ConeClassErrorType &&
(it?.lookupTag?.toSymbol(useSiteSession) as? FirClassSymbol)?.fir?.classKind == ClassKind.CLASS
} ?: return
list += superClassType
superClassType.symbol.collectSuperClasses(list)
superClassType.lookupTag.toSymbol(useSiteSession)?.collectSuperClasses(list, useSiteSession)
}
is FirTypeAliasSymbol -> {
val expansion = fir.expandedConeType?.computePartialExpansion() ?: return
expansion.symbol.collectSuperClasses(list)
expansion.lookupTag.toSymbol(useSiteSession)?.collectSuperClasses(list, useSiteSession)
}
else -> error("?!id:1")
}
}
private fun ConeClassLikeSymbol.collectSuperTypes(list: MutableList<ConeClassLikeType>, deep: Boolean) {
private fun ConeClassifierSymbol.collectSuperTypes(
list: MutableList<ConeClassLikeType>,
deep: Boolean,
useSiteSession: FirSession
) {
when (this) {
is FirClassSymbol -> {
val superClassTypes =
@@ -78,15 +89,15 @@ abstract class FirAbstractTreeTransformerWithSuperTypes(reversedScopePriority: B
if (deep)
superClassTypes.forEach {
if (it !is ConeClassErrorType) {
it.symbol.collectSuperTypes(list, deep)
it.lookupTag.toSymbol(useSiteSession)?.collectSuperTypes(list, deep, useSiteSession)
}
}
}
is FirTypeAliasSymbol -> {
val expansion = fir.expandedConeType?.computePartialExpansion() ?: return
expansion.symbol.collectSuperTypes(list, deep)
expansion.lookupTag.toSymbol(useSiteSession)?.collectSuperTypes(list, deep, useSiteSession)
}
else -> error("?!id:1")
}
}
}
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAccessResolveTransformer.kt
+4 -3
View File
@@ -14,6 +14,7 @@ import org.jetbrains.kotlin.fir.declarations.FirRegularClass
import org.jetbrains.kotlin.fir.expressions.*
import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
import org.jetbrains.kotlin.fir.references.FirResolvedCallableReferenceImpl
import org.jetbrains.kotlin.fir.resolve.toSymbol
import org.jetbrains.kotlin.fir.scopes.FirScope
import org.jetbrains.kotlin.fir.scopes.ProcessorAction
import org.jetbrains.kotlin.fir.scopes.ProcessorAction.NEXT
@@ -55,10 +56,10 @@ class FirAccessResolveTransformer : FirAbstractTreeTransformerWithSuperTypes(rev
private fun FirRegularClass.buildUseSiteScope(useSiteSession: FirSession = session): FirClassUseSiteScope {
val superTypeScope = FirCompositeScope(mutableListOf())
val declaredScope = FirClassDeclaredMemberScope(this, useSiteSession)
lookupSuperTypes(this, lookupInterfaces = true, deep = false)
lookupSuperTypes(this, lookupInterfaces = true, deep = false, useSiteSession = useSiteSession)
.mapNotNullTo(superTypeScope.scopes) { useSiteSuperType ->
if (useSiteSuperType is ConeClassErrorType) return@mapNotNullTo null
val symbol = useSiteSuperType.symbol
val symbol = useSiteSuperType.lookupTag.toSymbol(useSiteSession)
if (symbol is FirClassSymbol) {
val scope = symbol.fir.buildUseSiteScope(useSiteSession)
useSiteSuperType.buildSubstitutionScope(useSiteSession, scope, symbol.fir) ?: scope
@@ -160,4 +161,4 @@ class FirAccessResolveTransformer : FirAbstractTreeTransformerWithSuperTypes(rev
}
}
}
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeResolveTransformer.kt
+36 -40
View File
@@ -14,9 +14,11 @@ import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider
import org.jetbrains.kotlin.fir.resolve.FirTypeResolver
import org.jetbrains.kotlin.fir.scopes.FirPosition
import org.jetbrains.kotlin.fir.scopes.impl.*
import org.jetbrains.kotlin.fir.symbols.*
import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
import org.jetbrains.kotlin.fir.service
import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol
import org.jetbrains.kotlin.fir.symbols.ConeClassifierSymbol
import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
import org.jetbrains.kotlin.fir.transformSingle
import org.jetbrains.kotlin.fir.types.*
import org.jetbrains.kotlin.fir.types.impl.FirErrorTypeRefImpl
@@ -29,8 +31,11 @@ import org.jetbrains.kotlin.fir.visitors.compose
open class FirTypeResolveTransformer(
private val traversedClassifiers: Set<FirMemberDeclaration> = setOf()
) : FirAbstractTreeTransformerWithSuperTypes(reversedScopePriority = true) {
private lateinit var firProvider: FirProvider
override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult<FirFile> {
val session = file.session
firProvider = session.getService(FirProvider::class)
return withScopeCleanup {
towerScope.scopes += listOf(
// from low priority to high priority
@@ -63,11 +68,13 @@ open class FirTypeResolveTransformer(
}
}
return withScopeCleanup {
val firProvider = FirProvider.getInstance(regularClass.session)
val session = regularClass.session
val firProvider = FirProvider.getInstance(session)
val classId = regularClass.symbol.classId
lookupSuperTypes(regularClass, lookupInterfaces = false, deep = true).asReversed().mapTo(towerScope.scopes) {
FirNestedClassifierScope(it.symbol.classId, FirSymbolProvider.getInstance(regularClass.session))
}
lookupSuperTypes(regularClass, lookupInterfaces = false, deep = true, useSiteSession = session)
.asReversed().mapTo(towerScope.scopes) {
FirNestedClassifierScope(it.lookupTag.classId, FirSymbolProvider.getInstance(session))
}
val companionObjects = regularClass.declarations.filterIsInstance<FirRegularClass>().filter { it.isCompanion }
for (companionObject in companionObjects) {
towerScope.scopes += FirNestedClassifierScope(companionObject.symbol.classId, firProvider)
@@ -173,40 +180,29 @@ open class FirTypeResolveTransformer(
}
private fun walkSymbols(symbol: ConeSymbol) {
if (symbol is ConeClassLikeSymbol) {
if (symbol is FirBasedSymbol<*>) {
val classId = symbol.classId
private fun walkSymbols(symbol: ConeClassifierSymbol) {
if (symbol !is ConeClassLikeSymbol || symbol !is FirBasedSymbol<*>) return
val classId = symbol.classId
val classes = generateSequence(classId) { it.outerClassId }.toList().asReversed()
if (symbol is ConeTypeAliasSymbol) {
val fir = symbol.fir as FirTypeAlias
if (fir.expandedTypeRef is FirResolvedTypeRef) return
} else if (symbol is ConeClassSymbol) {
val fir = symbol.fir as FirClass
if (fir.superTypeRefs.all { it is FirResolvedTypeRef }) return
}
val firProvider = FirProvider.getInstance(symbol.fir.session)
val classes = generateSequence(classId) { it.outerClassId }.toList().asReversed()
val file = firProvider.getFirClassifierContainerFile(classes.first())
val firElementsToVisit = classes.asSequence().map {
firProvider.getFirClassifierByFqName(it)!!
}
val transformer = SuperTypeResolveTransformer(
firElementsToVisit.iterator(), traversedClassifiers
)
file.transformSingle(transformer, null)
} else {
if (symbol is FirTypeAliasSymbol) {
symbol.fir.expandedConeType?.let { if (it !is ConeClassErrorType) walkSymbols(it.symbol) }
} else if (symbol is FirClassSymbol) {
symbol.fir.superConeTypes.forEach { if (it !is ConeClassErrorType) walkSymbols(it.symbol) }
}
}
val fir = symbol.fir
if (fir is FirTypeAlias) {
if (fir.expandedTypeRef is FirResolvedTypeRef) return
} else if (fir is FirClass) {
if (fir.superTypeRefs.all { it is FirResolvedTypeRef }) return
}
val firProvider = fir.session.service<FirProvider>()
val file = firProvider.getFirClassifierContainerFile(classes.first())
val firElementsToVisit = classes.asSequence().map {
firProvider.getFirClassifierByFqName(it)!!
}
val transformer = SuperTypeResolveTransformer(
firElementsToVisit.iterator(), traversedClassifiers
)
file.transformSingle(transformer, null)
}
override fun transformTypeRef(typeRef: FirTypeRef, data: Nothing?): CompositeTransformResult<FirTypeRef> {
@@ -229,4 +225,4 @@ open class FirTypeResolveTransformer(
return myTransformer.transformType(typeRef, typeResolver.resolveUserType(typeRef, symbol, towerScope))
}
}
}
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/FirScope.kt
+3 -3
View File
@@ -6,16 +6,16 @@
package org.jetbrains.kotlin.fir.scopes
import org.jetbrains.kotlin.fir.scopes.ProcessorAction.NEXT
import org.jetbrains.kotlin.fir.symbols.ConeClassifierSymbol
import org.jetbrains.kotlin.fir.symbols.ConeFunctionSymbol
import org.jetbrains.kotlin.fir.symbols.ConePropertySymbol
import org.jetbrains.kotlin.fir.symbols.ConeSymbol
import org.jetbrains.kotlin.name.Name
interface FirScope {
fun processClassifiersByName(
name: Name,
position: FirPosition,
processor: (ConeSymbol) -> Boolean
processor: (ConeClassifierSymbol) -> Boolean
): Boolean = true
fun processFunctionsByName(
@@ -46,4 +46,4 @@ enum class ProcessorAction {
}
fun next() = this == NEXT
}
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/FirTypeParameterScope.kt
+3 -3
View File
@@ -6,7 +6,7 @@
package org.jetbrains.kotlin.fir.scopes
import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
import org.jetbrains.kotlin.fir.symbols.ConeSymbol
import org.jetbrains.kotlin.fir.symbols.ConeClassifierSymbol
import org.jetbrains.kotlin.name.Name
interface FirTypeParameterScope : FirScope {
@@ -15,10 +15,10 @@ interface FirTypeParameterScope : FirScope {
override fun processClassifiersByName(
name: Name,
position: FirPosition,
processor: (ConeSymbol) -> Boolean
processor: (ConeClassifierSymbol) -> Boolean
): Boolean {
val matchedTypeParameters = typeParameters[name] ?: return true
return matchedTypeParameters.all { processor(it.symbol) }
}
}
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirAbstractSimpleImportingScope.kt
+3 -3
View File
@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedImportImpl
import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider
import org.jetbrains.kotlin.fir.scopes.FirPosition
import org.jetbrains.kotlin.fir.scopes.FirScope
import org.jetbrains.kotlin.fir.symbols.ConeSymbol
import org.jetbrains.kotlin.fir.symbols.ConeClassifierSymbol
import org.jetbrains.kotlin.name.Name
abstract class FirAbstractSimpleImportingScope(val session: FirSession) : FirScope {
@@ -20,7 +20,7 @@ abstract class FirAbstractSimpleImportingScope(val session: FirSession) : FirSco
override fun processClassifiersByName(
name: Name,
position: FirPosition,
processor: (ConeSymbol) -> Boolean
processor: (ConeClassifierSymbol) -> Boolean
): Boolean {
val imports = simpleImports[name] ?: return true
if (imports.isEmpty()) return true
@@ -34,4 +34,4 @@ abstract class FirAbstractSimpleImportingScope(val session: FirSession) : FirSco
return true
}
}
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirAbstractStarImportingScope.kt
+3 -3
View File
@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.scopes.impl
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.FirResolvedImport
import org.jetbrains.kotlin.fir.scopes.FirPosition
import org.jetbrains.kotlin.fir.symbols.ConeSymbol
import org.jetbrains.kotlin.fir.symbols.ConeClassifierSymbol
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.Name
@@ -21,7 +21,7 @@ abstract class FirAbstractStarImportingScope(
override fun processClassifiersByName(
name: Name,
position: FirPosition,
processor: (ConeSymbol) -> Boolean
processor: (ConeClassifierSymbol) -> Boolean
): Boolean {
for (import in starImports) {
val relativeClassName = import.relativeClassName
@@ -38,4 +38,4 @@ abstract class FirAbstractStarImportingScope(
return true
}
}
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassSubstitutionScope.kt
+7 -3
View File
@@ -63,9 +63,13 @@ class FirClassSubstitutionScope(
return when (this) {
is ConeKotlinErrorType -> error("Trying to substitute arguments for error type")
is ConeTypeParameterType -> error("Trying to substitute arguments for type parameter")
is ConeClassTypeImpl -> ConeClassTypeImpl(symbol, newArguments as Array<ConeKotlinTypeProjection>, nullability.isNullable)
is ConeClassTypeImpl -> ConeClassTypeImpl(
lookupTag,
newArguments as Array<ConeKotlinTypeProjection>,
nullability.isNullable
)
is ConeAbbreviatedTypeImpl -> ConeAbbreviatedTypeImpl(
abbreviationSymbol,
abbreviationLookupTag,
newArguments as Array<ConeKotlinTypeProjection>,
directExpansion.substitute() as? ConeClassLikeType ?: directExpansion,
nullability.isNullable
@@ -148,4 +152,4 @@ fun FirTypeRef.withReplacedConeType(newType: ConeKotlinType?): FirResolvedTypeRe
annotations
)
}
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirCompositeScope.kt
+3 -3
View File
@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.fir.scopes.ProcessorAction.NEXT
import org.jetbrains.kotlin.fir.scopes.ProcessorAction.STOP
import org.jetbrains.kotlin.fir.symbols.ConeFunctionSymbol
import org.jetbrains.kotlin.fir.symbols.ConePropertySymbol
import org.jetbrains.kotlin.fir.symbols.ConeSymbol
import org.jetbrains.kotlin.fir.symbols.ConeClassifierSymbol
import org.jetbrains.kotlin.name.Name
class FirCompositeScope(
@@ -23,7 +23,7 @@ class FirCompositeScope(
override fun processClassifiersByName(
name: Name,
position: FirPosition,
processor: (ConeSymbol) -> Boolean
processor: (ConeClassifierSymbol) -> Boolean
): Boolean {
val scopes = if (reversedPriority) scopes.asReversed() else scopes
for (scope in scopes) {
@@ -57,4 +57,4 @@ class FirCompositeScope(
return processComposite(FirScope::processPropertiesByName, name, processor)
}
}
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirNestedClassifierScope.kt
+2 -2
View File
@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.scopes.impl
import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider
import org.jetbrains.kotlin.fir.scopes.FirPosition
import org.jetbrains.kotlin.fir.scopes.FirScope
import org.jetbrains.kotlin.fir.symbols.ConeSymbol
import org.jetbrains.kotlin.fir.symbols.ConeClassifierSymbol
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.Name
@@ -20,7 +20,7 @@ class FirNestedClassifierScope(
override fun processClassifiersByName(
name: Name,
position: FirPosition,
processor: (ConeSymbol) -> Boolean
processor: (ConeClassifierSymbol) -> Boolean
): Boolean {
val child = classId.createNestedClassId(name)
val symbol = symbolProvider.getClassLikeSymbolByFqName(child)
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirSelfImportingScope.kt
+4 -4
View File
@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider
import org.jetbrains.kotlin.fir.scopes.FirPosition
import org.jetbrains.kotlin.fir.scopes.FirScope
import org.jetbrains.kotlin.fir.symbols.ConeSymbol
import org.jetbrains.kotlin.fir.symbols.ConeClassifierSymbol
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
@@ -19,13 +19,13 @@ class FirSelfImportingScope(val fqName: FqName, val session: FirSession) : FirSc
private val symbolProvider = FirSymbolProvider.getInstance(session)
private val cache = ContainerUtil.newConcurrentMap<Name, ConeSymbol>()
private val cache = ContainerUtil.newConcurrentMap<Name, ConeClassifierSymbol>()
private val absentKeys = ContainerUtil.newConcurrentSet<Name>()
override fun processClassifiersByName(
name: Name,
position: FirPosition,
processor: (ConeSymbol) -> Boolean
processor: (ConeClassifierSymbol) -> Boolean
): Boolean {
@@ -47,4 +47,4 @@ class FirSelfImportingScope(val fqName: FqName, val session: FirSession) : FirSc
true
}
}
}
}
compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt
+10 -7
View File
@@ -1,5 +1,5 @@
/*
* Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
* Copyright 2000-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.
*/
@@ -10,9 +10,12 @@ import org.jetbrains.kotlin.descriptors.Visibility
import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.expressions.*
import org.jetbrains.kotlin.fir.expressions.impl.*
import org.jetbrains.kotlin.fir.expressions.impl.FirElseIfTrueCondition
import org.jetbrains.kotlin.fir.expressions.impl.FirExpressionStub
import org.jetbrains.kotlin.fir.expressions.impl.FirUnitExpression
import org.jetbrains.kotlin.fir.expressions.impl.FirWhenSubjectExpression
import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol
import org.jetbrains.kotlin.fir.symbols.ConeSymbol
import org.jetbrains.kotlin.fir.symbols.ConeClassifierSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
@@ -608,7 +611,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
visitTypeRefWithNullability(functionTypeRef)
}
private fun ConeSymbol.asString(): String {
private fun ConeClassifierSymbol.asString(): String {
return when (this) {
is ConeClassLikeSymbol -> classId.asString()
is FirTypeParameterSymbol -> fir.name.asString()
@@ -622,7 +625,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
is ConeClassErrorType -> "class error: $reason"
is ConeClassLikeType -> {
val sb = StringBuilder()
sb.append(symbol.classId.asString())
sb.append(lookupTag.classId.asString())
if (typeArguments.isNotEmpty()) {
sb.append(typeArguments.joinToString(prefix = "<", postfix = ">") {
when (it) {
@@ -639,7 +642,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
sb.toString()
}
is ConeTypeParameterType -> {
symbol.asString()
lookupTag.name.asString()
}
is ConeFunctionType -> {
buildString {
@@ -864,4 +867,4 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
override fun visitErrorExpression(errorExpression: FirErrorExpression) {
print("ERROR_EXPR(${errorExpression.reason})")
}
}
}
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirClassLikeDeclaration.kt
+12
View File
@@ -0,0 +1,12 @@
/*
* Copyright 2010-2019 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.symbols.ConeClassifierSymbol
interface FirClassLikeDeclaration : FirMemberDeclaration {
val symbol: ConeClassifierSymbol
}
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirRegularClass.kt
+3 -3
View File
@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.fir.visitors.FirVisitor
// May be all containers should be properties and not base classes
// About descriptors: introduce something like FirDescriptor which is FirUnresolved at the beginning and FirSymbol(descriptor) at the end
@BaseTransformedType
interface FirRegularClass : FirClass, @VisitedSupertype FirMemberDeclaration, FirSymbolOwner<FirRegularClass> {
interface FirRegularClass : FirClass, @VisitedSupertype FirClassLikeDeclaration, FirSymbolOwner<FirRegularClass> {
val isInner: Boolean get() = status.isInner
val isCompanion: Boolean get() = status.isCompanion
@@ -29,7 +29,7 @@ interface FirRegularClass : FirClass, @VisitedSupertype FirMemberDeclaration, Fi
visitor.visitRegularClass(this, data)
override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
super<FirMemberDeclaration>.acceptChildren(visitor, data)
super<FirClassLikeDeclaration>.acceptChildren(visitor, data)
super<FirClass>.acceptChildren(visitor, data)
}
}
}
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirTypeAlias.kt
+5 -2
View File
@@ -6,14 +6,17 @@
package org.jetbrains.kotlin.fir.declarations
import org.jetbrains.kotlin.fir.symbols.FirSymbolOwner
import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
import org.jetbrains.kotlin.fir.types.ConeClassLikeType
import org.jetbrains.kotlin.fir.types.FirTypeRef
import org.jetbrains.kotlin.fir.types.coneTypeSafe
import org.jetbrains.kotlin.fir.visitors.FirVisitor
interface FirTypeAlias : FirMemberDeclaration, FirSymbolOwner<FirTypeAlias> {
interface FirTypeAlias : FirClassLikeDeclaration, FirSymbolOwner<FirTypeAlias> {
val expandedTypeRef: FirTypeRef
override val symbol: FirTypeAliasSymbol
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
visitor.visitTypeAlias(this, data)
@@ -24,4 +27,4 @@ interface FirTypeAlias : FirMemberDeclaration, FirSymbolOwner<FirTypeAlias> {
}
val FirTypeAlias.expandedConeType: ConeClassLikeType? get() = expandedTypeRef.coneTypeSafe()
val FirTypeAlias.expandedConeType: ConeClassLikeType? get() = expandedTypeRef.coneTypeSafe()
compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirClassSymbol.kt
+5 -1
View File
@@ -7,7 +7,11 @@ package org.jetbrains.kotlin.fir.symbols.impl
import org.jetbrains.kotlin.fir.declarations.FirRegularClass
import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTagImpl
import org.jetbrains.kotlin.fir.symbols.ConeClassSymbol
import org.jetbrains.kotlin.name.ClassId
class FirClassSymbol(override val classId: ClassId) : ConeClassSymbol, AbstractFirBasedSymbol<FirRegularClass>()
class FirClassSymbol(override val classId: ClassId) : ConeClassSymbol, AbstractFirBasedSymbol<FirRegularClass>() {
override fun toLookupTag(): ConeClassLikeLookupTag = ConeClassLikeLookupTagImpl(classId)
}
compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirTypeAliasSymbol.kt
+11 -1
View File
@@ -7,7 +7,17 @@ package org.jetbrains.kotlin.fir.symbols.impl
import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
import org.jetbrains.kotlin.fir.symbols.ConeTypeAliasLookupTag
import org.jetbrains.kotlin.fir.symbols.ConeTypeAliasSymbol
import org.jetbrains.kotlin.name.ClassId
class FirTypeAliasSymbol(override val classId: ClassId) : ConeTypeAliasSymbol, AbstractFirBasedSymbol<FirTypeAlias>()
class FirTypeAliasSymbol(
override val classId: ClassId
) : ConeTypeAliasSymbol, AbstractFirBasedSymbol<FirTypeAlias>() {
override fun toLookupTag(): ConeClassLikeLookupTag = TypeAliasLookupTagImpl(classId)
}
class TypeAliasLookupTagImpl(
override val classId: ClassId
) : ConeTypeAliasLookupTag
compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirTypeParameterSymbol.kt
+10 -4
View File
@@ -6,11 +6,17 @@
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
import org.jetbrains.kotlin.fir.symbols.*
import org.jetbrains.kotlin.name.Name
class FirTypeParameterSymbol : AbstractFirBasedSymbol<FirTypeParameter>(), ConeTypeParameterSymbol {
class FirTypeParameterSymbol : AbstractFirBasedSymbol<FirTypeParameter>(), ConeTypeParameterSymbol, ConeTypeParameterLookupTag,
ConeClassifierLookupTagWithFixedSymbol {
override val name: Name
get() = fir.name
}
override val symbol: ConeClassifierSymbol
get() = this
override fun toLookupTag(): ConeTypeParameterLookupTag = this
}
compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirTransformerGenerated.kt
+10 -2
View File
@@ -72,8 +72,12 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
return transformNamedDeclaration(memberDeclaration, data)
}
open fun transformClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, data: D): CompositeTransformResult<FirDeclaration> {
return transformMemberDeclaration(classLikeDeclaration, data)
}
open fun transformRegularClass(regularClass: FirRegularClass, data: D): CompositeTransformResult<FirDeclaration> {
return transformMemberDeclaration(regularClass, data)
return transformClassLikeDeclaration(regularClass, data)
}
open fun transformEnumEntry(enumEntry: FirEnumEntry, data: D): CompositeTransformResult<FirDeclaration> {
@@ -81,7 +85,7 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
}
open fun transformTypeAlias(typeAlias: FirTypeAlias, data: D): CompositeTransformResult<FirDeclaration> {
return transformMemberDeclaration(typeAlias, data)
return transformClassLikeDeclaration(typeAlias, data)
}
open fun transformTypeParameter(typeParameter: FirTypeParameter, data: D): CompositeTransformResult<FirDeclaration> {
@@ -420,6 +424,10 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
return transformClass(klass, data)
}
final override fun visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, data: D): CompositeTransformResult<FirElement> {
return transformClassLikeDeclaration(classLikeDeclaration, data)
}
final override fun visitClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression, data: D): CompositeTransformResult<FirElement> {
return transformClassReferenceExpression(classReferenceExpression, data)
}
compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorGenerated.kt
+6 -2
View File
@@ -72,8 +72,12 @@ abstract class FirVisitor<out R, in D> {
return visitNamedDeclaration(memberDeclaration, data)
}
open fun visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, data: D): R {
return visitMemberDeclaration(classLikeDeclaration, data)
}
open fun visitRegularClass(regularClass: FirRegularClass, data: D): R {
return visitMemberDeclaration(regularClass, data)
return visitClassLikeDeclaration(regularClass, data)
}
open fun visitEnumEntry(enumEntry: FirEnumEntry, data: D): R {
@@ -81,7 +85,7 @@ abstract class FirVisitor<out R, in D> {
}
open fun visitTypeAlias(typeAlias: FirTypeAlias, data: D): R {
return visitMemberDeclaration(typeAlias, data)
return visitClassLikeDeclaration(typeAlias, data)
}
open fun visitTypeParameter(typeParameter: FirTypeParameter, data: D): R {
compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorVoidGenerated.kt
+10 -2
View File
@@ -72,8 +72,12 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
visitNamedDeclaration(memberDeclaration, null)
}
open fun visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration) {
visitMemberDeclaration(classLikeDeclaration, null)
}
open fun visitRegularClass(regularClass: FirRegularClass) {
visitMemberDeclaration(regularClass, null)
visitClassLikeDeclaration(regularClass, null)
}
open fun visitEnumEntry(enumEntry: FirEnumEntry) {
@@ -81,7 +85,7 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
}
open fun visitTypeAlias(typeAlias: FirTypeAlias) {
visitMemberDeclaration(typeAlias, null)
visitClassLikeDeclaration(typeAlias, null)
}
open fun visitTypeParameter(typeParameter: FirTypeParameter) {
@@ -420,6 +424,10 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
visitClass(klass)
}
final override fun visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, data: Nothing?) {
visitClassLikeDeclaration(classLikeDeclaration)
}
final override fun visitClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression, data: Nothing?) {
visitClassReferenceExpression(classReferenceExpression)
}
idea/testData/fir/multiModule/mppSuperTypes/jvm/jvm.kt
Vendored
-1
View File
@@ -13,7 +13,6 @@ actual open class A : X(), Y {
class C : B() {
fun test() {
foo()
// This and next cannot be resolved yet due to lack of search symbols / projections
bar()
baz()
}
idea/testData/fir/multiModule/mppSuperTypes/jvm/jvm.txt
Vendored
+2 -2
View File
@@ -23,8 +23,8 @@ FILE: jvm.kt
public final function test(): R|kotlin/Unit| {
R|/A.foo|()
<Unresolved name: bar>#()
<Unresolved name: baz>#()
R|/X.bar|()
R|/Y.baz|()
}
}