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

[FIR] Add symbol to all declarations. Get rid of FirSymbolOwner

Browse Source
This commit is contained in:
Dmitriy Novozhilov
2021-06-20 11:42:52 +03:00
parent 39cd1c8504
commit b3e5c6e079
254 changed files with 1305 additions and 1297 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/FirSymbolOwner.kt
-26
View File
@@ -1,26 +0,0 @@
/*
* Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
* Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
*/
package org.jetbrains.kotlin.fir
import org.jetbrains.kotlin.fir.declarations.FirDeclaration
import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
import org.jetbrains.kotlin.fir.visitors.*
/*
* This file was generated automatically
* DO NOT MODIFY IT MANUALLY
*/
interface FirSymbolOwner<E> : FirElement where E : FirSymbolOwner<E>, E : FirDeclaration {
override val source: FirSourceElement?
val symbol: FirBasedSymbol<E>
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitSymbolOwner(this, data)
@Suppress("UNCHECKED_CAST")
override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
transformer.transformSymbolOwner(this, data) as E
}
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirAnnotatedDeclaration.kt
+4 -2
View File
@@ -10,6 +10,7 @@ import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirModuleData
import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
import org.jetbrains.kotlin.fir.visitors.*
/*
@@ -17,8 +18,9 @@ import org.jetbrains.kotlin.fir.visitors.*
* DO NOT MODIFY IT MANUALLY
*/
sealed interface FirAnnotatedDeclaration : FirDeclaration, FirAnnotationContainer {
sealed interface FirAnnotatedDeclaration<E : FirAnnotatedDeclaration<E>> : FirDeclaration<E>, FirAnnotationContainer {
override val source: FirSourceElement?
override val symbol: FirBasedSymbol<E>
override val moduleData: FirModuleData
override val resolvePhase: FirResolvePhase
override val origin: FirDeclarationOrigin
@@ -33,5 +35,5 @@ sealed interface FirAnnotatedDeclaration : FirDeclaration, FirAnnotationContaine
override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirAnnotatedDeclaration
override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirAnnotatedDeclaration<E>
}
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirAnonymousInitializer.kt
+1 -2
View File
@@ -9,7 +9,6 @@ import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirModuleData
import org.jetbrains.kotlin.fir.FirPureAbstractElement
import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.FirSymbolOwner
import org.jetbrains.kotlin.fir.expressions.FirBlock
import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousInitializerSymbol
@@ -20,7 +19,7 @@ import org.jetbrains.kotlin.fir.visitors.*
* DO NOT MODIFY IT MANUALLY
*/
abstract class FirAnonymousInitializer : FirPureAbstractElement(), FirDeclaration, FirSymbolOwner<FirAnonymousInitializer>, FirControlFlowGraphOwner {
abstract class FirAnonymousInitializer : FirPureAbstractElement(), FirDeclaration<FirAnonymousInitializer>, FirControlFlowGraphOwner {
abstract override val source: FirSourceElement?
abstract override val moduleData: FirModuleData
abstract override val resolvePhase: FirResolvePhase
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirAnonymousObject.kt
+1 -1
View File
@@ -30,7 +30,7 @@ abstract class FirAnonymousObject : FirClass<FirAnonymousObject>(), FirControlFl
abstract override val typeParameters: List<FirTypeParameterRef>
abstract override val classKind: ClassKind
abstract override val superTypeRefs: List<FirTypeRef>
abstract override val declarations: List<FirDeclaration>
abstract override val declarations: List<FirDeclaration<*>>
abstract override val annotations: List<FirAnnotationCall>
abstract override val scopeProvider: FirScopeProvider
abstract override val controlFlowGraphReference: FirControlFlowGraphReference?
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirCallableDeclaration.kt
+5 -6
View File
@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.fir.declarations
import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirModuleData
import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.FirSymbolOwner
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
import org.jetbrains.kotlin.fir.types.FirTypeRef
@@ -19,7 +18,7 @@ import org.jetbrains.kotlin.fir.visitors.*
* DO NOT MODIFY IT MANUALLY
*/
sealed interface FirCallableDeclaration<F : FirCallableDeclaration<F>> : FirTypedDeclaration, FirSymbolOwner<F> {
sealed interface FirCallableDeclaration<E : FirCallableDeclaration<E>> : FirTypedDeclaration<E> {
override val source: FirSourceElement?
override val moduleData: FirModuleData
override val resolvePhase: FirResolvePhase
@@ -28,7 +27,7 @@ sealed interface FirCallableDeclaration<F : FirCallableDeclaration<F>> : FirType
override val annotations: List<FirAnnotationCall>
override val returnTypeRef: FirTypeRef
val receiverTypeRef: FirTypeRef?
override val symbol: FirCallableSymbol<F>
override val symbol: FirCallableSymbol<E>
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitCallableDeclaration(this, data)
@@ -42,9 +41,9 @@ sealed interface FirCallableDeclaration<F : FirCallableDeclaration<F>> : FirType
fun replaceReceiverTypeRef(newReceiverTypeRef: FirTypeRef?)
override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirCallableDeclaration<F>
override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirCallableDeclaration<E>
override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirCallableDeclaration<F>
override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirCallableDeclaration<E>
fun <D> transformReceiverTypeRef(transformer: FirTransformer<D>, data: D): FirCallableDeclaration<F>
fun <D> transformReceiverTypeRef(transformer: FirTransformer<D>, data: D): FirCallableDeclaration<E>
}
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirCallableMemberDeclaration.kt
+7 -7
View File
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.fir.visitors.*
* DO NOT MODIFY IT MANUALLY
*/
sealed interface FirCallableMemberDeclaration<F : FirCallableMemberDeclaration<F>> : FirCallableDeclaration<F>, FirMemberDeclaration {
sealed interface FirCallableMemberDeclaration<E : FirCallableMemberDeclaration<E>> : FirCallableDeclaration<E>, FirMemberDeclaration<E> {
override val source: FirSourceElement?
override val moduleData: FirModuleData
override val resolvePhase: FirResolvePhase
@@ -29,7 +29,7 @@ sealed interface FirCallableMemberDeclaration<F : FirCallableMemberDeclaration<F
override val annotations: List<FirAnnotationCall>
override val returnTypeRef: FirTypeRef
override val receiverTypeRef: FirTypeRef?
override val symbol: FirCallableSymbol<F>
override val symbol: FirCallableSymbol<E>
override val typeParameters: List<FirTypeParameterRef>
override val status: FirDeclarationStatus
val containerSource: DeserializedContainerSource?
@@ -47,13 +47,13 @@ sealed interface FirCallableMemberDeclaration<F : FirCallableMemberDeclaration<F
override fun replaceReceiverTypeRef(newReceiverTypeRef: FirTypeRef?)
override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirCallableMemberDeclaration<F>
override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirCallableMemberDeclaration<E>
override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirCallableMemberDeclaration<F>
override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirCallableMemberDeclaration<E>
override fun <D> transformReceiverTypeRef(transformer: FirTransformer<D>, data: D): FirCallableMemberDeclaration<F>
override fun <D> transformReceiverTypeRef(transformer: FirTransformer<D>, data: D): FirCallableMemberDeclaration<E>
override fun <D> transformTypeParameters(transformer: FirTransformer<D>, data: D): FirCallableMemberDeclaration<F>
override fun <D> transformTypeParameters(transformer: FirTransformer<D>, data: D): FirCallableMemberDeclaration<E>
override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirCallableMemberDeclaration<F>
override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirCallableMemberDeclaration<E>
}
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirClass.kt
+7 -7
View File
@@ -21,17 +21,17 @@ import org.jetbrains.kotlin.fir.visitors.*
* DO NOT MODIFY IT MANUALLY
*/
sealed class FirClass<F : FirClass<F>> : FirClassLikeDeclaration<F>(), FirStatement, FirTypeParameterRefsOwner {
sealed class FirClass<E : FirClass<E>> : FirClassLikeDeclaration<E>(), FirStatement, FirTypeParameterRefsOwner {
abstract override val source: FirSourceElement?
abstract override val moduleData: FirModuleData
abstract override val resolvePhase: FirResolvePhase
abstract override val origin: FirDeclarationOrigin
abstract override val attributes: FirDeclarationAttributes
abstract override val typeParameters: List<FirTypeParameterRef>
abstract override val symbol: FirClassSymbol<F>
abstract override val symbol: FirClassSymbol<E>
abstract val classKind: ClassKind
abstract val superTypeRefs: List<FirTypeRef>
abstract val declarations: List<FirDeclaration>
abstract val declarations: List<FirDeclaration<*>>
abstract override val annotations: List<FirAnnotationCall>
abstract val scopeProvider: FirScopeProvider
@@ -45,11 +45,11 @@ sealed class FirClass<F : FirClass<F>> : FirClassLikeDeclaration<F>(), FirStatem
abstract fun replaceSuperTypeRefs(newSuperTypeRefs: List<FirTypeRef>)
abstract override fun <D> transformTypeParameters(transformer: FirTransformer<D>, data: D): FirClass<F>
abstract override fun <D> transformTypeParameters(transformer: FirTransformer<D>, data: D): FirClass<E>
abstract fun <D> transformSuperTypeRefs(transformer: FirTransformer<D>, data: D): FirClass<F>
abstract fun <D> transformSuperTypeRefs(transformer: FirTransformer<D>, data: D): FirClass<E>
abstract fun <D> transformDeclarations(transformer: FirTransformer<D>, data: D): FirClass<F>
abstract fun <D> transformDeclarations(transformer: FirTransformer<D>, data: D): FirClass<E>
abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirClass<F>
abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirClass<E>
}
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirClassLikeDeclaration.kt
+3 -4
View File
@@ -9,7 +9,6 @@ import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirModuleData
import org.jetbrains.kotlin.fir.FirPureAbstractElement
import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.FirSymbolOwner
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
import org.jetbrains.kotlin.fir.expressions.FirStatement
import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
@@ -20,14 +19,14 @@ import org.jetbrains.kotlin.fir.visitors.*
* DO NOT MODIFY IT MANUALLY
*/
sealed class FirClassLikeDeclaration<F : FirClassLikeDeclaration<F>> : FirPureAbstractElement(), FirAnnotatedDeclaration, FirStatement, FirSymbolOwner<F> {
sealed class FirClassLikeDeclaration<E : FirClassLikeDeclaration<E>> : FirPureAbstractElement(), FirAnnotatedDeclaration<E>, FirStatement {
abstract override val source: FirSourceElement?
abstract override val moduleData: FirModuleData
abstract override val resolvePhase: FirResolvePhase
abstract override val origin: FirDeclarationOrigin
abstract override val attributes: FirDeclarationAttributes
abstract override val annotations: List<FirAnnotationCall>
abstract override val symbol: FirClassLikeSymbol<F>
abstract override val symbol: FirClassLikeSymbol<E>
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitClassLikeDeclaration(this, data)
@@ -37,5 +36,5 @@ sealed class FirClassLikeDeclaration<F : FirClassLikeDeclaration<F>> : FirPureAb
abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirClassLikeDeclaration<F>
abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirClassLikeDeclaration<E>
}
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirDeclaration.kt
+3 -1
View File
@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir.declarations
import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirModuleData
import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
import org.jetbrains.kotlin.fir.visitors.*
/*
@@ -15,8 +16,9 @@ import org.jetbrains.kotlin.fir.visitors.*
* DO NOT MODIFY IT MANUALLY
*/
sealed interface FirDeclaration : FirElement {
sealed interface FirDeclaration<E : FirDeclaration<E>> : FirElement {
override val source: FirSourceElement?
val symbol: FirBasedSymbol<E>
val moduleData: FirModuleData
val resolvePhase: FirResolvePhase
val origin: FirDeclarationOrigin
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirFile.kt
+4 -2
View File
@@ -10,6 +10,7 @@ import org.jetbrains.kotlin.fir.FirModuleData
import org.jetbrains.kotlin.fir.FirPureAbstractElement
import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
import org.jetbrains.kotlin.fir.symbols.impl.FirFileSymbol
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.fir.visitors.*
@@ -18,7 +19,7 @@ import org.jetbrains.kotlin.fir.visitors.*
* DO NOT MODIFY IT MANUALLY
*/
abstract class FirFile : FirPureAbstractElement(), FirAnnotatedDeclaration {
abstract class FirFile : FirPureAbstractElement(), FirAnnotatedDeclaration<FirFile> {
abstract override val source: FirSourceElement?
abstract override val moduleData: FirModuleData
abstract override val resolvePhase: FirResolvePhase
@@ -26,9 +27,10 @@ abstract class FirFile : FirPureAbstractElement(), FirAnnotatedDeclaration {
abstract override val attributes: FirDeclarationAttributes
abstract override val annotations: List<FirAnnotationCall>
abstract val imports: List<FirImport>
abstract val declarations: List<FirDeclaration>
abstract val declarations: List<FirDeclaration<*>>
abstract val name: String
abstract val packageFqName: FqName
abstract override val symbol: FirFileSymbol
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitFile(this, data)
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirFunction.kt
+8 -8
View File
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.fir.visitors.*
* DO NOT MODIFY IT MANUALLY
*/
sealed class FirFunction<F : FirFunction<F>> : FirPureAbstractElement(), FirCallableDeclaration<F>, FirTargetElement, FirTypeParameterRefsOwner, FirControlFlowGraphOwner, FirStatement {
sealed class FirFunction<E : FirFunction<E>> : FirPureAbstractElement(), FirCallableDeclaration<E>, FirTargetElement, FirTypeParameterRefsOwner, FirControlFlowGraphOwner, FirStatement {
abstract override val source: FirSourceElement?
abstract override val moduleData: FirModuleData
abstract override val resolvePhase: FirResolvePhase
@@ -34,7 +34,7 @@ sealed class FirFunction<F : FirFunction<F>> : FirPureAbstractElement(), FirCall
abstract override val receiverTypeRef: FirTypeRef?
abstract override val typeParameters: List<FirTypeParameterRef>
abstract override val controlFlowGraphReference: FirControlFlowGraphReference?
abstract override val symbol: FirFunctionSymbol<F>
abstract override val symbol: FirFunctionSymbol<E>
abstract val valueParameters: List<FirValueParameter>
abstract val body: FirBlock?
@@ -56,15 +56,15 @@ sealed class FirFunction<F : FirFunction<F>> : FirPureAbstractElement(), FirCall
abstract fun replaceBody(newBody: FirBlock?)
abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirFunction<F>
abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirFunction<E>
abstract override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirFunction<F>
abstract override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirFunction<E>
abstract override fun <D> transformReceiverTypeRef(transformer: FirTransformer<D>, data: D): FirFunction<F>
abstract override fun <D> transformReceiverTypeRef(transformer: FirTransformer<D>, data: D): FirFunction<E>
abstract override fun <D> transformTypeParameters(transformer: FirTransformer<D>, data: D): FirFunction<F>
abstract override fun <D> transformTypeParameters(transformer: FirTransformer<D>, data: D): FirFunction<E>
abstract fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirFunction<F>
abstract fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirFunction<E>
abstract fun <D> transformBody(transformer: FirTransformer<D>, data: D): FirFunction<F>
abstract fun <D> transformBody(transformer: FirTransformer<D>, data: D): FirFunction<E>
}
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirMemberDeclaration.kt
+6 -4
View File
@@ -9,6 +9,7 @@ import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirModuleData
import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
import org.jetbrains.kotlin.fir.visitors.*
/*
@@ -16,8 +17,9 @@ import org.jetbrains.kotlin.fir.visitors.*
* DO NOT MODIFY IT MANUALLY
*/
sealed interface FirMemberDeclaration : FirAnnotatedDeclaration, FirTypeParameterRefsOwner {
sealed interface FirMemberDeclaration<E : FirMemberDeclaration<E>> : FirAnnotatedDeclaration<E>, FirTypeParameterRefsOwner {
override val source: FirSourceElement?
override val symbol: FirBasedSymbol<E>
override val moduleData: FirModuleData
override val resolvePhase: FirResolvePhase
override val origin: FirDeclarationOrigin
@@ -34,9 +36,9 @@ sealed interface FirMemberDeclaration : FirAnnotatedDeclaration, FirTypeParamete
override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirMemberDeclaration
override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirMemberDeclaration<E>
override fun <D> transformTypeParameters(transformer: FirTransformer<D>, data: D): FirMemberDeclaration
override fun <D> transformTypeParameters(transformer: FirTransformer<D>, data: D): FirMemberDeclaration<E>
fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirMemberDeclaration
fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirMemberDeclaration<E>
}
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirRegularClass.kt
+2 -2
View File
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.fir.visitors.*
* DO NOT MODIFY IT MANUALLY
*/
abstract class FirRegularClass : FirMemberDeclaration, FirTypeParameterRefsOwner, FirControlFlowGraphOwner, FirClass<FirRegularClass>() {
abstract class FirRegularClass : FirMemberDeclaration<FirRegularClass>, FirTypeParameterRefsOwner, FirControlFlowGraphOwner, FirClass<FirRegularClass>() {
abstract override val source: FirSourceElement?
abstract override val moduleData: FirModuleData
abstract override val resolvePhase: FirResolvePhase
@@ -33,7 +33,7 @@ abstract class FirRegularClass : FirMemberDeclaration, FirTypeParameterRefsOwner
abstract override val status: FirDeclarationStatus
abstract override val controlFlowGraphReference: FirControlFlowGraphReference?
abstract override val classKind: ClassKind
abstract override val declarations: List<FirDeclaration>
abstract override val declarations: List<FirDeclaration<*>>
abstract override val scopeProvider: FirScopeProvider
abstract val name: Name
abstract override val symbol: FirRegularClassSymbol
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirTypeAlias.kt
+1 -1
View File
@@ -19,7 +19,7 @@ import org.jetbrains.kotlin.fir.visitors.*
* DO NOT MODIFY IT MANUALLY
*/
abstract class FirTypeAlias : FirClassLikeDeclaration<FirTypeAlias>(), FirMemberDeclaration, FirTypeParametersOwner {
abstract class FirTypeAlias : FirClassLikeDeclaration<FirTypeAlias>(), FirMemberDeclaration<FirTypeAlias>, FirTypeParametersOwner {
abstract override val source: FirSourceElement?
abstract override val moduleData: FirModuleData
abstract override val resolvePhase: FirResolvePhase
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirTypeParameter.kt
+1 -2
View File
@@ -9,7 +9,6 @@ import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirModuleData
import org.jetbrains.kotlin.fir.FirPureAbstractElement
import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.FirSymbolOwner
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
import org.jetbrains.kotlin.fir.types.FirTypeRef
@@ -22,7 +21,7 @@ import org.jetbrains.kotlin.fir.visitors.*
* DO NOT MODIFY IT MANUALLY
*/
abstract class FirTypeParameter : FirPureAbstractElement(), FirTypeParameterRef, FirAnnotatedDeclaration, FirSymbolOwner<FirTypeParameter> {
abstract class FirTypeParameter : FirPureAbstractElement(), FirTypeParameterRef, FirAnnotatedDeclaration<FirTypeParameter> {
abstract override val source: FirSourceElement?
abstract override val moduleData: FirModuleData
abstract override val resolvePhase: FirResolvePhase
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirTypedDeclaration.kt
+5 -3
View File
@@ -9,6 +9,7 @@ import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirModuleData
import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
import org.jetbrains.kotlin.fir.types.FirTypeRef
import org.jetbrains.kotlin.fir.visitors.*
@@ -17,8 +18,9 @@ import org.jetbrains.kotlin.fir.visitors.*
* DO NOT MODIFY IT MANUALLY
*/
sealed interface FirTypedDeclaration : FirAnnotatedDeclaration {
sealed interface FirTypedDeclaration<E : FirTypedDeclaration<E>> : FirAnnotatedDeclaration<E> {
override val source: FirSourceElement?
override val symbol: FirBasedSymbol<E>
override val moduleData: FirModuleData
override val resolvePhase: FirResolvePhase
override val origin: FirDeclarationOrigin
@@ -36,7 +38,7 @@ sealed interface FirTypedDeclaration : FirAnnotatedDeclaration {
fun replaceReturnTypeRef(newReturnTypeRef: FirTypeRef)
override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirTypedDeclaration
override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirTypedDeclaration<E>
fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirTypedDeclaration
fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirTypedDeclaration<E>
}
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirVariable.kt
+11 -11
View File
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.fir.visitors.*
* DO NOT MODIFY IT MANUALLY
*/
sealed class FirVariable<F : FirVariable<F>> : FirPureAbstractElement(), FirCallableDeclaration<F>, FirAnnotatedDeclaration, FirStatement {
sealed class FirVariable<E : FirVariable<E>> : FirPureAbstractElement(), FirCallableDeclaration<E>, FirAnnotatedDeclaration<E>, FirStatement {
abstract override val source: FirSourceElement?
abstract override val moduleData: FirModuleData
abstract override val resolvePhase: FirResolvePhase
@@ -32,10 +32,10 @@ sealed class FirVariable<F : FirVariable<F>> : FirPureAbstractElement(), FirCall
abstract override val returnTypeRef: FirTypeRef
abstract override val receiverTypeRef: FirTypeRef?
abstract val name: Name
abstract override val symbol: FirVariableSymbol<F>
abstract override val symbol: FirVariableSymbol<E>
abstract val initializer: FirExpression?
abstract val delegate: FirExpression?
abstract val delegateFieldSymbol: FirDelegateFieldSymbol<F>?
abstract val delegateFieldSymbol: FirDelegateFieldSymbol<E>?
abstract val isVar: Boolean
abstract val isVal: Boolean
abstract val getter: FirPropertyAccessor?
@@ -56,19 +56,19 @@ sealed class FirVariable<F : FirVariable<F>> : FirPureAbstractElement(), FirCall
abstract fun replaceInitializer(newInitializer: FirExpression?)
abstract override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirVariable<F>
abstract override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirVariable<E>
abstract override fun <D> transformReceiverTypeRef(transformer: FirTransformer<D>, data: D): FirVariable<F>
abstract override fun <D> transformReceiverTypeRef(transformer: FirTransformer<D>, data: D): FirVariable<E>
abstract fun <D> transformInitializer(transformer: FirTransformer<D>, data: D): FirVariable<F>
abstract fun <D> transformInitializer(transformer: FirTransformer<D>, data: D): FirVariable<E>
abstract fun <D> transformDelegate(transformer: FirTransformer<D>, data: D): FirVariable<F>
abstract fun <D> transformDelegate(transformer: FirTransformer<D>, data: D): FirVariable<E>
abstract fun <D> transformGetter(transformer: FirTransformer<D>, data: D): FirVariable<F>
abstract fun <D> transformGetter(transformer: FirTransformer<D>, data: D): FirVariable<E>
abstract fun <D> transformSetter(transformer: FirTransformer<D>, data: D): FirVariable<F>
abstract fun <D> transformSetter(transformer: FirTransformer<D>, data: D): FirVariable<E>
abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirVariable<F>
abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirVariable<E>
abstract fun <D> transformOtherChildren(transformer: FirTransformer<D>, data: D): FirVariable<F>
abstract fun <D> transformOtherChildren(transformer: FirTransformer<D>, data: D): FirVariable<E>
}
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirAnonymousObjectBuilder.kt
+1 -1
View File
@@ -42,7 +42,7 @@ class FirAnonymousObjectBuilder : FirDeclarationBuilder, FirClassBuilder, FirAnn
override val typeParameters: MutableList<FirTypeParameterRef> = mutableListOf()
override lateinit var classKind: ClassKind
override val superTypeRefs: MutableList<FirTypeRef> = mutableListOf()
override val declarations: MutableList<FirDeclaration> = mutableListOf()
override val declarations: MutableList<FirDeclaration<*>> = mutableListOf()
override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
override lateinit var scopeProvider: FirScopeProvider
lateinit var symbol: FirAnonymousObjectSymbol
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirClassBuilder.kt
+1 -1
View File
@@ -38,7 +38,7 @@ interface FirClassBuilder : FirDeclarationBuilder, FirAnnotationContainerBuilder
abstract val typeParameters: MutableList<FirTypeParameterRef>
abstract var classKind: ClassKind
abstract val superTypeRefs: MutableList<FirTypeRef>
abstract val declarations: MutableList<FirDeclaration>
abstract val declarations: MutableList<FirDeclaration<*>>
abstract var scopeProvider: FirScopeProvider
override fun build(): FirClass<*>
}
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirDeclarationBuilder.kt
+1 -1
View File
@@ -26,5 +26,5 @@ interface FirDeclarationBuilder {
abstract var resolvePhase: FirResolvePhase
abstract var origin: FirDeclarationOrigin
abstract var attributes: FirDeclarationAttributes
fun build(): FirDeclaration
fun build(): FirDeclaration<*>
}
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirFileBuilder.kt
+2 -1
View File
@@ -18,6 +18,7 @@ import org.jetbrains.kotlin.fir.declarations.FirImport
import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
import org.jetbrains.kotlin.fir.declarations.impl.FirFileImpl
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
import org.jetbrains.kotlin.fir.symbols.impl.FirFileSymbol
import org.jetbrains.kotlin.fir.visitors.*
import org.jetbrains.kotlin.name.FqName
@@ -35,7 +36,7 @@ class FirFileBuilder : FirAnnotationContainerBuilder {
var attributes: FirDeclarationAttributes = FirDeclarationAttributes()
override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
val imports: MutableList<FirImport> = mutableListOf()
val declarations: MutableList<FirDeclaration> = mutableListOf()
val declarations: MutableList<FirDeclaration<*>> = mutableListOf()
lateinit var name: String
lateinit var packageFqName: FqName
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirRegularClassBuilder.kt
+1 -1
View File
@@ -45,7 +45,7 @@ open class FirRegularClassBuilder : FirClassBuilder, FirTypeParameterRefsOwnerBu
override val typeParameters: MutableList<FirTypeParameterRef> = mutableListOf()
open lateinit var status: FirDeclarationStatus
override lateinit var classKind: ClassKind
override val declarations: MutableList<FirDeclaration> = mutableListOf()
override val declarations: MutableList<FirDeclaration<*>> = mutableListOf()
override lateinit var scopeProvider: FirScopeProvider
open lateinit var name: Name
open lateinit var symbol: FirRegularClassSymbol
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousObjectImpl.kt
+1 -1
View File
@@ -35,7 +35,7 @@ internal class FirAnonymousObjectImpl(
override val typeParameters: MutableList<FirTypeParameterRef>,
override val classKind: ClassKind,
override val superTypeRefs: MutableList<FirTypeRef>,
override val declarations: MutableList<FirDeclaration>,
override val declarations: MutableList<FirDeclaration<*>>,
override val annotations: MutableList<FirAnnotationCall>,
override val scopeProvider: FirScopeProvider,
override val symbol: FirAnonymousObjectSymbol,
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirFileImpl.kt
+8 -1
View File
@@ -14,6 +14,7 @@ import org.jetbrains.kotlin.fir.declarations.FirFile
import org.jetbrains.kotlin.fir.declarations.FirImport
import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
import org.jetbrains.kotlin.fir.symbols.impl.FirFileSymbol
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.fir.visitors.*
@@ -30,10 +31,16 @@ internal class FirFileImpl(
override val attributes: FirDeclarationAttributes,
override val annotations: MutableList<FirAnnotationCall>,
override val imports: MutableList<FirImport>,
override val declarations: MutableList<FirDeclaration>,
override val declarations: MutableList<FirDeclaration<*>>,
override val name: String,
override val packageFqName: FqName,
) : FirFile() {
override val symbol: FirFileSymbol = FirFileSymbol()
init {
symbol.bind(this)
}
override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
annotations.forEach { it.accept(visitor, data) }
imports.forEach { it.accept(visitor, data) }
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirRegularClassImpl.kt
+1 -1
View File
@@ -38,7 +38,7 @@ internal class FirRegularClassImpl(
override val typeParameters: MutableList<FirTypeParameterRef>,
override var status: FirDeclarationStatus,
override val classKind: ClassKind,
override val declarations: MutableList<FirDeclaration>,
override val declarations: MutableList<FirDeclaration<*>>,
override val scopeProvider: FirScopeProvider,
override val name: Name,
override val symbol: FirRegularClassSymbol,
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt
+40 -49
View File
@@ -10,7 +10,6 @@ import org.jetbrains.kotlin.fir.FirAnnotationContainer
import org.jetbrains.kotlin.fir.types.FirTypeRef
import org.jetbrains.kotlin.fir.references.FirReference
import org.jetbrains.kotlin.fir.FirLabel
import org.jetbrains.kotlin.fir.FirSymbolOwner
import org.jetbrains.kotlin.fir.expressions.FirResolvable
import org.jetbrains.kotlin.fir.FirTargetElement
import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus
@@ -160,10 +159,6 @@ abstract class FirTransformer<in D> : FirVisitor<FirElement, D>() {
return transformElement(label, data)
}
open fun <E> transformSymbolOwner(symbolOwner: FirSymbolOwner<E>, data: D): FirSymbolOwner<E> where E : FirSymbolOwner<E>, E : FirDeclaration {
return transformElement(symbolOwner, data)
}
open fun transformResolvable(resolvable: FirResolvable, data: D): FirResolvable {
return transformElement(resolvable, data)
}
@@ -192,23 +187,23 @@ abstract class FirTransformer<in D> : FirVisitor<FirElement, D>() {
return transformElement(expression, data)
}
open fun transformDeclaration(declaration: FirDeclaration, data: D): FirDeclaration {
open fun <E : FirDeclaration<E>> transformDeclaration(declaration: FirDeclaration<E>, data: D): FirDeclaration<E> {
return transformElement(declaration, data)
}
open fun transformAnnotatedDeclaration(annotatedDeclaration: FirAnnotatedDeclaration, data: D): FirDeclaration {
open fun <E : FirAnnotatedDeclaration<E>> transformAnnotatedDeclaration(annotatedDeclaration: FirAnnotatedDeclaration<E>, data: D): FirAnnotatedDeclaration<E> {
return transformElement(annotatedDeclaration, data)
}
open fun transformAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, data: D): FirDeclaration {
open fun transformAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, data: D): FirAnonymousInitializer {
return transformElement(anonymousInitializer, data)
}
open fun transformTypedDeclaration(typedDeclaration: FirTypedDeclaration, data: D): FirDeclaration {
open fun <E : FirTypedDeclaration<E>> transformTypedDeclaration(typedDeclaration: FirTypedDeclaration<E>, data: D): FirTypedDeclaration<E> {
return transformElement(typedDeclaration, data)
}
open fun <F : FirCallableDeclaration<F>> transformCallableDeclaration(callableDeclaration: FirCallableDeclaration<F>, data: D): FirDeclaration {
open fun <E : FirCallableDeclaration<E>> transformCallableDeclaration(callableDeclaration: FirCallableDeclaration<E>, data: D): FirCallableDeclaration<E> {
return transformElement(callableDeclaration, data)
}
@@ -216,7 +211,7 @@ abstract class FirTransformer<in D> : FirVisitor<FirElement, D>() {
return transformElement(typeParameterRef, data)
}
open fun transformTypeParameter(typeParameter: FirTypeParameter, data: D): FirDeclaration {
open fun transformTypeParameter(typeParameter: FirTypeParameter, data: D): FirTypeParameterRef {
return transformElement(typeParameter, data)
}
@@ -228,15 +223,15 @@ abstract class FirTransformer<in D> : FirVisitor<FirElement, D>() {
return transformElement(typeParametersOwner, data)
}
open fun transformMemberDeclaration(memberDeclaration: FirMemberDeclaration, data: D): FirDeclaration {
open fun <E : FirMemberDeclaration<E>> transformMemberDeclaration(memberDeclaration: FirMemberDeclaration<E>, data: D): FirMemberDeclaration<E> {
return transformElement(memberDeclaration, data)
}
open fun <F : FirCallableMemberDeclaration<F>> transformCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration<F>, data: D): FirDeclaration {
open fun <E : FirCallableMemberDeclaration<E>> transformCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration<E>, data: D): FirCallableMemberDeclaration<E> {
return transformElement(callableMemberDeclaration, data)
}
open fun <F : FirVariable<F>> transformVariable(variable: FirVariable<F>, data: D): FirStatement {
open fun <E : FirVariable<E>> transformVariable(variable: FirVariable<E>, data: D): FirStatement {
return transformElement(variable, data)
}
@@ -244,23 +239,23 @@ abstract class FirTransformer<in D> : FirVisitor<FirElement, D>() {
return transformElement(valueParameter, data)
}
open fun transformProperty(property: FirProperty, data: D): FirDeclaration {
open fun transformProperty(property: FirProperty, data: D): FirStatement {
return transformElement(property, data)
}
open fun transformField(field: FirField, data: D): FirDeclaration {
open fun transformField(field: FirField, data: D): FirStatement {
return transformElement(field, data)
}
open fun transformEnumEntry(enumEntry: FirEnumEntry, data: D): FirDeclaration {
open fun transformEnumEntry(enumEntry: FirEnumEntry, data: D): FirStatement {
return transformElement(enumEntry, data)
}
open fun <F : FirClassLikeDeclaration<F>> transformClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration<F>, data: D): FirStatement {
open fun <E : FirClassLikeDeclaration<E>> transformClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration<E>, data: D): FirStatement {
return transformElement(classLikeDeclaration, data)
}
open fun <F : FirClass<F>> transformClass(klass: FirClass<F>, data: D): FirStatement {
open fun <E : FirClass<E>> transformClass(klass: FirClass<E>, data: D): FirStatement {
return transformElement(klass, data)
}
@@ -268,11 +263,11 @@ abstract class FirTransformer<in D> : FirVisitor<FirElement, D>() {
return transformElement(regularClass, data)
}
open fun transformTypeAlias(typeAlias: FirTypeAlias, data: D): FirDeclaration {
open fun transformTypeAlias(typeAlias: FirTypeAlias, data: D): FirStatement {
return transformElement(typeAlias, data)
}
open fun <F : FirFunction<F>> transformFunction(function: FirFunction<F>, data: D): FirStatement {
open fun <E : FirFunction<E>> transformFunction(function: FirFunction<E>, data: D): FirStatement {
return transformElement(function, data)
}
@@ -280,19 +275,19 @@ abstract class FirTransformer<in D> : FirVisitor<FirElement, D>() {
return transformElement(contractDescriptionOwner, data)
}
open fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: D): FirDeclaration {
open fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: D): FirStatement {
return transformElement(simpleFunction, data)
}
open fun transformPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: D): FirDeclaration {
open fun transformPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: D): FirStatement {
return transformElement(propertyAccessor, data)
}
open fun transformConstructor(constructor: FirConstructor, data: D): FirDeclaration {
open fun transformConstructor(constructor: FirConstructor, data: D): FirStatement {
return transformElement(constructor, data)
}
open fun transformFile(file: FirFile, data: D): FirDeclaration {
open fun transformFile(file: FirFile, data: D): FirFile {
return transformElement(file, data)
}
@@ -676,10 +671,6 @@ abstract class FirTransformer<in D> : FirVisitor<FirElement, D>() {
return transformLabel(label, data)
}
final override fun <E> visitSymbolOwner(symbolOwner: FirSymbolOwner<E>, data: D): FirSymbolOwner<E> where E : FirSymbolOwner<E>, E : FirDeclaration {
return transformSymbolOwner(symbolOwner, data)
}
final override fun visitResolvable(resolvable: FirResolvable, data: D): FirResolvable {
return transformResolvable(resolvable, data)
}
@@ -708,23 +699,23 @@ abstract class FirTransformer<in D> : FirVisitor<FirElement, D>() {
return transformExpression(expression, data)
}
final override fun visitDeclaration(declaration: FirDeclaration, data: D): FirDeclaration {
final override fun <E : FirDeclaration<E>> visitDeclaration(declaration: FirDeclaration<E>, data: D): FirDeclaration<E> {
return transformDeclaration(declaration, data)
}
final override fun visitAnnotatedDeclaration(annotatedDeclaration: FirAnnotatedDeclaration, data: D): FirDeclaration {
final override fun <E : FirAnnotatedDeclaration<E>> visitAnnotatedDeclaration(annotatedDeclaration: FirAnnotatedDeclaration<E>, data: D): FirAnnotatedDeclaration<E> {
return transformAnnotatedDeclaration(annotatedDeclaration, data)
}
final override fun visitAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, data: D): FirDeclaration {
final override fun visitAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, data: D): FirAnonymousInitializer {
return transformAnonymousInitializer(anonymousInitializer, data)
}
final override fun visitTypedDeclaration(typedDeclaration: FirTypedDeclaration, data: D): FirDeclaration {
final override fun <E : FirTypedDeclaration<E>> visitTypedDeclaration(typedDeclaration: FirTypedDeclaration<E>, data: D): FirTypedDeclaration<E> {
return transformTypedDeclaration(typedDeclaration, data)
}
final override fun <F : FirCallableDeclaration<F>> visitCallableDeclaration(callableDeclaration: FirCallableDeclaration<F>, data: D): FirDeclaration {
final override fun <E : FirCallableDeclaration<E>> visitCallableDeclaration(callableDeclaration: FirCallableDeclaration<E>, data: D): FirCallableDeclaration<E> {
return transformCallableDeclaration(callableDeclaration, data)
}
@@ -732,7 +723,7 @@ abstract class FirTransformer<in D> : FirVisitor<FirElement, D>() {
return transformTypeParameterRef(typeParameterRef, data)
}
final override fun visitTypeParameter(typeParameter: FirTypeParameter, data: D): FirDeclaration {
final override fun visitTypeParameter(typeParameter: FirTypeParameter, data: D): FirTypeParameterRef {
return transformTypeParameter(typeParameter, data)
}
@@ -744,15 +735,15 @@ abstract class FirTransformer<in D> : FirVisitor<FirElement, D>() {
return transformTypeParametersOwner(typeParametersOwner, data)
}
final override fun visitMemberDeclaration(memberDeclaration: FirMemberDeclaration, data: D): FirDeclaration {
final override fun <E : FirMemberDeclaration<E>> visitMemberDeclaration(memberDeclaration: FirMemberDeclaration<E>, data: D): FirMemberDeclaration<E> {
return transformMemberDeclaration(memberDeclaration, data)
}
final override fun <F : FirCallableMemberDeclaration<F>> visitCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration<F>, data: D): FirDeclaration {
final override fun <E : FirCallableMemberDeclaration<E>> visitCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration<E>, data: D): FirCallableMemberDeclaration<E> {
return transformCallableMemberDeclaration(callableMemberDeclaration, data)
}
final override fun <F : FirVariable<F>> visitVariable(variable: FirVariable<F>, data: D): FirStatement {
final override fun <E : FirVariable<E>> visitVariable(variable: FirVariable<E>, data: D): FirStatement {
return transformVariable(variable, data)
}
@@ -760,23 +751,23 @@ abstract class FirTransformer<in D> : FirVisitor<FirElement, D>() {
return transformValueParameter(valueParameter, data)
}
final override fun visitProperty(property: FirProperty, data: D): FirDeclaration {
final override fun visitProperty(property: FirProperty, data: D): FirStatement {
return transformProperty(property, data)
}
final override fun visitField(field: FirField, data: D): FirDeclaration {
final override fun visitField(field: FirField, data: D): FirStatement {
return transformField(field, data)
}
final override fun visitEnumEntry(enumEntry: FirEnumEntry, data: D): FirDeclaration {
final override fun visitEnumEntry(enumEntry: FirEnumEntry, data: D): FirStatement {
return transformEnumEntry(enumEntry, data)
}
final override fun <F : FirClassLikeDeclaration<F>> visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration<F>, data: D): FirStatement {
final override fun <E : FirClassLikeDeclaration<E>> visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration<E>, data: D): FirStatement {
return transformClassLikeDeclaration(classLikeDeclaration, data)
}
final override fun <F : FirClass<F>> visitClass(klass: FirClass<F>, data: D): FirStatement {
final override fun <E : FirClass<E>> visitClass(klass: FirClass<E>, data: D): FirStatement {
return transformClass(klass, data)
}
@@ -784,11 +775,11 @@ abstract class FirTransformer<in D> : FirVisitor<FirElement, D>() {
return transformRegularClass(regularClass, data)
}
final override fun visitTypeAlias(typeAlias: FirTypeAlias, data: D): FirDeclaration {
final override fun visitTypeAlias(typeAlias: FirTypeAlias, data: D): FirStatement {
return transformTypeAlias(typeAlias, data)
}
final override fun <F : FirFunction<F>> visitFunction(function: FirFunction<F>, data: D): FirStatement {
final override fun <E : FirFunction<E>> visitFunction(function: FirFunction<E>, data: D): FirStatement {
return transformFunction(function, data)
}
@@ -796,19 +787,19 @@ abstract class FirTransformer<in D> : FirVisitor<FirElement, D>() {
return transformContractDescriptionOwner(contractDescriptionOwner, data)
}
final override fun visitSimpleFunction(simpleFunction: FirSimpleFunction, data: D): FirDeclaration {
final override fun visitSimpleFunction(simpleFunction: FirSimpleFunction, data: D): FirStatement {
return transformSimpleFunction(simpleFunction, data)
}
final override fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: D): FirDeclaration {
final override fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: D): FirStatement {
return transformPropertyAccessor(propertyAccessor, data)
}
final override fun visitConstructor(constructor: FirConstructor, data: D): FirDeclaration {
final override fun visitConstructor(constructor: FirConstructor, data: D): FirStatement {
return transformConstructor(constructor, data)
}
final override fun visitFile(file: FirFile, data: D): FirDeclaration {
final override fun visitFile(file: FirFile, data: D): FirFile {
return transformFile(file, data)
}
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt
+10 -13
View File
@@ -10,7 +10,6 @@ import org.jetbrains.kotlin.fir.FirAnnotationContainer
import org.jetbrains.kotlin.fir.types.FirTypeRef
import org.jetbrains.kotlin.fir.references.FirReference
import org.jetbrains.kotlin.fir.FirLabel
import org.jetbrains.kotlin.fir.FirSymbolOwner
import org.jetbrains.kotlin.fir.expressions.FirResolvable
import org.jetbrains.kotlin.fir.FirTargetElement
import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus
@@ -151,8 +150,6 @@ abstract class FirVisitor<out R, in D> {
open fun visitLabel(label: FirLabel, data: D): R = visitElement(label, data)
open fun <E> visitSymbolOwner(symbolOwner: FirSymbolOwner<E>, data: D): R where E : FirSymbolOwner<E>, E : FirDeclaration = visitElement(symbolOwner, data)
open fun visitResolvable(resolvable: FirResolvable, data: D): R = visitElement(resolvable, data)
open fun visitTargetElement(targetElement: FirTargetElement, data: D): R = visitElement(targetElement, data)
@@ -167,15 +164,15 @@ abstract class FirVisitor<out R, in D> {
open fun visitExpression(expression: FirExpression, data: D): R = visitElement(expression, data)
open fun visitDeclaration(declaration: FirDeclaration, data: D): R = visitElement(declaration, data)
open fun <E : FirDeclaration<E>> visitDeclaration(declaration: FirDeclaration<E>, data: D): R = visitElement(declaration, data)
open fun visitAnnotatedDeclaration(annotatedDeclaration: FirAnnotatedDeclaration, data: D): R = visitElement(annotatedDeclaration, data)
open fun <E : FirAnnotatedDeclaration<E>> visitAnnotatedDeclaration(annotatedDeclaration: FirAnnotatedDeclaration<E>, data: D): R = visitElement(annotatedDeclaration, data)
open fun visitAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, data: D): R = visitElement(anonymousInitializer, data)
open fun visitTypedDeclaration(typedDeclaration: FirTypedDeclaration, data: D): R = visitElement(typedDeclaration, data)
open fun <E : FirTypedDeclaration<E>> visitTypedDeclaration(typedDeclaration: FirTypedDeclaration<E>, data: D): R = visitElement(typedDeclaration, data)
open fun <F : FirCallableDeclaration<F>> visitCallableDeclaration(callableDeclaration: FirCallableDeclaration<F>, data: D): R = visitElement(callableDeclaration, data)
open fun <E : FirCallableDeclaration<E>> visitCallableDeclaration(callableDeclaration: FirCallableDeclaration<E>, data: D): R = visitElement(callableDeclaration, data)
open fun visitTypeParameterRef(typeParameterRef: FirTypeParameterRef, data: D): R = visitElement(typeParameterRef, data)
@@ -185,11 +182,11 @@ abstract class FirVisitor<out R, in D> {
open fun visitTypeParametersOwner(typeParametersOwner: FirTypeParametersOwner, data: D): R = visitElement(typeParametersOwner, data)
open fun visitMemberDeclaration(memberDeclaration: FirMemberDeclaration, data: D): R = visitElement(memberDeclaration, data)
open fun <E : FirMemberDeclaration<E>> visitMemberDeclaration(memberDeclaration: FirMemberDeclaration<E>, data: D): R = visitElement(memberDeclaration, data)
open fun <F : FirCallableMemberDeclaration<F>> visitCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration<F>, data: D): R = visitElement(callableMemberDeclaration, data)
open fun <E : FirCallableMemberDeclaration<E>> visitCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration<E>, data: D): R = visitElement(callableMemberDeclaration, data)
open fun <F : FirVariable<F>> visitVariable(variable: FirVariable<F>, data: D): R = visitElement(variable, data)
open fun <E : FirVariable<E>> visitVariable(variable: FirVariable<E>, data: D): R = visitElement(variable, data)
open fun visitValueParameter(valueParameter: FirValueParameter, data: D): R = visitElement(valueParameter, data)
@@ -199,15 +196,15 @@ abstract class FirVisitor<out R, in D> {
open fun visitEnumEntry(enumEntry: FirEnumEntry, data: D): R = visitElement(enumEntry, data)
open fun <F : FirClassLikeDeclaration<F>> visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration<F>, data: D): R = visitElement(classLikeDeclaration, data)
open fun <E : FirClassLikeDeclaration<E>> visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration<E>, data: D): R = visitElement(classLikeDeclaration, data)
open fun <F : FirClass<F>> visitClass(klass: FirClass<F>, data: D): R = visitElement(klass, data)
open fun <E : FirClass<E>> visitClass(klass: FirClass<E>, data: D): R = visitElement(klass, data)
open fun visitRegularClass(regularClass: FirRegularClass, data: D): R = visitElement(regularClass, data)
open fun visitTypeAlias(typeAlias: FirTypeAlias, data: D): R = visitElement(typeAlias, data)
open fun <F : FirFunction<F>> visitFunction(function: FirFunction<F>, data: D): R = visitElement(function, data)
open fun <E : FirFunction<E>> visitFunction(function: FirFunction<E>, data: D): R = visitElement(function, data)
open fun visitContractDescriptionOwner(contractDescriptionOwner: FirContractDescriptionOwner, data: D): R = visitElement(contractDescriptionOwner, data)
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitorVoid.kt
+20 -29
View File
@@ -10,7 +10,6 @@ import org.jetbrains.kotlin.fir.FirAnnotationContainer
import org.jetbrains.kotlin.fir.types.FirTypeRef
import org.jetbrains.kotlin.fir.references.FirReference
import org.jetbrains.kotlin.fir.FirLabel
import org.jetbrains.kotlin.fir.FirSymbolOwner
import org.jetbrains.kotlin.fir.expressions.FirResolvable
import org.jetbrains.kotlin.fir.FirTargetElement
import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus
@@ -159,10 +158,6 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
visitElement(label)
}
open fun <E> visitSymbolOwner(symbolOwner: FirSymbolOwner<E>) where E : FirSymbolOwner<E>, E : FirDeclaration {
visitElement(symbolOwner)
}
open fun visitResolvable(resolvable: FirResolvable) {
visitElement(resolvable)
}
@@ -191,11 +186,11 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
visitElement(expression)
}
open fun visitDeclaration(declaration: FirDeclaration) {
open fun <E : FirDeclaration<E>> visitDeclaration(declaration: FirDeclaration<E>) {
visitElement(declaration)
}
open fun visitAnnotatedDeclaration(annotatedDeclaration: FirAnnotatedDeclaration) {
open fun <E : FirAnnotatedDeclaration<E>> visitAnnotatedDeclaration(annotatedDeclaration: FirAnnotatedDeclaration<E>) {
visitElement(annotatedDeclaration)
}
@@ -203,11 +198,11 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
visitElement(anonymousInitializer)
}
open fun visitTypedDeclaration(typedDeclaration: FirTypedDeclaration) {
open fun <E : FirTypedDeclaration<E>> visitTypedDeclaration(typedDeclaration: FirTypedDeclaration<E>) {
visitElement(typedDeclaration)
}
open fun <F : FirCallableDeclaration<F>> visitCallableDeclaration(callableDeclaration: FirCallableDeclaration<F>) {
open fun <E : FirCallableDeclaration<E>> visitCallableDeclaration(callableDeclaration: FirCallableDeclaration<E>) {
visitElement(callableDeclaration)
}
@@ -227,15 +222,15 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
visitElement(typeParametersOwner)
}
open fun visitMemberDeclaration(memberDeclaration: FirMemberDeclaration) {
open fun <E : FirMemberDeclaration<E>> visitMemberDeclaration(memberDeclaration: FirMemberDeclaration<E>) {
visitElement(memberDeclaration)
}
open fun <F : FirCallableMemberDeclaration<F>> visitCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration<F>) {
open fun <E : FirCallableMemberDeclaration<E>> visitCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration<E>) {
visitElement(callableMemberDeclaration)
}
open fun <F : FirVariable<F>> visitVariable(variable: FirVariable<F>) {
open fun <E : FirVariable<E>> visitVariable(variable: FirVariable<E>) {
visitElement(variable)
}
@@ -255,11 +250,11 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
visitElement(enumEntry)
}
open fun <F : FirClassLikeDeclaration<F>> visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration<F>) {
open fun <E : FirClassLikeDeclaration<E>> visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration<E>) {
visitElement(classLikeDeclaration)
}
open fun <F : FirClass<F>> visitClass(klass: FirClass<F>) {
open fun <E : FirClass<E>> visitClass(klass: FirClass<E>) {
visitElement(klass)
}
@@ -271,7 +266,7 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
visitElement(typeAlias)
}
open fun <F : FirFunction<F>> visitFunction(function: FirFunction<F>) {
open fun <E : FirFunction<E>> visitFunction(function: FirFunction<E>) {
visitElement(function)
}
@@ -675,10 +670,6 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
visitLabel(label)
}
final override fun <E> visitSymbolOwner(symbolOwner: FirSymbolOwner<E>, data: Nothing?) where E : FirSymbolOwner<E>, E : FirDeclaration {
visitSymbolOwner(symbolOwner)
}
final override fun visitResolvable(resolvable: FirResolvable, data: Nothing?) {
visitResolvable(resolvable)
}
@@ -707,11 +698,11 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
visitExpression(expression)
}
final override fun visitDeclaration(declaration: FirDeclaration, data: Nothing?) {
final override fun <E : FirDeclaration<E>> visitDeclaration(declaration: FirDeclaration<E>, data: Nothing?) {
visitDeclaration(declaration)
}
final override fun visitAnnotatedDeclaration(annotatedDeclaration: FirAnnotatedDeclaration, data: Nothing?) {
final override fun <E : FirAnnotatedDeclaration<E>> visitAnnotatedDeclaration(annotatedDeclaration: FirAnnotatedDeclaration<E>, data: Nothing?) {
visitAnnotatedDeclaration(annotatedDeclaration)
}
@@ -719,11 +710,11 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
visitAnonymousInitializer(anonymousInitializer)
}
final override fun visitTypedDeclaration(typedDeclaration: FirTypedDeclaration, data: Nothing?) {
final override fun <E : FirTypedDeclaration<E>> visitTypedDeclaration(typedDeclaration: FirTypedDeclaration<E>, data: Nothing?) {
visitTypedDeclaration(typedDeclaration)
}
final override fun <F : FirCallableDeclaration<F>> visitCallableDeclaration(callableDeclaration: FirCallableDeclaration<F>, data: Nothing?) {
final override fun <E : FirCallableDeclaration<E>> visitCallableDeclaration(callableDeclaration: FirCallableDeclaration<E>, data: Nothing?) {
visitCallableDeclaration(callableDeclaration)
}
@@ -743,15 +734,15 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
visitTypeParametersOwner(typeParametersOwner)
}
final override fun visitMemberDeclaration(memberDeclaration: FirMemberDeclaration, data: Nothing?) {
final override fun <E : FirMemberDeclaration<E>> visitMemberDeclaration(memberDeclaration: FirMemberDeclaration<E>, data: Nothing?) {
visitMemberDeclaration(memberDeclaration)
}
final override fun <F : FirCallableMemberDeclaration<F>> visitCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration<F>, data: Nothing?) {
final override fun <E : FirCallableMemberDeclaration<E>> visitCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration<E>, data: Nothing?) {
visitCallableMemberDeclaration(callableMemberDeclaration)
}
final override fun <F : FirVariable<F>> visitVariable(variable: FirVariable<F>, data: Nothing?) {
final override fun <E : FirVariable<E>> visitVariable(variable: FirVariable<E>, data: Nothing?) {
visitVariable(variable)
}
@@ -771,11 +762,11 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
visitEnumEntry(enumEntry)
}
final override fun <F : FirClassLikeDeclaration<F>> visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration<F>, data: Nothing?) {
final override fun <E : FirClassLikeDeclaration<E>> visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration<E>, data: Nothing?) {
visitClassLikeDeclaration(classLikeDeclaration)
}
final override fun <F : FirClass<F>> visitClass(klass: FirClass<F>, data: Nothing?) {
final override fun <E : FirClass<E>> visitClass(klass: FirClass<E>, data: Nothing?) {
visitClass(klass)
}
@@ -787,7 +778,7 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
visitTypeAlias(typeAlias)
}
final override fun <F : FirFunction<F>> visitFunction(function: FirFunction<F>, data: Nothing?) {
final override fun <E : FirFunction<E>> visitFunction(function: FirFunction<E>, data: Nothing?) {
visitFunction(function)
}
compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt
+14 -14
View File
@@ -17,9 +17,8 @@ import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.expressions.*
import org.jetbrains.kotlin.fir.expressions.impl.*
import org.jetbrains.kotlin.fir.references.*
import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
import org.jetbrains.kotlin.name.StandardClassIds
import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
@@ -27,6 +26,7 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
import org.jetbrains.kotlin.fir.types.*
import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid
import org.jetbrains.kotlin.name.SpecialNames
import org.jetbrains.kotlin.name.StandardClassIds
import org.jetbrains.kotlin.types.Variance
import org.jetbrains.kotlin.util.capitalizeDecapitalize.toLowerCaseAsciiOnly
import org.jetbrains.kotlin.utils.Printer
@@ -211,7 +211,7 @@ class FirRenderer(builder: StringBuilder, private val mode: RenderMode = RenderM
}
override fun <F : FirCallableDeclaration<F>> visitCallableDeclaration(callableDeclaration: FirCallableDeclaration<F>) {
if (callableDeclaration is FirMemberDeclaration) {
if (callableDeclaration is FirMemberDeclaration<*>) {
visitMemberDeclaration(callableDeclaration)
} else {
callableDeclaration.annotations.renderAnnotations()
@@ -248,7 +248,7 @@ class FirRenderer(builder: StringBuilder, private val mode: RenderMode = RenderM
callableDeclaration.renderContractDescription()
}
private fun FirDeclaration.renderContractDescription() {
private fun FirDeclaration<*>.renderContractDescription() {
val contractDescription = (this as? FirContractDescriptionOwner)?.contractDescription ?: return
pushIndent()
contractDescription.accept(this@FirRenderer)
@@ -268,7 +268,7 @@ class FirRenderer(builder: StringBuilder, private val mode: RenderMode = RenderM
return itself + "[${effectiveVisibility.name}]"
}
private fun FirMemberDeclaration.modalityAsString(): String {
private fun FirMemberDeclaration<*>.modalityAsString(): String {
return modality?.name?.toLowerCaseAsciiOnly() ?: run {
if (this is FirCallableMemberDeclaration<*> && this.isOverride) {
"open?"
@@ -298,7 +298,7 @@ class FirRenderer(builder: StringBuilder, private val mode: RenderMode = RenderM
typeParameterRef.symbol.fir.accept(this)
}
override fun visitMemberDeclaration(memberDeclaration: FirMemberDeclaration) {
override fun <E : FirMemberDeclaration<E>> visitMemberDeclaration(memberDeclaration: FirMemberDeclaration<E>) {
memberDeclaration.annotations.renderAnnotations()
if (memberDeclaration !is FirProperty || !memberDeclaration.isLocal) {
// we can't access session.effectiveVisibilityResolver from here!
@@ -384,7 +384,7 @@ class FirRenderer(builder: StringBuilder, private val mode: RenderMode = RenderM
}
}
override fun visitDeclaration(declaration: FirDeclaration) {
override fun <E : FirDeclaration<E>> visitDeclaration(declaration: FirDeclaration<E>) {
declaration.renderDeclarationData()
print(
when (declaration) {
@@ -402,19 +402,19 @@ class FirRenderer(builder: StringBuilder, private val mode: RenderMode = RenderM
)
}
private fun FirDeclaration.renderDeclarationData() {
private fun FirDeclaration<*>.renderDeclarationData() {
renderDeclarationResolvePhaseIfNeeded()
renderDeclarationAttributesIfNeeded()
renderDeclarationOriginIfNeeded()
}
private fun FirDeclaration.renderDeclarationResolvePhaseIfNeeded() {
private fun FirDeclaration<*>.renderDeclarationResolvePhaseIfNeeded() {
if (mode.renderDeclarationResolvePhase) {
print("[${resolvePhase}] ")
}
}
private fun FirDeclaration.renderDeclarationAttributesIfNeeded() {
private fun FirDeclaration<*>.renderDeclarationAttributesIfNeeded() {
if (mode.renderDeclarationAttributes && attributes.isNotEmpty()) {
val attributes = getAttributesWithValues().mapNotNull { (klass, value) ->
value?.let { klass.simpleName to value.renderAsDeclarationAttributeValue() }
@@ -423,13 +423,13 @@ class FirRenderer(builder: StringBuilder, private val mode: RenderMode = RenderM
}
}
private fun FirDeclaration.renderDeclarationOriginIfNeeded() {
private fun FirDeclaration<*>.renderDeclarationOriginIfNeeded() {
if (mode.renderDeclarationOrigin) {
print("[$origin] ")
}
}
private fun FirDeclaration.getAttributesWithValues(): List<Pair<KClass<out FirDeclarationDataKey>, Any?>> {
private fun FirDeclaration<*>.getAttributesWithValues(): List<Pair<KClass<out FirDeclarationDataKey>, Any?>> {
val attributesMap = FirDeclarationDataRegistry.allValuesThreadUnsafeForRendering()
return attributesMap.entries.sortedBy { it.key.simpleName }.map { (klass, index) -> klass to attributes[index] }
}
@@ -441,7 +441,7 @@ class FirRenderer(builder: StringBuilder, private val mode: RenderMode = RenderM
}
private fun List<FirDeclaration>.renderDeclarations() {
private fun List<FirDeclaration<*>>.renderDeclarations() {
renderInBraces {
for (declaration in this) {
declaration.accept(this@FirRenderer)
@@ -681,7 +681,7 @@ class FirRenderer(builder: StringBuilder, private val mode: RenderMode = RenderM
print("\$subj\$")
}
override fun visitTypedDeclaration(typedDeclaration: FirTypedDeclaration) {
override fun <E : FirTypedDeclaration<E>> visitTypedDeclaration(typedDeclaration: FirTypedDeclaration<E>) {
visitDeclaration(typedDeclaration)
}
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirDeclarationAttributes.kt
+3 -3
View File
@@ -37,7 +37,7 @@ class FirDeclarationAttributes : AttributeArrayOwner<FirDeclarationDataKey, Any>
* Example of adding new attribute for declaration:
*
* object SomeKey : FirDeclarationDataKey()
* var FirDeclaration.someString: String? by FirDeclarationDataRegistry.data(SomeKey)
* var FirDeclaration<*>.someString: String? by FirDeclarationDataRegistry.data(SomeKey)
*/
object FirDeclarationDataRegistry : TypeRegistry<FirDeclarationDataKey, Any>() {
fun <K : FirDeclarationDataKey> data(key: K): DeclarationDataAccessor {
@@ -54,12 +54,12 @@ object FirDeclarationDataRegistry : TypeRegistry<FirDeclarationDataKey, Any>() {
private val dataAccessor: NullableArrayMapAccessor<FirDeclarationDataKey, Any, *>,
val key: KClass<out FirDeclarationDataKey>
) {
operator fun <V> getValue(thisRef: FirDeclaration, property: KProperty<*>): V? {
operator fun <V> getValue(thisRef: FirDeclaration<*>, property: KProperty<*>): V? {
@Suppress("UNCHECKED_CAST")
return dataAccessor.getValue(thisRef.attributes, property) as? V
}
operator fun <V> setValue(thisRef: FirDeclaration, property: KProperty<*>, value: V?) {
operator fun <V> setValue(thisRef: FirDeclaration<*>, property: KProperty<*>, value: V?) {
thisRef.attributes[key] = value
}
}
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirDeclarationUtil.kt
+31 -30
View File
@@ -53,39 +53,40 @@ inline val FirRegularClass.isData get() = status.isData
inline val FirRegularClass.canHaveAbstractDeclaration: Boolean
get() = isAbstract || isSealed || isEnumClass
inline val FirMemberDeclaration.modality get() = status.modality
inline val FirMemberDeclaration.isAbstract get() = status.modality == Modality.ABSTRACT
inline val FirMemberDeclaration.isOpen get() = status.modality == Modality.OPEN
inline val FirMemberDeclaration.isFinal: Boolean
inline val FirMemberDeclaration<*>.modality get() = status.modality
inline val FirMemberDeclaration<*>.isAbstract get() = status.modality == Modality.ABSTRACT
inline val FirMemberDeclaration<*>.isOpen get() = status.modality == Modality.OPEN
inline val FirMemberDeclaration<*>.isFinal: Boolean
get() {
// member with unspecified modality is final
val modality = status.modality ?: return true
return modality == Modality.FINAL
}
inline val FirMemberDeclaration.visibility: Visibility get() = status.visibility
inline val FirMemberDeclaration.effectiveVisibility: EffectiveVisibility
inline val FirMemberDeclaration<*>.visibility: Visibility get() = status.visibility
inline val FirMemberDeclaration<*>.effectiveVisibility: EffectiveVisibility
get() = (status as? FirResolvedDeclarationStatus)?.effectiveVisibility
?: error("Effective visibility for ${render(FirRenderer.RenderMode.NoBodies)} must be resolved")
inline val FirMemberDeclaration.allowsToHaveFakeOverride: Boolean
inline val FirMemberDeclaration<*>.allowsToHaveFakeOverride: Boolean
get() = !Visibilities.isPrivate(visibility) && visibility != Visibilities.InvisibleFake
inline val FirMemberDeclaration.isActual get() = status.isActual
inline val FirMemberDeclaration.isExpect get() = status.isExpect
inline val FirMemberDeclaration.isInner get() = status.isInner
inline val FirMemberDeclaration.isStatic get() = status.isStatic
inline val FirMemberDeclaration.isOverride: Boolean get() = status.isOverride
inline val FirMemberDeclaration.isOperator: Boolean get() = status.isOperator
inline val FirMemberDeclaration.isInfix: Boolean get() = status.isInfix
inline val FirMemberDeclaration.isInline: Boolean get() = status.isInline
inline val FirMemberDeclaration.isTailRec: Boolean get() = status.isTailRec
inline val FirMemberDeclaration.isExternal: Boolean get() = status.isExternal
inline val FirMemberDeclaration.isSuspend: Boolean get() = status.isSuspend
inline val FirMemberDeclaration.isConst: Boolean get() = status.isConst
inline val FirMemberDeclaration.isLateInit: Boolean get() = status.isLateInit
inline val FirMemberDeclaration.isFromSealedClass: Boolean get() = status.isFromSealedClass
inline val FirMemberDeclaration.isFromEnumClass: Boolean get() = status.isFromEnumClass
inline val FirMemberDeclaration<*>.isActual get() = status.isActual
inline val FirMemberDeclaration<*>.isExpect get() = status.isExpect
inline val FirMemberDeclaration<*>.isInner get() = status.isInner
inline val FirMemberDeclaration<*>.isStatic get() = status.isStatic
inline val FirMemberDeclaration<*>.isOverride: Boolean get() = status.isOverride
inline val FirMemberDeclaration<*>.isOperator: Boolean get() = status.isOperator
inline val FirMemberDeclaration<*>.isInfix: Boolean get() = status.isInfix
inline val FirMemberDeclaration<*>.isInline: Boolean get() = status.isInline
inline val FirMemberDeclaration<*>.isTailRec: Boolean get() = status.isTailRec
inline val FirMemberDeclaration<*>.isExternal: Boolean get() = status.isExternal
inline val FirMemberDeclaration<*>.isSuspend: Boolean get() = status.isSuspend
inline val FirMemberDeclaration<*>.isConst: Boolean get() = status.isConst
inline val FirMemberDeclaration<*>.isLateInit: Boolean get() = status.isLateInit
inline val FirMemberDeclaration<*>.isFromSealedClass: Boolean get() = status.isFromSealedClass
inline val FirMemberDeclaration<*>.isFromEnumClass: Boolean get() = status.isFromEnumClass
inline val FirMemberDeclaration<*>.isFun: Boolean get() = status.isFun
inline val FirFunction<*>.hasBody get() = body != null
@@ -103,14 +104,14 @@ inline val FirPropertyAccessor.allowsToHaveFakeOverride: Boolean
inline val FirClassLikeDeclaration<*>.isLocal get() = symbol.classId.isLocal
inline val FirCallableMemberDeclaration<*>.isLocal get() = status.visibility == Visibilities.Local
fun FirRegularClassBuilder.addDeclaration(declaration: FirDeclaration) {
fun FirRegularClassBuilder.addDeclaration(declaration: FirDeclaration<*>) {
declarations += declaration
if (companionObject == null && declaration is FirRegularClass && declaration.isCompanion) {
companionObject = declaration
}
}
fun FirRegularClassBuilder.addDeclarations(declarations: Collection<FirDeclaration>) {
fun FirRegularClassBuilder.addDeclarations(declarations: Collection<FirDeclaration<*>>) {
declarations.forEach(this::addDeclaration)
}
@@ -166,12 +167,12 @@ fun FirRegularClass.collectEnumEntries(): Collection<FirEnumEntry> {
return declarations.filterIsInstance<FirEnumEntry>()
}
fun FirFile.addDeclaration(declaration: FirDeclaration) {
fun FirFile.addDeclaration(declaration: FirDeclaration<*>) {
require(this is FirFileImpl)
declarations += declaration
}
fun FirRegularClass.addDeclaration(declaration: FirDeclaration) {
fun FirRegularClass.addDeclaration(declaration: FirDeclaration<*>) {
@Suppress("LiftReturnOrAssignment")
when (this) {
is FirRegularClassImpl -> declarations += declaration
@@ -189,7 +190,7 @@ var FirRegularClass.moduleName: String? by FirDeclarationDataRegistry.data(Modul
var FirTypeAlias.sourceElement: SourceElement? by FirDeclarationDataRegistry.data(SourceElementKey)
val FirMemberDeclaration.containerSource: SourceElement?
val FirMemberDeclaration<*>.containerSource: SourceElement?
get() = when (this) {
is FirCallableMemberDeclaration<*> -> containerSource
is FirRegularClass -> sourceElement
@@ -230,9 +231,9 @@ val FirQualifiedAccess.referredPropertySymbol: FirPropertySymbol?
return reference.resolvedSymbol as? FirPropertySymbol
}
inline val FirDeclaration.isJava: Boolean
inline val FirDeclaration<*>.isJava: Boolean
get() = origin == FirDeclarationOrigin.Java
inline val FirDeclaration.isFromLibrary: Boolean
inline val FirDeclaration<*>.isFromLibrary: Boolean
get() = origin == FirDeclarationOrigin.Library
inline val FirDeclaration.isSynthetic: Boolean
inline val FirDeclaration<*>.isSynthetic: Boolean
get() = origin == FirDeclarationOrigin.Synthetic
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirMemberDeclarationComparator.kt
+6 -6
View File
@@ -9,10 +9,10 @@ import org.jetbrains.kotlin.fir.render
import org.jetbrains.kotlin.fir.types.FirTypeRefComparator
import org.jetbrains.kotlin.name.Name
object FirMemberDeclarationComparator : Comparator<FirMemberDeclaration> {
object FirMemberDeclarationComparator : Comparator<FirMemberDeclaration<*>> {
// Comparing different kinds of callable members by assigning distinct priorities to those members.
object TypeAndNameComparator : Comparator<FirMemberDeclaration> {
private val FirMemberDeclaration.priority: Int
object TypeAndNameComparator : Comparator<FirMemberDeclaration<*>> {
private val FirMemberDeclaration<*>.priority: Int
get() = when (this) {
is FirEnumEntry -> 7
is FirConstructor -> 6
@@ -23,7 +23,7 @@ object FirMemberDeclarationComparator : Comparator<FirMemberDeclaration> {
is FirTypeAlias -> 1
}
private val FirMemberDeclaration.name: Name
private val FirMemberDeclaration<*>.name: Name
get() = when (this) {
is FirCallableMemberDeclaration<*> ->
this.symbol.callableId.callableName
@@ -33,7 +33,7 @@ object FirMemberDeclarationComparator : Comparator<FirMemberDeclaration> {
this.name
}
override fun compare(a: FirMemberDeclaration, b: FirMemberDeclaration): Int {
override fun compare(a: FirMemberDeclaration<*>, b: FirMemberDeclaration<*>): Int {
val priorityDiff = a.priority - b.priority
if (priorityDiff != 0) {
return priorityDiff
@@ -50,7 +50,7 @@ object FirMemberDeclarationComparator : Comparator<FirMemberDeclaration> {
}
}
override fun compare(a: FirMemberDeclaration, b: FirMemberDeclaration): Int {
override fun compare(a: FirMemberDeclaration<*>, b: FirMemberDeclaration<*>): Int {
if (a is FirCallableMemberDeclaration<*> && b is FirCallableMemberDeclaration<*>) {
return FirCallableMemberDeclarationComparator.compare(a, b)
}
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/danglingConstraints.kt
+2 -2
View File
@@ -16,10 +16,10 @@ data class DanglingTypeConstraint(val name: Name, val source: FirSourceElement)
private object DanglingTypeConstraintsKey : FirDeclarationDataKey()
var <T> T.danglingTypeConstraints: List<DanglingTypeConstraint>?
where T : FirDeclaration, T : FirTypeParameterRefsOwner
where T : FirDeclaration<T>, T : FirTypeParameterRefsOwner
by FirDeclarationDataRegistry.data(DanglingTypeConstraintsKey)
fun FirDeclaration.getDanglingTypeConstraintsOrEmpty(): List<DanglingTypeConstraint> {
fun FirDeclaration<*>.getDanglingTypeConstraintsOrEmpty(): List<DanglingTypeConstraint> {
val res = when (this) {
is FirRegularClass -> danglingTypeConstraints
is FirSimpleFunction -> danglingTypeConstraints
compiler/fir/tree/src/org/jetbrains/kotlin/fir/scopes/FirUnstableSmartcastTypeScope.kt
+2 -2
View File
@@ -6,7 +6,7 @@
package org.jetbrains.kotlin.fir.scopes
import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
import org.jetbrains.kotlin.fir.symbols.impl.*
import org.jetbrains.kotlin.name.Name
@@ -81,7 +81,7 @@ class FirUnstableSmartcastTypeScope(
return ProcessorAction.NEXT
}
fun isSymbolFromUnstableSmartcast(symbol: AbstractFirBasedSymbol<*>) = symbol in symbolsFromUnstableSmartcast
fun isSymbolFromUnstableSmartcast(symbol: FirBasedSymbol<*>) = symbol in symbolsFromUnstableSmartcast
fun markSymbolFromUnstableSmartcast(symbol: FirCallableSymbol<*>) {
symbolsFromUnstableSmartcast += symbol
compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/FirBasedSymbol.kt
+1 -2
View File
@@ -5,10 +5,9 @@
package org.jetbrains.kotlin.fir.symbols
import org.jetbrains.kotlin.fir.FirSymbolOwner
import org.jetbrains.kotlin.fir.declarations.FirDeclaration
abstract class FirBasedSymbol<E> where E : FirSymbolOwner<E>, E : FirDeclaration {
abstract class FirBasedSymbol<E : FirDeclaration<E>> {
private var _fir: E? = null
val fir: E
compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirCallableSymbol.kt
+1 -1
View File
@@ -18,7 +18,7 @@ abstract class FirCallableSymbol<D : FirCallableDeclaration<D>> : FirBasedSymbol
override fun toString(): String = "${this::class.simpleName} $callableId"
}
val FirCallableSymbol<*>.isStatic: Boolean get() = (fir as? FirMemberDeclaration)?.status?.isStatic == true
val FirCallableSymbol<*>.isStatic: Boolean get() = (fir as? FirMemberDeclaration<*>)?.status?.isStatic == true
val FirCallableSymbol<*>.isExtension: Boolean
get() = when (fir) {
compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirClassLikeSymbol.kt
+2 -3
View File
@@ -5,16 +5,15 @@
package org.jetbrains.kotlin.fir.symbols.impl
import org.jetbrains.kotlin.fir.FirSymbolOwner
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
sealed class FirClassLikeSymbol<D>(
sealed class FirClassLikeSymbol<D : FirClassLikeDeclaration<D>>(
val classId: ClassId
) : FirClassifierSymbol<D>() where D : FirClassLikeDeclaration<D>, D : FirSymbolOwner<D> {
) : FirClassifierSymbol<D>() {
abstract override fun toLookupTag(): ConeClassLikeLookupTag
override fun toString(): String = "${this::class.simpleName} ${classId.asString()}"
compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirClassifierSymbol.kt
+2 -4
View File
@@ -5,12 +5,10 @@
package org.jetbrains.kotlin.fir.symbols.impl
import org.jetbrains.kotlin.fir.FirSymbolOwner
import org.jetbrains.kotlin.fir.declarations.FirDeclaration
import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
import org.jetbrains.kotlin.fir.symbols.ConeClassifierLookupTag
import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
sealed class FirClassifierSymbol<E> : FirBasedSymbol<E>()
where E : FirSymbolOwner<E>, E : FirDeclaration {
sealed class FirClassifierSymbol<E : FirDeclaration<E>> : FirBasedSymbol<E>() {
abstract fun toLookupTag(): ConeClassifierLookupTag
}
compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirFileSymbol.kt
+11
View File
@@ -0,0 +1,11 @@
/*
* Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
* 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.FirFile
import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
class FirFileSymbol : FirBasedSymbol<FirFile>()
compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirVariableSymbol.kt
+1 -1
View File
@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.name.CallableId
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
open class FirVariableSymbol<D : FirVariable<D>>(override val callableId: CallableId) : FirCallableSymbol<D>() {
open class FirVariableSymbol<E : FirVariable<E>>(override val callableId: CallableId) : FirCallableSymbol<E>() {
constructor(name: Name) : this(CallableId(name)) // TODO?
}
compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/BuilderConfigurator.kt
+1 -1
View File
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.fir.tree.generator.util.traverseParents
object BuilderConfigurator : AbstractBuilderConfigurator<FirTreeBuilder>(FirTreeBuilder) {
fun configureBuilders() = with(firTreeBuilder) {
val declarationBuilder by builder {
fields from declaration
fields from declaration without "symbol"
}
val annotationContainerBuilder by builder {
compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/FieldSets.kt
+27 -30
View File
@@ -21,24 +21,23 @@ import org.jetbrains.kotlin.fir.tree.generator.context.type
import org.jetbrains.kotlin.fir.tree.generator.model.*
object FieldSets {
val calleeReference = field("calleeReference", reference, withReplace = true)
val calleeReference by lazy { field("calleeReference", reference, withReplace = true) }
val receivers = fieldSet(
field("explicitReceiver", expression, nullable = true, withReplace = true).withTransform(),
field("dispatchReceiver", expression).withTransform(),
field("extensionReceiver", expression).withTransform()
)
val receivers by lazy {
fieldSet(
field("explicitReceiver", expression, nullable = true, withReplace = true).withTransform(),
field("dispatchReceiver", expression).withTransform(),
field("extensionReceiver", expression).withTransform()
)
}
val typeArguments =
fieldList("typeArguments", typeProjection, withReplace = true)
val typeArguments by lazy { fieldList("typeArguments", typeProjection, withReplace = true) }
val arguments =
fieldList("arguments", expression)
val arguments by lazy { fieldList("arguments", expression) }
val declarations = fieldList(declaration)
val declarations by lazy { fieldList(declaration.withArgs("E" to "*")) }
val annotations =
fieldList("annotations", annotationCall).withTransform(needTransformInOtherChildren = true)
val annotations by lazy { fieldList("annotations", annotationCall).withTransform(needTransformInOtherChildren = true) }
fun symbolWithPackage(packageName: String?, symbolClassName: String, argument: String? = null): Field {
return field("symbol", type(packageName, symbolClassName), argument)
@@ -50,39 +49,37 @@ object FieldSets {
fun body(nullable: Boolean = false, withReplace: Boolean = false) =
field("body", block, nullable, withReplace = withReplace)
val returnTypeRef =
field("returnTypeRef", typeRef)
val returnTypeRef =field("returnTypeRef", typeRef)
val typeRefField =
field(typeRef, withReplace = true)
val typeRefField = field(typeRef, withReplace = true)
fun receiverTypeRef(nullable: Boolean = false) = field("receiverTypeRef", typeRef, nullable)
val valueParameters = fieldList(valueParameter)
val valueParameters by lazy { fieldList(valueParameter) }
val typeParameters = fieldList("typeParameters", typeParameter)
val typeParameters by lazy { fieldList("typeParameters", typeParameter) }
val typeParameterRefs = fieldList("typeParameters", typeParameterRef)
val typeParameterRefs by lazy { fieldList("typeParameters", typeParameterRef) }
val name = field(nameType)
val name by lazy { field(nameType) }
val initializer = field("initializer", expression, nullable = true)
val initializer by lazy { field("initializer", expression, nullable = true) }
fun superTypeRefs(withReplace: Boolean = false) = fieldList("superTypeRefs", typeRef, withReplace)
val classKind = field(classKindType)
val classKind by lazy { field(classKindType) }
val status = field("status", declarationStatus)
val status by lazy { field("status", declarationStatus) }
val controlFlowGraphReferenceField = field("controlFlowGraphReference", controlFlowGraphReference, withReplace = true, nullable = true)
val controlFlowGraphReferenceField by lazy { field("controlFlowGraphReference", controlFlowGraphReference, withReplace = true, nullable = true) }
val visibility = field(visibilityType)
val visibility by lazy { field(visibilityType) }
val effectiveVisibility = field("effectiveVisibility", effectiveVisibilityType)
val effectiveVisibility by lazy { field("effectiveVisibility", effectiveVisibilityType) }
val modality = field(modalityType, nullable = true)
val modality by lazy { field(modalityType, nullable = true) }
val scopeProvider = field("scopeProvider", firScopeProviderType)
val scopeProvider by lazy { field("scopeProvider", firScopeProviderType) }
val smartcastStability = field(smartcastStabilityType)
val smartcastStability by lazy { field(smartcastStabilityType) }
}
compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/FirTreeBuilder.kt
+4 -5
View File
@@ -15,7 +15,6 @@ object FirTreeBuilder : AbstractFirTreeBuilder() {
val reference = element("Reference", Reference)
val label = element("Label", Other)
val symbolOwner = element("SymbolOwner", Other)
val resolvable = sealedElement("Resolvable", Expression)
val targetElement = element("TargetElement", Other)
@@ -29,11 +28,11 @@ object FirTreeBuilder : AbstractFirTreeBuilder() {
val expression = element("Expression", Expression, statement)
val declaration = sealedElement("Declaration", Declaration)
val annotatedDeclaration = sealedElement("AnnotatedDeclaration", Declaration, declaration, annotationContainer)
val anonymousInitializer = element("AnonymousInitializer", Declaration, declaration, symbolOwner, controlFlowGraphOwner)
val anonymousInitializer = element("AnonymousInitializer", Declaration, declaration, controlFlowGraphOwner)
val typedDeclaration = sealedElement("TypedDeclaration", Declaration, annotatedDeclaration)
val callableDeclaration = sealedElement("CallableDeclaration", Declaration, typedDeclaration, symbolOwner)
val callableDeclaration = sealedElement("CallableDeclaration", Declaration, typedDeclaration)
val typeParameterRef = element("TypeParameterRef", Declaration)
val typeParameter = element("TypeParameter", Declaration, typeParameterRef, annotatedDeclaration, symbolOwner)
val typeParameter = element("TypeParameter", Declaration, typeParameterRef, annotatedDeclaration)
val typeParameterRefsOwner = sealedElement("TypeParameterRefsOwner", Declaration)
val typeParametersOwner = sealedElement("TypeParametersOwner", Declaration, typeParameterRefsOwner)
val memberDeclaration = sealedElement("MemberDeclaration", Declaration, annotatedDeclaration, typeParameterRefsOwner)
@@ -45,7 +44,7 @@ object FirTreeBuilder : AbstractFirTreeBuilder() {
val field = element("Field", Declaration, variable, typeParametersOwner, callableMemberDeclaration)
val enumEntry = element("EnumEntry", Declaration, variable, callableMemberDeclaration)
val classLikeDeclaration = sealedElement("ClassLikeDeclaration", Declaration, annotatedDeclaration, statement, symbolOwner)
val classLikeDeclaration = sealedElement("ClassLikeDeclaration", Declaration, annotatedDeclaration, statement)
val klass = sealedElement("Class", Declaration, classLikeDeclaration, statement, typeParameterRefsOwner)
val regularClass = element("RegularClass", Declaration, memberDeclaration, typeParameterRefsOwner, controlFlowGraphOwner, klass)
val typeAlias = element("TypeAlias", Declaration, classLikeDeclaration, memberDeclaration, typeParametersOwner)
compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/ImplementationConfigurator.kt
+4
View File
@@ -495,6 +495,10 @@ object ImplementationConfigurator : AbstractFirTreeImplementationConfigurator()
noImpl(userTypeRef)
impl(file) {
default("symbol", "FirFileSymbol()")
}
noImpl(argumentList)
}
compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt
+63 -46
View File
@@ -46,10 +46,10 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
+annotations
}
symbolOwner.configure {
withArg("E", symbolOwner, declaration)
+symbolWithPackage("fir.symbols", "FirBasedSymbol", "E")
}
// symbolOwner.configure {
// withArg("DE, symbolOwner, declaration)
// +symbolWithPackage("fir.symbols", "FirBasedSymbol", "DE)
// }
typeParameterRef.configure {
+symbol(typeParameterSymbolType.type)
@@ -76,45 +76,57 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
}
declaration.configure {
withArg("E", declaration)
+symbolWithPackage("fir.symbols", "FirBasedSymbol", "E")
+field("moduleData", firModuleDataType)
+field("resolvePhase", resolvePhaseType, withReplace = true).apply { isMutable = true }
+field("origin", declarationOriginType)
+field("attributes", declarationAttributesType)
}
annotatedDeclaration.configure {
withArg("E", annotatedDeclaration)
parentArg(declaration, "E", "E")
}
typedDeclaration.configure {
withArg("E", typedDeclaration)
parentArg(annotatedDeclaration, "E", "E")
+field("returnTypeRef", typeRef, withReplace = true).withTransform()
}
callableDeclaration.configure {
withArg("F", "FirCallableDeclaration<F>")
parentArg(symbolOwner, "E", "F")
withArg("E", "FirCallableDeclaration<E>")
parentArg(typedDeclaration, "E", "E")
+field("receiverTypeRef", typeRef, nullable = true, withReplace = true).withTransform()
+symbol("FirCallableSymbol", "F")
+symbol("FirCallableSymbol", "E")
}
callableMemberDeclaration.configure {
withArg("F", "FirCallableMemberDeclaration<F>")
parentArg(callableDeclaration, "F", "F")
withArg("E", "FirCallableMemberDeclaration<E>")
parentArg(callableDeclaration, "E", "E")
parentArg(memberDeclaration, "E", "E")
+field("containerSource", type(DeserializedContainerSource::class), nullable = true)
+field("dispatchReceiverType", coneKotlinTypeType, nullable = true)
}
function.configure {
withArg("F", "FirFunction<F>")
parentArg(callableDeclaration, "F", "F")
+symbol("FirFunctionSymbol", "F")
withArg("E", "FirFunction<E>")
parentArg(callableDeclaration, "E", "E")
+symbol("FirFunctionSymbol", "E")
+fieldList(valueParameter, withReplace = true).withTransform()
+body(nullable = true, withReplace = true).withTransform()
}
errorFunction.configure {
parentArg(function, "F", errorFunction)
parentArg(function, "E", errorFunction)
+symbol("FirErrorFunctionSymbol")
+typeParameters
}
memberDeclaration.configure {
withArg("E", "FirMemberDeclaration<E>")
parentArg(annotatedDeclaration, "E", "E")
+typeParameterRefs
+status.withTransform()
}
@@ -155,7 +167,7 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
}
returnExpression.configure {
parentArg(jump, "E", function.withArgs("F" to "*"))
parentArg(jump, "E", function.withArgs("E" to "*"))
+field("result", expression).withTransform()
needTransformOtherChildren()
}
@@ -239,15 +251,15 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
}
classLikeDeclaration.configure {
withArg("F", "FirClassLikeDeclaration<F>")
parentArg(symbolOwner, "F", "F")
+symbol("FirClassLikeSymbol", "F")
withArg("E", "FirClassLikeDeclaration<E>")
parentArg(annotatedDeclaration, "E", "E")
+symbol("FirClassLikeSymbol", "E")
}
klass.configure {
withArg("F", "FirClass<F>")
parentArg(classLikeDeclaration, "F", "F")
+symbol("FirClassSymbol", "F")
withArg("E", "FirClass<E>")
parentArg(classLikeDeclaration, "E", "E")
+symbol("FirClassSymbol", "E")
+classKind
+superTypeRefs(withReplace = true).withTransform()
+declarations.withTransform()
@@ -256,7 +268,8 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
}
regularClass.configure {
parentArg(klass, "F", regularClass)
parentArg(klass, "E", regularClass)
parentArg(memberDeclaration, "E", regularClass)
+name
+symbol("FirRegularClassSymbol")
+field("companionObject", regularClass, nullable = true).withTransform()
@@ -265,7 +278,7 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
}
anonymousObject.configure {
parentArg(klass, "F", anonymousObject)
parentArg(klass, "E", anonymousObject)
+symbol("FirAnonymousObjectSymbol")
}
@@ -275,7 +288,8 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
typeAlias.configure {
+typeParameters
parentArg(classLikeDeclaration, "F", typeAlias)
parentArg(classLikeDeclaration, "E", typeAlias)
parentArg(memberDeclaration, "E", typeAlias)
+name
+symbol("FirTypeAliasSymbol")
+field("expandedTypeRef", typeRef, withReplace = true).withTransform()
@@ -283,7 +297,7 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
}
anonymousFunction.configure {
parentArg(function, "F", anonymousFunction)
parentArg(function, "E", anonymousFunction)
+symbol("FirAnonymousFunctionSymbol")
+field(label, nullable = true)
+field("invocationKind", eventOccurrencesRangeType, nullable = true, withReplace = true).apply {
@@ -302,7 +316,7 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
}
typeParameter.configure {
parentArg(symbolOwner, "F", typeParameter)
parentArg(annotatedDeclaration, "E", typeParameter)
+name
+symbol("FirTypeParameterSymbol")
+field(varianceType)
@@ -312,8 +326,8 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
}
simpleFunction.configure {
parentArg(function, "F", simpleFunction)
parentArg(callableMemberDeclaration, "F", simpleFunction)
parentArg(function, "E", simpleFunction)
parentArg(callableMemberDeclaration, "E", simpleFunction)
+name
+symbol("FirNamedFunctionSymbol")
+annotations
@@ -325,8 +339,8 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
}
property.configure {
parentArg(variable, "F", property)
parentArg(callableMemberDeclaration, "F", property)
parentArg(variable, "E", property)
parentArg(callableMemberDeclaration, "E", property)
+symbol("FirPropertySymbol")
+field("backingFieldSymbol", backingFieldSymbolType)
+booleanField("isLocal")
@@ -334,8 +348,8 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
}
propertyAccessor.configure {
parentArg(function, "F", propertyAccessor)
parentArg(callableMemberDeclaration, "F", propertyAccessor)
parentArg(function, "E", propertyAccessor)
parentArg(callableMemberDeclaration, "E", propertyAccessor)
+symbol("FirPropertyAccessorSymbol")
+booleanField("isGetter")
+booleanField("isSetter")
@@ -359,8 +373,8 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
}
constructor.configure {
parentArg(function, "F", constructor)
parentArg(callableMemberDeclaration, "F", constructor)
parentArg(function, "E", constructor)
parentArg(callableMemberDeclaration, "E", constructor)
+annotations
+symbol("FirConstructorSymbol")
+field("delegatedConstructor", delegatedConstructorCall, nullable = true).withTransform()
@@ -376,19 +390,20 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
}
valueParameter.configure {
parentArg(variable, "F", valueParameter)
parentArg(variable, "E", valueParameter)
+field("defaultValue", expression, nullable = true)
generateBooleanFields("crossinline", "noinline", "vararg")
}
variable.configure {
withArg("F", variable)
parentArg(callableDeclaration, "F", "F")
withArg("E", variable)
parentArg(callableDeclaration, "E", "E")
parentArg(annotatedDeclaration, "E", "E")
+name
+symbol("FirVariableSymbol", "F")
+symbol("FirVariableSymbol", "E")
+initializer.withTransform().withReplace()
+field("delegate", expression, nullable = true).withTransform()
+field("delegateFieldSymbol", delegateFieldSymbolType, "F", nullable = true)
+field("delegateFieldSymbol", delegateFieldSymbolType, "E", nullable = true)
generateBooleanFields("var", "val")
+field("getter", propertyAccessor, nullable = true).withTransform()
+field("setter", propertyAccessor, nullable = true).withTransform()
@@ -397,31 +412,33 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
}
errorProperty.configure {
parentArg(variable, "F", errorProperty)
parentArg(variable, "E", errorProperty)
+symbol("FirErrorPropertySymbol")
}
enumEntry.configure {
parentArg(variable, "F", enumEntry)
parentArg(callableMemberDeclaration, "F", enumEntry)
parentArg(variable, "E", enumEntry)
parentArg(callableMemberDeclaration, "E", enumEntry)
}
field.configure {
parentArg(variable, "F", field)
parentArg(callableMemberDeclaration, "F", field)
parentArg(variable, "E", field)
parentArg(callableMemberDeclaration, "E", field)
}
anonymousInitializer.configure {
parentArg(symbolOwner, "E", anonymousInitializer)
parentArg(declaration, "E", anonymousInitializer)
+body(nullable = true)
+symbol(anonymousInitializerSymbolType.type)
}
file.configure {
parentArg(annotatedDeclaration, "E", file)
+fieldList(import).withTransform()
+declarations.withTransform()
+stringField("name")
+field("packageFqName", fqNameType)
+symbol(fileSymbolType.type)
}
import.configure {
@@ -621,7 +638,7 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
whenExpression.configure {
+field("subject", expression, nullable = true).withTransform()
+field("subjectVariable", variable.withArgs("F" to "*"), nullable = true)
+field("subjectVariable", variable.withArgs("E" to "*"), nullable = true)
+fieldList("branches", whenBranch).withTransform()
+field("exhaustivenessStatus", exhaustivenessStatusType, nullable = true, withReplace = true)
+booleanField("usedAsExpression")
@@ -652,7 +669,7 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
}
}
private fun Element.withArgs(vararg replacements: Pair<String, String>): AbstractElement {
fun Element.withArgs(vararg replacements: Pair<String, String>): AbstractElement {
val replaceMap = replacements.toMap()
val newArguments = typeArguments.map { replaceMap[it.name]?.let { SimpleTypeArgument(it, null) } ?: it }
return ElementWithArguments(this, newArguments)
compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/Types.kt
+1
View File
@@ -72,6 +72,7 @@ val typeParameterSymbolType = type("fir.symbols.impl", "FirTypeParameterSymbol")
val emptyArgumentListType = type("fir.expressions", "FirEmptyArgumentList")
val firScopeProviderType = type("fir.scopes", "FirScopeProvider")
val anonymousInitializerSymbolType = type("fir.symbols.impl", "FirAnonymousInitializerSymbol")
val fileSymbolType = type("fir.symbols.impl", "FirFileSymbol")
val pureAbstractElementType = generatedType("FirPureAbstractElement")
val coneEffectDeclarationType = type("fir.contracts.description", "ConeEffectDeclaration")
compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/model/Element.kt
+2 -1
View File
@@ -20,6 +20,7 @@ interface FieldContainer {
}
interface AbstractElement : FieldContainer, KindOwner {
val name: String
val fields: Set<Field>
val parents: List<AbstractElement>
val typeArguments: List<TypeArgument>
@@ -41,7 +42,7 @@ interface AbstractElement : FieldContainer, KindOwner {
override val allParents: List<KindOwner> get() = parents
}
class Element(val name: String, kind: Kind) : AbstractElement {
class Element(override val name: String, kind: Kind) : AbstractElement {
companion object {
private val allowedKinds = setOf(
Implementation.Kind.Interface,
compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/model/ElementUtils.kt
+2 -2
View File
@@ -66,7 +66,7 @@ fun fieldList(name: String, type: Importable, withReplace: Boolean = false): Fie
return FieldList(name, type, withReplace)
}
fun fieldList(element: Element, withReplace: Boolean = false): Field {
fun fieldList(element: AbstractElement, withReplace: Boolean = false): Field {
return FieldList(element.name.replaceFirstChar(Char::lowercaseChar) + "s", element, withReplace)
}
@@ -96,4 +96,4 @@ fun Field.withReplace(): Field = copy().apply {
withReplace = true
}
fun FieldSet.withTransform(): FieldSet = this.map { it.withTransform() }
fun FieldSet.withTransform(): FieldSet = this.map { it.withTransform() }
compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/model/Field.kt
+1 -1
View File
@@ -205,5 +205,5 @@ class FieldList(
)
}
override val isFirType: Boolean = baseType is Element
override val isFirType: Boolean = baseType is AbstractElement
}
compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/util/BaseTransformerTypeFinder.kt
+1 -2
View File
@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.fir.tree.generator.util
import org.jetbrains.kotlin.fir.tree.generator.context.AbstractFirTreeBuilder
import org.jetbrains.kotlin.fir.tree.generator.model.AbstractElement
import org.jetbrains.kotlin.fir.tree.generator.model.Element
import org.jetbrains.kotlin.fir.tree.generator.model.FieldList
import org.jetbrains.kotlin.fir.tree.generator.model.FirField
@@ -17,7 +16,7 @@ fun detectBaseTransformerTypes(builder: AbstractFirTreeBuilder) {
for (field in element.allFirFields) {
val fieldElement = when (field) {
is FirField -> field.element
is FieldList -> field.baseType as Element
is FieldList -> field.baseType as AbstractElement
else -> throw IllegalArgumentException()
}
usedAsFieldType[fieldElement] = true