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

[FIR] Remove default visited hierarchy

Browse Source
This commit is contained in:
Dmitriy Novozhilov
2019-09-17 14:17:29 +03:00
parent 9b32bd7138
commit e70c1d6959
23 changed files with 673 additions and 390 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/fir/dump/src/org/jetbrains/kotlin/fir/dump/HtmlFirDump.kt
+7 -7
View File
@@ -323,7 +323,7 @@ class MultiModuleHtmlFirDump(private val outputRoot: File) {
override fun visitRegularClass(regularClass: FirRegularClass) {
classes[regularClass.classId] = location
super.visitRegularClass(regularClass)
visitElement(regularClass)
}
fun indexDeclaration(symbolOwner: FirSymbolOwner<*>) {
@@ -333,32 +333,32 @@ class MultiModuleHtmlFirDump(private val outputRoot: File) {
override fun <F : FirVariable<F>> visitVariable(variable: FirVariable<F>) {
indexDeclaration(variable)
super.visitVariable(variable)
visitElement(variable)
}
override fun visitValueParameter(valueParameter: FirValueParameter) {
indexDeclaration(valueParameter)
super.visitValueParameter(valueParameter)
visitElement(valueParameter)
}
override fun visitNamedFunction(namedFunction: FirNamedFunction) {
indexDeclaration(namedFunction)
super.visitNamedFunction(namedFunction)
visitElement(namedFunction)
}
override fun visitTypeParameter(typeParameter: FirTypeParameter) {
indexDeclaration(typeParameter)
super.visitTypeParameter(typeParameter)
visitElement(typeParameter)
}
override fun visitProperty(property: FirProperty) {
indexDeclaration(property)
super.visitProperty(property)
visitElement(property)
}
override fun visitConstructor(constructor: FirConstructor) {
indexDeclaration(constructor)
super.visitConstructor(constructor)
visitElement(constructor)
}
}
}
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt
+22 -2
View File
@@ -53,7 +53,7 @@ import org.jetbrains.kotlin.types.AbstractStrictEqualityTypeChecker
import org.jetbrains.kotlin.types.Variance
import java.util.*
internal class Fir2IrVisitor(
class Fir2IrVisitor(
private val session: FirSession,
private val moduleDescriptor: FirModuleDescriptor,
private val symbolTable: SymbolTable,
@@ -297,6 +297,10 @@ internal class Fir2IrVisitor(
}
}
override fun visitEnumEntry(enumEntry: FirEnumEntry, data: Any?): IrElement {
return visitRegularClass(enumEntry, data)
}
private fun IrFunction.addDispatchReceiverParameter(containingClass: IrClass) {
val thisOrigin = IrDeclarationOrigin.DEFINED
val thisType = containingClass.thisReceiver!!.type
@@ -661,6 +665,18 @@ internal class Fir2IrVisitor(
return wrappedArgumentExpression.expression.toIrExpression()
}
override fun visitNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression, data: Any?): IrElement {
return visitWrappedArgumentExpression(namedArgumentExpression, data)
}
override fun visitLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression, data: Any?): IrElement {
return visitWrappedArgumentExpression(lambdaArgumentExpression, data)
}
override fun visitSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression, data: Any?): IrElement {
return visitWrappedArgumentExpression(spreadArgumentExpression, data)
}
private fun FirReference.statementOrigin(): IrStatementOrigin? {
return when (this) {
is FirPropertyFromParameterCallableReference -> IrStatementOrigin.INITIALIZE_PROPERTY_FROM_PARAMETER
@@ -793,6 +809,10 @@ internal class Fir2IrVisitor(
return functionCall.toIrExpression(functionCall.typeRef).applyCallArguments(functionCall).applyReceivers(functionCall)
}
override fun visitComponentCall(componentCall: FirComponentCall, data: Any?): IrElement {
return visitFunctionCall(componentCall, data)
}
override fun visitAnnotationCall(annotationCall: FirAnnotationCall, data: Any?): IrElement {
return annotationCall.toIrExpression().applyCallArguments(annotationCall)
}
@@ -1249,7 +1269,7 @@ internal class Fir2IrVisitor(
)
}
}
return super.visitResolvedQualifier(resolvedQualifier, data)
return visitElement(resolvedQualifier, data)
}
override fun visitBinaryLogicExpression(binaryLogicExpression: FirBinaryLogicExpression, data: Any?): IrElement {
compiler/fir/psi2fir/tests/org/jetbrains/kotlin/fir/builder/RawFirBuilderTotalKotlinTestCase.kt
+1 -1
View File
@@ -80,7 +80,7 @@ class RawFirBuilderTotalKotlinTestCase : AbstractRawFirBuilderTestCase() {
} else {
normalReferences++
}
super.visitQualifiedAccess(qualifiedAccess)
visitStatement(qualifiedAccess)
}
override fun visitExpression(expression: FirExpression) {
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirProviderImpl.kt
+4
View File
@@ -102,6 +102,10 @@ class FirProviderImpl(val session: FirSession) : FirProvider() {
override fun visitProperty(property: FirProperty) {
visitCallableMemberDeclaration(property)
}
override fun visitEnumEntry(enumEntry: FirEnumEntry) {
visitRegularClass(enumEntry)
}
})
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirBodyResolveTransformer.kt
+49 -19
View File
@@ -101,7 +101,7 @@ open class FirBodyResolveTransformer(
return withScopeCleanup(topLevelScopes) {
topLevelScopes.addImportingScopes(file, session, scopeSession)
topLevelScopes += FirTopLevelDeclaredMemberScope(file, session, scopeSession)
super.transformFile(file, data)
transformElement(file, data)
}
}
@@ -112,7 +112,7 @@ open class FirBodyResolveTransformer(
override fun transformConstructor(constructor: FirConstructor, data: Any?): CompositeTransformResult<FirDeclaration> {
if (implicitTypeOnly) return constructor.compose()
return super.transformConstructor(constructor, data)
return transformFunction(constructor, data)
}
override fun transformAnonymousInitializer(
@@ -123,7 +123,7 @@ open class FirBodyResolveTransformer(
return withScopeCleanup(localScopes) {
dataFlowAnalyzer.enterInitBlock(anonymousInitializer)
localScopes.addIfNotNull(primaryConstructorParametersScope)
super.transformAnonymousInitializer(anonymousInitializer, data).also {
transformDeclaration(anonymousInitializer, data).also {
dataFlowAnalyzer.exitInitBlock(it.single as FirAnonymousInitializer)
}
}
@@ -142,7 +142,7 @@ open class FirBodyResolveTransformer(
valueParameter.resolvePhase = transformerPhase
return valueParameter.compose() // TODO
}
return super.transformValueParameter(valueParameter, valueParameter.returnTypeRef)
return transformDeclaration(valueParameter, valueParameter.returnTypeRef)
}
override fun transformRegularClass(regularClass: FirRegularClass, data: Any?): CompositeTransformResult<FirDeclaration> {
@@ -156,17 +156,21 @@ open class FirBodyResolveTransformer(
constructor.valueParameters.forEach { this.storeDeclaration(it) }
}
}
super.transformRegularClass(regularClass, data)
transformDeclaration(regularClass, data)
}
primaryConstructorParametersScope = oldConstructorScope
return result
}
override fun transformEnumEntry(enumEntry: FirEnumEntry, data: Any?): CompositeTransformResult<FirDeclaration> {
return transformRegularClass(enumEntry, data)
}
override fun transformUncheckedNotNullCast(
uncheckedNotNullCast: FirUncheckedNotNullCast,
data: Any?
): CompositeTransformResult<FirStatement> {
val notNullCast = super.transformUncheckedNotNullCast(uncheckedNotNullCast, data).single as FirUncheckedNotNullCast
val notNullCast = transformExpression(uncheckedNotNullCast, data).single as FirUncheckedNotNullCast
val resultType = notNullCast.expression.resultType
notNullCast.resultType =
resultType.withReplacedConeType(resultType.coneTypeUnsafe<ConeKotlinType>().withNullability(ConeNullability.NOT_NULL))
@@ -268,6 +272,13 @@ open class FirBodyResolveTransformer(
}
}
override fun transformCallableReferenceAccess(
callableReferenceAccess: FirCallableReferenceAccess,
data: Any?
): CompositeTransformResult<FirStatement> {
return transformQualifiedAccessExpression(callableReferenceAccess, data)
}
override fun transformVariableAssignment(
variableAssignment: FirVariableAssignment,
data: Any?
@@ -350,7 +361,7 @@ open class FirBodyResolveTransformer(
)
af = af.transformValueParameters(ImplicitToErrorTypeTransformer, null) as FirAnonymousFunction
val bodyExpectedType = returnTypeRefFromResolvedAtom ?: data
af = super.transformAnonymousFunction(af, bodyExpectedType).single as FirAnonymousFunction
af = transformFunction(af, bodyExpectedType).single as FirAnonymousFunction
af = af.copy(
returnTypeRef = af.body?.resultType ?: FirErrorTypeRefImpl(af.psi, "No result type for lambda")
)
@@ -358,7 +369,7 @@ open class FirBodyResolveTransformer(
af.compose()
}
else -> {
super.transformAnonymousFunction(anonymousFunction, data)
transformFunction(anonymousFunction, data)
}
}
}
@@ -385,8 +396,8 @@ open class FirBodyResolveTransformer(
val receiverTypeRef = anonymousFunction.receiverTypeRef
fun transform(): FirAnonymousFunction {
val expectedReturnType =
lambdaResolution.expectedReturnTypeRef ?: anonymousFunction.returnTypeRef.takeUnless { it is FirImplicitTypeRef }
val result = super.transformAnonymousFunction(anonymousFunction, expectedReturnType).single as FirAnonymousFunction
lambdaResolution.expectedReturnTypeRef ?: anonymousFunction.returnTypeRef.takeUnless { it is FirImplicitTypeRef }
val result = transformFunction(anonymousFunction, expectedReturnType).single as FirAnonymousFunction
val body = result.body
return if (result.returnTypeRef is FirImplicitTypeRef && body != null) {
result.transformReturnTypeRef(this, body.resultType)
@@ -475,7 +486,11 @@ open class FirBodyResolveTransformer(
}
// override fun transformNamedReference(namedReference: FirNamedReference, data: Any?): CompositeTransformResult<FirNamedReference> {
override fun transformComponentCall(componentCall: FirComponentCall, data: Any?): CompositeTransformResult<FirStatement> {
return transformFunctionCall(componentCall, data)
}
// override fun transformNamedReference(namedReference: FirNamedReference, data: Any?): CompositeTransformResult<FirNamedReference> {
// if (namedReference is FirErrorNamedReference || namedReference is FirResolvedCallableReference) return namedReference.compose()
// val referents = data as? List<ConeCallableSymbol> ?: return namedReference.compose()
// return createResolvedNamedReference(namedReference, referents).compose()
@@ -503,13 +518,28 @@ open class FirBodyResolveTransformer(
}
override fun <E : FirTargetElement> transformJump(jump: FirJump<E>, data: Any?): CompositeTransformResult<FirStatement> {
val result = super.transformJump(jump, data)
val result = transformExpression(jump, data)
dataFlowAnalyzer.exitJump(jump)
return result
}
override fun transformBreakExpression(breakExpression: FirBreakExpression, data: Any?): CompositeTransformResult<FirStatement> {
return transformJump(breakExpression, data)
}
override fun transformContinueExpression(
continueExpression: FirContinueExpression,
data: Any?
): CompositeTransformResult<FirStatement> {
return transformJump(continueExpression, data)
}
override fun transformReturnExpression(returnExpression: FirReturnExpression, data: Any?): CompositeTransformResult<FirStatement> {
return transformJump(returnExpression, data)
}
override fun transformThrowExpression(throwExpression: FirThrowExpression, data: Any?): CompositeTransformResult<FirStatement> {
return super.transformThrowExpression(throwExpression, data).also {
return transformExpression(throwExpression, data).also {
dataFlowAnalyzer.exitThrowExceptionNode(it.single as FirThrowExpression)
}
}
@@ -606,7 +636,7 @@ open class FirBodyResolveTransformer(
}
return super.transformConstExpression(constExpression, data).also {
return transformExpression(constExpression, data).also {
dataFlowAnalyzer.exitConstExpresion(it.single as FirConstExpression<*>)
}
}
@@ -628,7 +658,7 @@ open class FirBodyResolveTransformer(
return withScopeCleanup(localScopes) {
localScopes += FirLocalScope()
dataFlowAnalyzer.enterFunction(function)
super.transformFunction(function, data).also {
transformDeclaration(function, data).also {
val result = it.single as FirFunction<*>
dataFlowAnalyzer.exitFunction(result)?.let { controlFlowGraph ->
result.transformControlFlowGraphReference(ControlFlowGraphReferenceTransformer, controlFlowGraph)
@@ -678,7 +708,7 @@ open class FirBodyResolveTransformer(
override fun transformPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: Any?): CompositeTransformResult<FirDeclaration> {
if (propertyAccessor is FirDefaultPropertyAccessor || propertyAccessor.body == null) {
return super.transformPropertyAccessor(propertyAccessor, data)
return transformFunction(propertyAccessor, data)
}
val returnTypeRef = propertyAccessor.returnTypeRef
if (returnTypeRef is FirImplicitTypeRef && data !is FirResolvedTypeRef) {
@@ -748,7 +778,7 @@ open class FirBodyResolveTransformer(
wrappedDelegateExpression: FirWrappedDelegateExpression,
data: Any?
): CompositeTransformResult<FirStatement> {
super.transformWrappedDelegateExpression(wrappedDelegateExpression, data)
transformExpression(wrappedDelegateExpression, data)
with(wrappedDelegateExpression) {
val delegateProviderTypeRef = delegateProvider.typeRef
val useDelegateProvider = delegateProviderTypeRef is FirResolvedTypeRef &&
@@ -812,7 +842,7 @@ open class FirBodyResolveTransformer(
}
override fun transformGetClassCall(getClassCall: FirGetClassCall, data: Any?): CompositeTransformResult<FirStatement> {
val transformedGetClassCall = super.transformGetClassCall(getClassCall, data).single as FirGetClassCall
val transformedGetClassCall = transformExpression(getClassCall, data).single as FirGetClassCall
val kClassSymbol = ClassId.fromString("kotlin/reflect/KClass")(session.service())
val typeOfExpression = when (val lhs = transformedGetClassCall.argument) {
@@ -870,7 +900,7 @@ open class FirBodyResolveTransformer(
it.resultType = builtinTypes.booleanType
}
} else {
super.transformOperatorCall(operatorCall, data).single
transformExpression(operatorCall, data).single
} as FirOperatorCall
dataFlowAnalyzer.exitOperatorCall(result)
return result.compose()
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt
+13 -3
View File
@@ -9,7 +9,6 @@ import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.copy
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.expressions.*
import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
import org.jetbrains.kotlin.fir.references.FirResolvedCallableReferenceImpl
import org.jetbrains.kotlin.fir.resolve.calls.FirNamedReferenceWithCandidate
import org.jetbrains.kotlin.fir.resolve.calls.candidate
@@ -58,6 +57,13 @@ class FirCallCompletionResultsWriterTransformer(
).compose()
}
override fun transformCallableReferenceAccess(
callableReferenceAccess: FirCallableReferenceAccess,
data: Nothing?
): CompositeTransformResult<FirStatement> {
return transformQualifiedAccessExpression(callableReferenceAccess, data)
}
override fun transformVariableAssignment(
variableAssignment: FirVariableAssignment,
data: Nothing?
@@ -131,6 +137,10 @@ class FirCallCompletionResultsWriterTransformer(
}
override fun transformComponentCall(componentCall: FirComponentCall, data: Nothing?): CompositeTransformResult<FirStatement> {
return transformFunctionCall(componentCall, data)
}
override fun transformAnonymousFunction(
anonymousFunction: FirAnonymousFunction,
data: Nothing?
@@ -145,7 +155,7 @@ class FirCallCompletionResultsWriterTransformer(
anonymousFunction.replaceTypeRef(anonymousFunction.constructFunctionalTypeRef(session))
}
return super.transformAnonymousFunction(anonymousFunction, data)
return transformElement(anonymousFunction, data)
}
override fun transformBlock(block: FirBlock, data: Nothing?): CompositeTransformResult<FirStatement> {
@@ -155,7 +165,7 @@ class FirCallCompletionResultsWriterTransformer(
val resultType = block.resultType.withReplacedConeType(finalType)
block.replaceTypeRef(resultType)
}
return super.transformBlock(block, data)
return transformElement(block, data)
}
override fun transformWhenExpression(whenExpression: FirWhenExpression, data: Nothing?): CompositeTransformResult<FirStatement> {
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSpecificTypeResolverTransformer.kt
+30
View File
@@ -58,4 +58,34 @@ class FirSpecificTypeResolverTransformer(
override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: Nothing?): CompositeTransformResult<FirTypeRef> {
return implicitTypeRef.compose()
}
override fun transformErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: Nothing?): CompositeTransformResult<FirTypeRef> {
return transformTypeRef(errorTypeRef, data)
}
override fun transformResolvedFunctionTypeRef(
resolvedFunctionTypeRef: FirResolvedFunctionTypeRef,
data: Nothing?
): CompositeTransformResult<FirTypeRef> {
return transformTypeRef(resolvedFunctionTypeRef, data)
}
override fun transformTypeRefWithNullability(
typeRefWithNullability: FirTypeRefWithNullability,
data: Nothing?
): CompositeTransformResult<FirTypeRef> {
return transformTypeRef(typeRefWithNullability, data)
}
override fun transformUserTypeRef(userTypeRef: FirUserTypeRef, data: Nothing?): CompositeTransformResult<FirTypeRef> {
return transformTypeRef(userTypeRef, data)
}
override fun transformDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: Nothing?): CompositeTransformResult<FirTypeRef> {
return transformTypeRef(dynamicTypeRef, data)
}
override fun transformDelegatedTypeRef(delegatedTypeRef: FirDelegatedTypeRef, data: Nothing?): CompositeTransformResult<FirTypeRef> {
return transformTypeRef(delegatedTypeRef, data)
}
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt
+20 -8
View File
@@ -63,7 +63,7 @@ class FirStatusResolveTransformer : FirAbstractTreeTransformer(phase = FirResolv
override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult<FirFile> {
session = file.fileSession
return super.transformFile(file, data)
return transformElement(file, data)
}
override fun transformDeclarationStatus(
@@ -81,7 +81,7 @@ class FirStatusResolveTransformer : FirAbstractTreeTransformer(phase = FirResolv
return resolvedStatus.compose()
}
return super.transformDeclarationStatus(declarationStatus, data)
return transformElement(declarationStatus, data)
}
private inline fun storeDeclaration(
@@ -104,9 +104,13 @@ class FirStatusResolveTransformer : FirAbstractTreeTransformer(phase = FirResolv
return result
}
override fun transformTypeAlias(typeAlias: FirTypeAlias, data: Nothing?): CompositeTransformResult<FirDeclaration> {
return transformMemberDeclaration(typeAlias, data)
}
override fun transformRegularClass(regularClass: FirRegularClass, data: Nothing?): CompositeTransformResult<FirDeclaration> {
return storeClass(regularClass) {
super.transformRegularClass(regularClass, data)
transformMemberDeclaration(regularClass, data)
}
}
@@ -115,7 +119,7 @@ class FirStatusResolveTransformer : FirAbstractTreeTransformer(phase = FirResolv
data: Nothing?
): CompositeTransformResult<FirDeclaration> {
return storeDeclaration(memberDeclaration) {
super.transformMemberDeclaration(memberDeclaration, data)
transformDeclaration(memberDeclaration, data)
}
}
@@ -124,7 +128,7 @@ class FirStatusResolveTransformer : FirAbstractTreeTransformer(phase = FirResolv
data: Nothing?
): CompositeTransformResult<FirDeclaration> {
return storeDeclaration(propertyAccessor) {
super.transformPropertyAccessor(propertyAccessor, data)
transformDeclaration(propertyAccessor, data)
}
}
@@ -133,7 +137,7 @@ class FirStatusResolveTransformer : FirAbstractTreeTransformer(phase = FirResolv
data: Nothing?
): CompositeTransformResult<FirDeclaration> {
return storeDeclaration(constructor) {
super.transformConstructor(constructor, data)
transformDeclaration(constructor, data)
}
}
@@ -142,7 +146,7 @@ class FirStatusResolveTransformer : FirAbstractTreeTransformer(phase = FirResolv
data: Nothing?
): CompositeTransformResult<FirDeclaration> {
return storeDeclaration(namedFunction) {
super.transformNamedFunction(namedFunction, data)
transformDeclaration(namedFunction, data)
}
}
@@ -151,7 +155,15 @@ class FirStatusResolveTransformer : FirAbstractTreeTransformer(phase = FirResolv
data: Nothing?
): CompositeTransformResult<FirDeclaration> {
return storeDeclaration(property) {
super.transformProperty(property, data)
transformDeclaration(property, data)
}
}
override fun transformValueParameter(valueParameter: FirValueParameter, data: Nothing?): CompositeTransformResult<FirDeclaration> {
return transformDeclaration(valueParameter, data)
}
override fun transformEnumEntry(enumEntry: FirEnumEntry, data: Nothing?): CompositeTransformResult<FirDeclaration> {
return transformRegularClass(enumEntry, data)
}
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypeResolverTransformer.kt
+30 -11
View File
@@ -8,11 +8,7 @@ package org.jetbrains.kotlin.fir.resolve.transformers
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.render
import org.jetbrains.kotlin.fir.resolve.FirProvider
import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider
import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
import org.jetbrains.kotlin.fir.resolve.ScopeSession
import org.jetbrains.kotlin.fir.resolve.lookupSuperTypes
import org.jetbrains.kotlin.fir.resolve.*
import org.jetbrains.kotlin.fir.scopes.FirPosition
import org.jetbrains.kotlin.fir.scopes.addImportingScopes
import org.jetbrains.kotlin.fir.scopes.impl.FirNestedClassifierScope
@@ -31,7 +27,7 @@ class FirSupertypeResolverTransformer : FirAbstractTreeTransformer(phase = FirRe
override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult<FirFile> {
initFromFile(file)
return super.transformFile(file, data)
return transformElement(file, data)
}
fun initFromFile(file: FirFile) {
@@ -43,7 +39,7 @@ class FirSupertypeResolverTransformer : FirAbstractTreeTransformer(phase = FirRe
val transformedClass = resolveSupertypesOrExpansions(regularClass) as? FirRegularClass ?: regularClass
// resolve supertypes for nested classes
return super.transformRegularClass(transformedClass, data)
return transformElement(transformedClass, data)
}
@@ -53,17 +49,36 @@ class FirSupertypeResolverTransformer : FirAbstractTreeTransformer(phase = FirRe
}
// This and transformProperty functions are required to forbid supertype resolving for local classes
override fun transformDeclarationWithBody(
declarationWithBody: FirDeclarationWithBody,
// override fun transformDeclarationWithBody(
// declarationWithBody: FirDeclarationWithBody,
// data: Nothing?
// ): CompositeTransformResult<FirDeclaration> {
// return declarationWithBody.compose()
// }
override fun transformAnonymousInitializer(
anonymousInitializer: FirAnonymousInitializer,
data: Nothing?
): CompositeTransformResult<FirDeclaration> {
return declarationWithBody.compose()
return anonymousInitializer.compose()
}
override fun transformConstructor(constructor: FirConstructor, data: Nothing?): CompositeTransformResult<FirDeclaration> {
return constructor.compose()
}
override fun transformNamedFunction(namedFunction: FirNamedFunction, data: Nothing?): CompositeTransformResult<FirDeclaration> {
return namedFunction.compose()
}
override fun transformProperty(property: FirProperty, data: Nothing?): CompositeTransformResult<FirDeclaration> {
return property.compose()
}
override fun <F : FirFunction<F>> transformFunction(function: FirFunction<F>, data: Nothing?): CompositeTransformResult<FirDeclaration> {
return function.compose()
}
private fun resolveSupertypesOrExpansions(classLikeDeclaration: FirClassLikeDeclaration<*>): FirDeclaration {
if (classLikeDeclaration.areSupertypesComputed() || classLikeDeclaration.areSupertypesComputing()) {
return classLikeDeclaration
@@ -114,6 +129,10 @@ class FirSupertypeResolverTransformer : FirAbstractTreeTransformer(phase = FirRe
return resolveNestedClassesSupertypes(transformedClass, data)
}
override fun transformEnumEntry(enumEntry: FirEnumEntry, data: Nothing?): CompositeTransformResult<FirDeclaration> {
return transformRegularClass(enumEntry, data)
}
private fun FirClassLikeDeclaration<*>.matchesRequestedDeclaration(): Boolean {
if (knownFirClassLikeDeclaration != null) return knownFirClassLikeDeclaration == this
return symbol.classId == requestedClassId
@@ -209,7 +228,7 @@ class FirSupertypeResolverTransformer : FirAbstractTreeTransformer(phase = FirRe
towerScope.scopes += FirNestedClassifierScope(classId, firProvider)
regularClass.addTypeParametersScope()
super.transformRegularClass(regularClass, data)
transformElement(regularClass, data)
}
}
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeResolveTransformer.kt
+48 -9
View File
@@ -13,7 +13,8 @@ import org.jetbrains.kotlin.fir.resolve.ScopeSession
import org.jetbrains.kotlin.fir.resolve.lookupSuperTypes
import org.jetbrains.kotlin.fir.scopes.FirPosition
import org.jetbrains.kotlin.fir.scopes.addImportingScopes
import org.jetbrains.kotlin.fir.scopes.impl.*
import org.jetbrains.kotlin.fir.scopes.impl.FirNestedClassifierScope
import org.jetbrains.kotlin.fir.scopes.impl.withReplacedConeType
import org.jetbrains.kotlin.fir.types.*
import org.jetbrains.kotlin.fir.types.impl.FirImplicitBuiltinTypeRef
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
@@ -30,7 +31,7 @@ open class FirTypeResolveTransformer : FirAbstractTreeTransformerWithSuperTypes(
val scopeSession = ScopeSession()
return withScopeCleanup {
towerScope.addImportingScopes(file, session, scopeSession)
super.transformFile(file, data)
transformElement(file, data)
}
}
@@ -57,21 +58,21 @@ open class FirTypeResolveTransformer : FirAbstractTreeTransformerWithSuperTypes(
towerScope.scopes += FirNestedClassifierScope(classId, firProvider)
regularClass.addTypeParametersScope()
super.transformRegularClass(regularClass, data)
transformDeclaration(regularClass, data)
}
}
override fun transformConstructor(constructor: FirConstructor, data: Nothing?): CompositeTransformResult<FirDeclaration> {
return withScopeCleanup {
constructor.addTypeParametersScope()
super.transformConstructor(constructor, data)
transformDeclaration(constructor, data)
}
}
override fun transformTypeAlias(typeAlias: FirTypeAlias, data: Nothing?): CompositeTransformResult<FirDeclaration> {
return withScopeCleanup {
typeAlias.addTypeParametersScope()
super.transformTypeAlias(typeAlias, data)
transformDeclaration(typeAlias, data)
}
}
@@ -79,28 +80,66 @@ open class FirTypeResolveTransformer : FirAbstractTreeTransformerWithSuperTypes(
override fun transformProperty(property: FirProperty, data: Nothing?): CompositeTransformResult<FirDeclaration> {
return withScopeCleanup {
property.addTypeParametersScope()
super.transformProperty(property, data)
transformDeclaration(property, data)
}
}
override fun transformNamedFunction(namedFunction: FirNamedFunction, data: Nothing?): CompositeTransformResult<FirDeclaration> {
return withScopeCleanup {
namedFunction.addTypeParametersScope()
super.transformNamedFunction(namedFunction, data)
transformDeclaration(namedFunction, data)
}
}
override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: Nothing?): CompositeTransformResult<FirTypeRef> {
if (implicitTypeRef is FirImplicitBuiltinTypeRef) return super.transformImplicitTypeRef(implicitTypeRef, data)
if (implicitTypeRef is FirImplicitBuiltinTypeRef) return transformTypeRef(implicitTypeRef, data)
return implicitTypeRef.compose()
}
override fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: Nothing?): CompositeTransformResult<FirTypeRef> {
return transformTypeRef(resolvedTypeRef, data)
}
override fun transformErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: Nothing?): CompositeTransformResult<FirTypeRef> {
return transformTypeRef(errorTypeRef, data)
}
override fun transformResolvedFunctionTypeRef(
resolvedFunctionTypeRef: FirResolvedFunctionTypeRef,
data: Nothing?
): CompositeTransformResult<FirTypeRef> {
return transformTypeRef(resolvedFunctionTypeRef, data)
}
override fun transformTypeRefWithNullability(
typeRefWithNullability: FirTypeRefWithNullability,
data: Nothing?
): CompositeTransformResult<FirTypeRef> {
return transformTypeRef(typeRefWithNullability, data)
}
override fun transformUserTypeRef(userTypeRef: FirUserTypeRef, data: Nothing?): CompositeTransformResult<FirTypeRef> {
return transformTypeRef(userTypeRef, data)
}
override fun transformDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: Nothing?): CompositeTransformResult<FirTypeRef> {
return transformTypeRef(dynamicTypeRef, data)
}
override fun transformFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: Nothing?): CompositeTransformResult<FirTypeRef> {
return transformTypeRef(functionTypeRef, data)
}
override fun transformDelegatedTypeRef(delegatedTypeRef: FirDelegatedTypeRef, data: Nothing?): CompositeTransformResult<FirTypeRef> {
return transformTypeRef(delegatedTypeRef, data)
}
override fun transformTypeRef(typeRef: FirTypeRef, data: Nothing?): CompositeTransformResult<FirTypeRef> {
return FirSpecificTypeResolverTransformer(towerScope, FirPosition.OTHER, session).transformTypeRef(typeRef, data)
}
override fun transformValueParameter(valueParameter: FirValueParameter, data: Nothing?): CompositeTransformResult<FirDeclaration> {
val result = super.transformValueParameter(valueParameter, data).single as FirValueParameter
val result = transformDeclaration(valueParameter, data).single as FirValueParameter
if (result.isVararg) {
val returnTypeRef = result.returnTypeRef
val returnType = returnTypeRef.coneTypeUnsafe<ConeKotlinType>()
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeTransformer.kt
+60
View File
@@ -0,0 +1,60 @@
/*
* Copyright 2010-2019 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.resolve.transformers
import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.types.*
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
import org.jetbrains.kotlin.fir.visitors.FirTransformer
import org.jetbrains.kotlin.fir.visitors.compose
abstract class FirTypeTransformer<D> : FirTransformer<D>() {
override fun <E : FirElement> transformElement(element: E, data: D): CompositeTransformResult<E> {
return element.compose()
}
override fun transformTypeRef(typeRef: FirTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
return transformElement(typeRef, data)
}
override fun transformDelegatedTypeRef(delegatedTypeRef: FirDelegatedTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
return transformTypeRef(delegatedTypeRef, data)
}
override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
return transformTypeRef(implicitTypeRef, data)
}
override fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
return transformTypeRef(resolvedTypeRef, data)
}
override fun transformErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
return transformResolvedTypeRef(errorTypeRef, data)
}
override fun transformResolvedFunctionTypeRef(resolvedFunctionTypeRef: FirResolvedFunctionTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
return transformResolvedTypeRef(resolvedFunctionTypeRef, data)
}
override fun transformTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability, data: D): CompositeTransformResult<FirTypeRef> {
return transformTypeRef(typeRefWithNullability, data)
}
override fun transformDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
return transformTypeRefWithNullability(dynamicTypeRef, data)
}
override fun transformFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
return transformTypeRefWithNullability(functionTypeRef, data)
}
override fun transformUserTypeRef(userTypeRef: FirUserTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
return transformTypeRefWithNullability(userTypeRef, data)
}
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/TransformUtils.kt
+23 -15
View File
@@ -10,7 +10,6 @@ import org.jetbrains.kotlin.fir.FirNamedReference
import org.jetbrains.kotlin.fir.FirResolvedCallableReference
import org.jetbrains.kotlin.fir.expressions.*
import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
import org.jetbrains.kotlin.fir.resolve.calls.Candidate
import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
import org.jetbrains.kotlin.fir.types.FirTypeRef
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
@@ -35,23 +34,36 @@ internal object MapArguments : FirTransformer<Map<FirElement, FirElement>>() {
): CompositeTransformResult<FirStatement> {
return (wrappedArgumentExpression.transformChildren(this, data) as FirStatement).compose()
}
}
internal object StoreType : FirTransformer<FirTypeRef>() {
override fun <E : FirElement> transformElement(element: E, data: FirTypeRef): CompositeTransformResult<E> {
return element.compose()
override fun transformLambdaArgumentExpression(
lambdaArgumentExpression: FirLambdaArgumentExpression,
data: Map<FirElement, FirElement>
): CompositeTransformResult<FirStatement> {
return transformWrappedArgumentExpression(lambdaArgumentExpression, data)
}
override fun transformSpreadArgumentExpression(
spreadArgumentExpression: FirSpreadArgumentExpression,
data: Map<FirElement, FirElement>
): CompositeTransformResult<FirStatement> {
return transformWrappedArgumentExpression(spreadArgumentExpression, data)
}
override fun transformNamedArgumentExpression(
namedArgumentExpression: FirNamedArgumentExpression,
data: Map<FirElement, FirElement>
): CompositeTransformResult<FirStatement> {
return transformWrappedArgumentExpression(namedArgumentExpression, data)
}
}
internal object StoreType : FirTypeTransformer<FirTypeRef>() {
override fun transformTypeRef(typeRef: FirTypeRef, data: FirTypeRef): CompositeTransformResult<FirTypeRef> {
return data.compose()
}
}
internal object TransformImplicitType : FirTransformer<FirTypeRef>() {
override fun <E : FirElement> transformElement(element: E, data: FirTypeRef): CompositeTransformResult<E> {
return element.compose()
}
internal object TransformImplicitType : FirTypeTransformer<FirTypeRef>() {
override fun transformImplicitTypeRef(
implicitTypeRef: FirImplicitTypeRef,
data: FirTypeRef
@@ -61,11 +73,7 @@ internal object TransformImplicitType : FirTransformer<FirTypeRef>() {
}
internal object StoreNameReference : FirTransformer<FirNamedReference>() {
override fun <E : FirElement> transformElement(element: E, data: FirNamedReference): CompositeTransformResult<E> {
return element.compose()
}
internal object StoreNameReference : FirTypeTransformer<FirNamedReference>() {
override fun transformNamedReference(
namedReference: FirNamedReference,
data: FirNamedReference
compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/AbstractFirCfgBuildingTest.kt
+1 -1
View File
@@ -69,7 +69,7 @@ abstract class AbstractFirCfgBuildingTest : AbstractFirResolveTestCase() {
.appendln("${INDENT}node [shape=box penwidth=2]")
.appendln("${INDENT}edge [penwidth=2]")
.appendln()
super.visitFile(file)
visitElement(file)
dotBuilder.appendln("}")
}
compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirResolveBench.kt
+40 -2
View File
@@ -8,6 +8,8 @@ import com.intellij.openapi.fileEditor.FileDocumentManager
import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.builder.RawFirBuilder
import org.jetbrains.kotlin.fir.declarations.FirFile
import org.jetbrains.kotlin.fir.expressions.FirCallableReferenceAccess
import org.jetbrains.kotlin.fir.expressions.FirComponentCall
import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
import org.jetbrains.kotlin.fir.resolve.FirProvider
@@ -197,7 +199,11 @@ class FirResolveBench(val withProgress: Boolean) {
}
}
super.visitFunctionCall(functionCall)
visitElement(functionCall)
}
override fun visitComponentCall(componentCall: FirComponentCall) {
visitFunctionCall(componentCall)
}
override fun visitQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression) {
@@ -209,7 +215,11 @@ class FirResolveBench(val withProgress: Boolean) {
}
}
super.visitQualifiedAccessExpression(qualifiedAccessExpression)
visitElement(qualifiedAccessExpression)
}
override fun visitCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess) {
visitQualifiedAccessExpression(callableReferenceAccess)
}
override fun visitTypeRef(typeRef: FirTypeRef) {
@@ -222,6 +232,34 @@ class FirResolveBench(val withProgress: Boolean) {
}
}
override fun visitDelegatedTypeRef(delegatedTypeRef: FirDelegatedTypeRef) {
visitTypeRef(delegatedTypeRef)
}
override fun visitErrorTypeRef(errorTypeRef: FirErrorTypeRef) {
visitResolvedTypeRef(errorTypeRef)
}
override fun visitResolvedFunctionTypeRef(resolvedFunctionTypeRef: FirResolvedFunctionTypeRef) {
visitResolvedTypeRef(resolvedFunctionTypeRef)
}
override fun visitTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability) {
visitTypeRef(typeRefWithNullability)
}
override fun visitDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef) {
visitTypeRefWithNullability(dynamicTypeRef)
}
override fun visitFunctionTypeRef(functionTypeRef: FirFunctionTypeRef) {
visitTypeRefWithNullability(functionTypeRef)
}
override fun visitUserTypeRef(userTypeRef: FirUserTypeRef) {
visitTypeRefWithNullability(userTypeRef)
}
override fun visitImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef) {
if (implicitTypeRef is FirResolvedTypeRef) {
visitResolvedTypeRef(implicitTypeRef)
compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt
+1 -1
View File
@@ -72,7 +72,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
override fun visitFile(file: FirFile) {
println("FILE: ${file.name}")
pushIndent()
super.visitFile(file)
visitElement(file)
popIndent()
}
compiler/fir/tree/visitors-generator/src/ParametricTransformerGenerator.kt
+2 -2
View File
@@ -90,7 +90,7 @@ class ParametricTransformerGenerator(data: DataCollector.ReferencesData) : Abstr
typeParametersWithBounds = listOf("E : $parent") + className.typeParametersWithBounds()
) {
print("return ")
generateCall("transform${parent.name.classNameWithoutFir}", listOf(parameterName, "data"))
generateCall("transformElement", listOf(parameterName, "data"))
printlnWithNoIndent()
}
} else {
@@ -104,7 +104,7 @@ class ParametricTransformerGenerator(data: DataCollector.ReferencesData) : Abstr
typeParametersWithBounds = className.typeParametersWithBounds()
) {
print("return ")
generateCall("transform${parent.name.classNameWithoutFir}", listOf(parameterName, "data"))
generateCall("transformElement", listOf(parameterName, "data"))
printlnWithNoIndent()
}
}
compiler/fir/tree/visitors-generator/src/SimpleVisitorGenerator.kt
+1 -1
View File
@@ -46,7 +46,7 @@ class SimpleVisitorGenerator(referencesData: DataCollector.ReferencesData) : Abs
typeParametersWithBounds = className.typeParametersWithBounds()
) {
print("return ")
generateCall("visit${parent.name.classNameWithoutFir}", listOf(parameterName, "data"))
generateCall("visitElement", listOf(parameterName, "data"))
println()
}
}
compiler/fir/tree/visitors-generator/src/UnitVisitorGenerator.kt
+1 -1
View File
@@ -49,7 +49,7 @@ class UnitVisitorGenerator(referencesData: DataCollector.ReferencesData) : Abstr
typeParametersWithBounds = className.typeParametersWithBounds()
) {
printIndent()
generateCall("visit${parent.name.classNameWithoutFir}", listOf(parameterName, "null"))
generateCall("visitElement", listOf(parameterName, "null"))
println()
}
}
compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirTransformerGenerated.kt
+101 -101
View File
@@ -26,99 +26,99 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
}
open fun <F : FirCallableDeclaration<F>> transformCallableDeclaration(callableDeclaration: FirCallableDeclaration<F>, data: D): CompositeTransformResult<FirDeclaration> {
return transformDeclaration(callableDeclaration, data)
return transformElement(callableDeclaration, data)
}
open fun <F : FirCallableMemberDeclaration<F>> transformCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration<F>, data: D): CompositeTransformResult<FirDeclaration> {
return transformDeclaration(callableMemberDeclaration, data)
return transformElement(callableMemberDeclaration, data)
}
open fun transformDeclarationWithBody(declarationWithBody: FirDeclarationWithBody, data: D): CompositeTransformResult<FirDeclaration> {
return transformDeclaration(declarationWithBody, data)
return transformElement(declarationWithBody, data)
}
open fun transformAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, data: D): CompositeTransformResult<FirDeclaration> {
return transformDeclarationWithBody(anonymousInitializer, data)
return transformElement(anonymousInitializer, data)
}
open fun <F : FirFunction<F>> transformFunction(function: FirFunction<F>, data: D): CompositeTransformResult<FirDeclaration> {
return transformDeclarationWithBody(function, data)
return transformElement(function, data)
}
open fun transformAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: D): CompositeTransformResult<FirDeclaration> {
return transformFunction(anonymousFunction, data)
return transformElement(anonymousFunction, data)
}
open fun <F : FirMemberFunction<F>> transformMemberFunction(memberFunction: FirMemberFunction<F>, data: D): CompositeTransformResult<FirDeclaration> {
return transformFunction(memberFunction, data)
return transformElement(memberFunction, data)
}
open fun transformConstructor(constructor: FirConstructor, data: D): CompositeTransformResult<FirDeclaration> {
return transformMemberFunction(constructor, data)
return transformElement(constructor, data)
}
open fun transformNamedFunction(namedFunction: FirNamedFunction, data: D): CompositeTransformResult<FirDeclaration> {
return transformMemberFunction(namedFunction, data)
return transformElement(namedFunction, data)
}
open fun <F : FirFunction<F>> transformModifiableFunction(modifiableFunction: FirModifiableFunction<F>, data: D): CompositeTransformResult<FirDeclaration> {
return transformFunction(modifiableFunction, data)
return transformElement(modifiableFunction, data)
}
open fun transformPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: D): CompositeTransformResult<FirDeclaration> {
return transformFunction(propertyAccessor, data)
return transformElement(propertyAccessor, data)
}
open fun transformErrorDeclaration(errorDeclaration: FirErrorDeclaration, data: D): CompositeTransformResult<FirDeclaration> {
return transformDeclaration(errorDeclaration, data)
return transformElement(errorDeclaration, data)
}
open fun transformField(field: FirField, data: D): CompositeTransformResult<FirDeclaration> {
return transformDeclaration(field, data)
return transformElement(field, data)
}
open fun transformNamedDeclaration(namedDeclaration: FirNamedDeclaration, data: D): CompositeTransformResult<FirDeclaration> {
return transformDeclaration(namedDeclaration, data)
return transformElement(namedDeclaration, data)
}
open fun transformMemberDeclaration(memberDeclaration: FirMemberDeclaration, data: D): CompositeTransformResult<FirDeclaration> {
return transformNamedDeclaration(memberDeclaration, data)
return transformElement(memberDeclaration, data)
}
open fun <F : FirClassLikeDeclaration<F>> transformClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration<F>, data: D): CompositeTransformResult<FirDeclaration> {
return transformMemberDeclaration(classLikeDeclaration, data)
return transformElement(classLikeDeclaration, data)
}
open fun transformRegularClass(regularClass: FirRegularClass, data: D): CompositeTransformResult<FirDeclaration> {
return transformClassLikeDeclaration(regularClass, data)
return transformElement(regularClass, data)
}
open fun transformEnumEntry(enumEntry: FirEnumEntry, data: D): CompositeTransformResult<FirDeclaration> {
return transformRegularClass(enumEntry, data)
return transformElement(enumEntry, data)
}
open fun transformTypeAlias(typeAlias: FirTypeAlias, data: D): CompositeTransformResult<FirDeclaration> {
return transformClassLikeDeclaration(typeAlias, data)
return transformElement(typeAlias, data)
}
open fun transformTypeParameter(typeParameter: FirTypeParameter, data: D): CompositeTransformResult<FirDeclaration> {
return transformNamedDeclaration(typeParameter, data)
return transformElement(typeParameter, data)
}
open fun transformProperty(property: FirProperty, data: D): CompositeTransformResult<FirDeclaration> {
return transformDeclaration(property, data)
return transformElement(property, data)
}
open fun transformTypedDeclaration(typedDeclaration: FirTypedDeclaration, data: D): CompositeTransformResult<FirDeclaration> {
return transformDeclaration(typedDeclaration, data)
return transformElement(typedDeclaration, data)
}
open fun transformValueParameter(valueParameter: FirValueParameter, data: D): CompositeTransformResult<FirDeclaration> {
return transformDeclaration(valueParameter, data)
return transformElement(valueParameter, data)
}
open fun <F : FirVariable<F>> transformVariable(variable: FirVariable<F>, data: D): CompositeTransformResult<FirDeclaration> {
return transformDeclaration(variable, data)
return transformElement(variable, data)
}
open fun transformDeclarationStatus(declarationStatus: FirDeclarationStatus, data: D): CompositeTransformResult<FirDeclarationStatus> {
@@ -126,7 +126,7 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
}
open fun transformResolvedDeclarationStatus(resolvedDeclarationStatus: FirResolvedDeclarationStatus, data: D): CompositeTransformResult<FirDeclarationStatus> {
return transformDeclarationStatus(resolvedDeclarationStatus, data)
return transformElement(resolvedDeclarationStatus, data)
}
open fun transformImport(import: FirImport, data: D): CompositeTransformResult<FirImport> {
@@ -134,7 +134,7 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
}
open fun transformResolvedImport(resolvedImport: FirResolvedImport, data: D): CompositeTransformResult<FirImport> {
return transformImport(resolvedImport, data)
return transformElement(resolvedImport, data)
}
open fun <E : FirElement> transformLabel(label: E, data: D): CompositeTransformResult<E> {
@@ -146,7 +146,7 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
}
open fun transformFile(file: FirFile, data: D): CompositeTransformResult<FirFile> {
return transformPackageFragment(file, data)
return transformElement(file, data)
}
open fun <E : FirElement> transformReference(reference: E, data: D): CompositeTransformResult<E> {
@@ -154,31 +154,31 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
}
open fun transformControlFlowGraphReference(controlFlowGraphReference: FirControlFlowGraphReference, data: D): CompositeTransformResult<FirControlFlowGraphReference> {
return transformReference(controlFlowGraphReference, data)
return transformElement(controlFlowGraphReference, data)
}
open fun transformNamedReference(namedReference: FirNamedReference, data: D): CompositeTransformResult<FirNamedReference> {
return transformReference(namedReference, data)
return transformElement(namedReference, data)
}
open fun transformResolvedCallableReference(resolvedCallableReference: FirResolvedCallableReference, data: D): CompositeTransformResult<FirNamedReference> {
return transformNamedReference(resolvedCallableReference, data)
return transformElement(resolvedCallableReference, data)
}
open fun transformBackingFieldReference(backingFieldReference: FirBackingFieldReference, data: D): CompositeTransformResult<FirNamedReference> {
return transformResolvedCallableReference(backingFieldReference, data)
return transformElement(backingFieldReference, data)
}
open fun transformDelegateFieldReference(delegateFieldReference: FirDelegateFieldReference, data: D): CompositeTransformResult<FirNamedReference> {
return transformResolvedCallableReference(delegateFieldReference, data)
return transformElement(delegateFieldReference, data)
}
open fun <E : FirReference> transformSuperReference(superReference: E, data: D): CompositeTransformResult<E> {
return transformReference(superReference, data)
return transformElement(superReference, data)
}
open fun <E : FirReference> transformThisReference(thisReference: E, data: D): CompositeTransformResult<E> {
return transformReference(thisReference, data)
return transformElement(thisReference, data)
}
open fun transformStatement(statement: FirStatement, data: D): CompositeTransformResult<FirStatement> {
@@ -186,223 +186,223 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
}
open fun transformAnnotatedStatement(annotatedStatement: FirAnnotatedStatement, data: D): CompositeTransformResult<FirStatement> {
return transformStatement(annotatedStatement, data)
return transformElement(annotatedStatement, data)
}
open fun transformExpression(expression: FirExpression, data: D): CompositeTransformResult<FirStatement> {
return transformAnnotatedStatement(expression, data)
return transformElement(expression, data)
}
open fun transformCall(call: FirCall, data: D): CompositeTransformResult<FirStatement> {
return transformExpression(call, data)
return transformElement(call, data)
}
open fun transformArraySetCall(arraySetCall: FirArraySetCall, data: D): CompositeTransformResult<FirStatement> {
return transformCall(arraySetCall, data)
return transformElement(arraySetCall, data)
}
open fun transformCallWithArgumentList(callWithArgumentList: FirCallWithArgumentList, data: D): CompositeTransformResult<FirStatement> {
return transformCall(callWithArgumentList, data)
return transformElement(callWithArgumentList, data)
}
open fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: D): CompositeTransformResult<FirStatement> {
return transformCallWithArgumentList(annotationCall, data)
return transformElement(annotationCall, data)
}
open fun transformDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall, data: D): CompositeTransformResult<FirStatement> {
return transformCallWithArgumentList(delegatedConstructorCall, data)
return transformElement(delegatedConstructorCall, data)
}
open fun transformOperatorCall(operatorCall: FirOperatorCall, data: D): CompositeTransformResult<FirStatement> {
return transformCallWithArgumentList(operatorCall, data)
return transformElement(operatorCall, data)
}
open fun transformOperationBasedCall(operationBasedCall: FirOperationBasedCall, data: D): CompositeTransformResult<FirStatement> {
return transformOperatorCall(operationBasedCall, data)
return transformElement(operationBasedCall, data)
}
open fun transformTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: D): CompositeTransformResult<FirStatement> {
return transformOperationBasedCall(typeOperatorCall, data)
return transformElement(typeOperatorCall, data)
}
open fun transformStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall, data: D): CompositeTransformResult<FirStatement> {
return transformCallWithArgumentList(stringConcatenationCall, data)
return transformElement(stringConcatenationCall, data)
}
open fun transformUnknownTypeCallWithArgumentList(unknownTypeCallWithArgumentList: FirUnknownTypeCallWithArgumentList, data: D): CompositeTransformResult<FirStatement> {
return transformCallWithArgumentList(unknownTypeCallWithArgumentList, data)
return transformElement(unknownTypeCallWithArgumentList, data)
}
open fun transformArrayOfCall(arrayOfCall: FirArrayOfCall, data: D): CompositeTransformResult<FirStatement> {
return transformUnknownTypeCallWithArgumentList(arrayOfCall, data)
return transformElement(arrayOfCall, data)
}
open fun transformFunctionCall(functionCall: FirFunctionCall, data: D): CompositeTransformResult<FirStatement> {
return transformUnknownTypeCallWithArgumentList(functionCall, data)
return transformElement(functionCall, data)
}
open fun transformComponentCall(componentCall: FirComponentCall, data: D): CompositeTransformResult<FirStatement> {
return transformFunctionCall(componentCall, data)
return transformElement(componentCall, data)
}
open fun transformGetClassCall(getClassCall: FirGetClassCall, data: D): CompositeTransformResult<FirStatement> {
return transformUnknownTypeCallWithArgumentList(getClassCall, data)
return transformElement(getClassCall, data)
}
open fun transformUncheckedNotNullCast(uncheckedNotNullCast: FirUncheckedNotNullCast, data: D): CompositeTransformResult<FirStatement> {
return transformUnknownTypeCallWithArgumentList(uncheckedNotNullCast, data)
return transformElement(uncheckedNotNullCast, data)
}
open fun <E : FirTargetElement> transformJump(jump: FirJump<E>, data: D): CompositeTransformResult<FirStatement> {
return transformExpression(jump, data)
return transformElement(jump, data)
}
open fun transformLoopJump(loopJump: FirLoopJump, data: D): CompositeTransformResult<FirStatement> {
return transformJump(loopJump, data)
return transformElement(loopJump, data)
}
open fun transformBreakExpression(breakExpression: FirBreakExpression, data: D): CompositeTransformResult<FirStatement> {
return transformLoopJump(breakExpression, data)
return transformElement(breakExpression, data)
}
open fun transformContinueExpression(continueExpression: FirContinueExpression, data: D): CompositeTransformResult<FirStatement> {
return transformLoopJump(continueExpression, data)
return transformElement(continueExpression, data)
}
open fun transformReturnExpression(returnExpression: FirReturnExpression, data: D): CompositeTransformResult<FirStatement> {
return transformJump(returnExpression, data)
return transformElement(returnExpression, data)
}
open fun transformThrowExpression(throwExpression: FirThrowExpression, data: D): CompositeTransformResult<FirStatement> {
return transformExpression(throwExpression, data)
return transformElement(throwExpression, data)
}
open fun transformUnknownTypeExpression(unknownTypeExpression: FirUnknownTypeExpression, data: D): CompositeTransformResult<FirStatement> {
return transformExpression(unknownTypeExpression, data)
return transformElement(unknownTypeExpression, data)
}
open fun transformBinaryLogicExpression(binaryLogicExpression: FirBinaryLogicExpression, data: D): CompositeTransformResult<FirStatement> {
return transformUnknownTypeExpression(binaryLogicExpression, data)
return transformElement(binaryLogicExpression, data)
}
open fun transformBlock(block: FirBlock, data: D): CompositeTransformResult<FirStatement> {
return transformUnknownTypeExpression(block, data)
return transformElement(block, data)
}
open fun transformCallLikeControlFlowExpression(callLikeControlFlowExpression: FirCallLikeControlFlowExpression, data: D): CompositeTransformResult<FirStatement> {
return transformUnknownTypeExpression(callLikeControlFlowExpression, data)
return transformElement(callLikeControlFlowExpression, data)
}
open fun transformTryExpression(tryExpression: FirTryExpression, data: D): CompositeTransformResult<FirStatement> {
return transformCallLikeControlFlowExpression(tryExpression, data)
return transformElement(tryExpression, data)
}
open fun transformWhenExpression(whenExpression: FirWhenExpression, data: D): CompositeTransformResult<FirStatement> {
return transformCallLikeControlFlowExpression(whenExpression, data)
return transformElement(whenExpression, data)
}
open fun transformClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression, data: D): CompositeTransformResult<FirStatement> {
return transformUnknownTypeExpression(classReferenceExpression, data)
return transformElement(classReferenceExpression, data)
}
open fun <T> transformConstExpression(constExpression: FirConstExpression<T>, data: D): CompositeTransformResult<FirStatement> {
return transformUnknownTypeExpression(constExpression, data)
return transformElement(constExpression, data)
}
open fun transformErrorExpression(errorExpression: FirErrorExpression, data: D): CompositeTransformResult<FirStatement> {
return transformUnknownTypeExpression(errorExpression, data)
return transformElement(errorExpression, data)
}
open fun transformQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression, data: D): CompositeTransformResult<FirStatement> {
return transformUnknownTypeExpression(qualifiedAccessExpression, data)
return transformElement(qualifiedAccessExpression, data)
}
open fun transformCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess, data: D): CompositeTransformResult<FirStatement> {
return transformQualifiedAccessExpression(callableReferenceAccess, data)
return transformElement(callableReferenceAccess, data)
}
open fun transformExpressionWithSmartcast(expressionWithSmartcast: FirExpressionWithSmartcast, data: D): CompositeTransformResult<FirStatement> {
return transformQualifiedAccessExpression(expressionWithSmartcast, data)
return transformElement(expressionWithSmartcast, data)
}
open fun transformResolvedQualifier(resolvedQualifier: FirResolvedQualifier, data: D): CompositeTransformResult<FirStatement> {
return transformUnknownTypeExpression(resolvedQualifier, data)
return transformElement(resolvedQualifier, data)
}
open fun transformWhenSubjectExpression(whenSubjectExpression: FirWhenSubjectExpression, data: D): CompositeTransformResult<FirStatement> {
return transformUnknownTypeExpression(whenSubjectExpression, data)
return transformElement(whenSubjectExpression, data)
}
open fun transformWrappedExpression(wrappedExpression: FirWrappedExpression, data: D): CompositeTransformResult<FirStatement> {
return transformExpression(wrappedExpression, data)
return transformElement(wrappedExpression, data)
}
open fun transformWrappedArgumentExpression(wrappedArgumentExpression: FirWrappedArgumentExpression, data: D): CompositeTransformResult<FirStatement> {
return transformWrappedExpression(wrappedArgumentExpression, data)
return transformElement(wrappedArgumentExpression, data)
}
open fun transformLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression, data: D): CompositeTransformResult<FirStatement> {
return transformWrappedArgumentExpression(lambdaArgumentExpression, data)
return transformElement(lambdaArgumentExpression, data)
}
open fun transformNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression, data: D): CompositeTransformResult<FirStatement> {
return transformWrappedArgumentExpression(namedArgumentExpression, data)
return transformElement(namedArgumentExpression, data)
}
open fun transformSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression, data: D): CompositeTransformResult<FirStatement> {
return transformWrappedArgumentExpression(spreadArgumentExpression, data)
return transformElement(spreadArgumentExpression, data)
}
open fun transformWrappedDelegateExpression(wrappedDelegateExpression: FirWrappedDelegateExpression, data: D): CompositeTransformResult<FirStatement> {
return transformWrappedExpression(wrappedDelegateExpression, data)
return transformElement(wrappedDelegateExpression, data)
}
open fun transformClass(klass: FirClass, data: D): CompositeTransformResult<FirStatement> {
return transformStatement(klass, data)
return transformElement(klass, data)
}
open fun transformAnonymousObject(anonymousObject: FirAnonymousObject, data: D): CompositeTransformResult<FirStatement> {
return transformClass(anonymousObject, data)
return transformElement(anonymousObject, data)
}
open fun transformModifiableClass(modifiableClass: FirModifiableClass, data: D): CompositeTransformResult<FirStatement> {
return transformClass(modifiableClass, data)
return transformElement(modifiableClass, data)
}
open fun transformErrorStatement(errorStatement: FirErrorStatement, data: D): CompositeTransformResult<FirStatement> {
return transformStatement(errorStatement, data)
return transformElement(errorStatement, data)
}
open fun transformLoop(loop: FirLoop, data: D): CompositeTransformResult<FirStatement> {
return transformStatement(loop, data)
return transformElement(loop, data)
}
open fun transformDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: D): CompositeTransformResult<FirStatement> {
return transformLoop(doWhileLoop, data)
return transformElement(doWhileLoop, data)
}
open fun transformWhileLoop(whileLoop: FirWhileLoop, data: D): CompositeTransformResult<FirStatement> {
return transformLoop(whileLoop, data)
return transformElement(whileLoop, data)
}
open fun transformResolvable(resolvable: FirResolvable, data: D): CompositeTransformResult<FirStatement> {
return transformStatement(resolvable, data)
return transformElement(resolvable, data)
}
open fun transformQualifiedAccess(qualifiedAccess: FirQualifiedAccess, data: D): CompositeTransformResult<FirStatement> {
return transformResolvable(qualifiedAccess, data)
return transformElement(qualifiedAccess, data)
}
open fun transformAssignment(assignment: FirAssignment, data: D): CompositeTransformResult<FirStatement> {
return transformQualifiedAccess(assignment, data)
return transformElement(assignment, data)
}
open fun transformVariableAssignment(variableAssignment: FirVariableAssignment, data: D): CompositeTransformResult<FirStatement> {
return transformAssignment(variableAssignment, data)
return transformElement(variableAssignment, data)
}
open fun <C : FirReference> transformModifiableQualifiedAccess(modifiableQualifiedAccess: FirModifiableQualifiedAccess<C>, data: D): CompositeTransformResult<FirStatement> {
return transformQualifiedAccess(modifiableQualifiedAccess, data)
return transformElement(modifiableQualifiedAccess, data)
}
open fun <E : FirElement> transformTargetElement(targetElement: E, data: D): CompositeTransformResult<E> {
@@ -410,7 +410,7 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
}
open fun <E : FirTargetElement> transformLabeledElement(labeledElement: E, data: D): CompositeTransformResult<E> {
return transformTargetElement(labeledElement, data)
return transformElement(labeledElement, data)
}
open fun transformTypeProjection(typeProjection: FirTypeProjection, data: D): CompositeTransformResult<FirTypeProjection> {
@@ -418,11 +418,11 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
}
open fun transformStarProjection(starProjection: FirStarProjection, data: D): CompositeTransformResult<FirTypeProjection> {
return transformTypeProjection(starProjection, data)
return transformElement(starProjection, data)
}
open fun transformTypeProjectionWithVariance(typeProjectionWithVariance: FirTypeProjectionWithVariance, data: D): CompositeTransformResult<FirTypeProjection> {
return transformTypeProjection(typeProjectionWithVariance, data)
return transformElement(typeProjectionWithVariance, data)
}
open fun transformTypeRef(typeRef: FirTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
@@ -430,39 +430,39 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
}
open fun transformDelegatedTypeRef(delegatedTypeRef: FirDelegatedTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
return transformTypeRef(delegatedTypeRef, data)
return transformElement(delegatedTypeRef, data)
}
open fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
return transformTypeRef(implicitTypeRef, data)
return transformElement(implicitTypeRef, data)
}
open fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
return transformTypeRef(resolvedTypeRef, data)
return transformElement(resolvedTypeRef, data)
}
open fun transformErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
return transformResolvedTypeRef(errorTypeRef, data)
return transformElement(errorTypeRef, data)
}
open fun transformResolvedFunctionTypeRef(resolvedFunctionTypeRef: FirResolvedFunctionTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
return transformResolvedTypeRef(resolvedFunctionTypeRef, data)
return transformElement(resolvedFunctionTypeRef, data)
}
open fun transformTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability, data: D): CompositeTransformResult<FirTypeRef> {
return transformTypeRef(typeRefWithNullability, data)
return transformElement(typeRefWithNullability, data)
}
open fun transformDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
return transformTypeRefWithNullability(dynamicTypeRef, data)
return transformElement(dynamicTypeRef, data)
}
open fun transformFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
return transformTypeRefWithNullability(functionTypeRef, data)
return transformElement(functionTypeRef, data)
}
open fun transformUserTypeRef(userTypeRef: FirUserTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
return transformTypeRefWithNullability(userTypeRef, data)
return transformElement(userTypeRef, data)
}
open fun transformWhenBranch(whenBranch: FirWhenBranch, data: D): CompositeTransformResult<FirWhenBranch> {
compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorGenerated.kt
+101 -101
View File
@@ -26,99 +26,99 @@ abstract class FirVisitor<out R, in D> {
}
open fun <F : FirCallableDeclaration<F>> visitCallableDeclaration(callableDeclaration: FirCallableDeclaration<F>, data: D): R {
return visitDeclaration(callableDeclaration, data)
return visitElement(callableDeclaration, data)
}
open fun <F : FirCallableMemberDeclaration<F>> visitCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration<F>, data: D): R {
return visitDeclaration(callableMemberDeclaration, data)
return visitElement(callableMemberDeclaration, data)
}
open fun visitDeclarationWithBody(declarationWithBody: FirDeclarationWithBody, data: D): R {
return visitDeclaration(declarationWithBody, data)
return visitElement(declarationWithBody, data)
}
open fun visitAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, data: D): R {
return visitDeclarationWithBody(anonymousInitializer, data)
return visitElement(anonymousInitializer, data)
}
open fun <F : FirFunction<F>> visitFunction(function: FirFunction<F>, data: D): R {
return visitDeclarationWithBody(function, data)
return visitElement(function, data)
}
open fun visitAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: D): R {
return visitFunction(anonymousFunction, data)
return visitElement(anonymousFunction, data)
}
open fun <F : FirMemberFunction<F>> visitMemberFunction(memberFunction: FirMemberFunction<F>, data: D): R {
return visitFunction(memberFunction, data)
return visitElement(memberFunction, data)
}
open fun visitConstructor(constructor: FirConstructor, data: D): R {
return visitMemberFunction(constructor, data)
return visitElement(constructor, data)
}
open fun visitNamedFunction(namedFunction: FirNamedFunction, data: D): R {
return visitMemberFunction(namedFunction, data)
return visitElement(namedFunction, data)
}
open fun <F : FirFunction<F>> visitModifiableFunction(modifiableFunction: FirModifiableFunction<F>, data: D): R {
return visitFunction(modifiableFunction, data)
return visitElement(modifiableFunction, data)
}
open fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: D): R {
return visitFunction(propertyAccessor, data)
return visitElement(propertyAccessor, data)
}
open fun visitErrorDeclaration(errorDeclaration: FirErrorDeclaration, data: D): R {
return visitDeclaration(errorDeclaration, data)
return visitElement(errorDeclaration, data)
}
open fun visitField(field: FirField, data: D): R {
return visitDeclaration(field, data)
return visitElement(field, data)
}
open fun visitNamedDeclaration(namedDeclaration: FirNamedDeclaration, data: D): R {
return visitDeclaration(namedDeclaration, data)
return visitElement(namedDeclaration, data)
}
open fun visitMemberDeclaration(memberDeclaration: FirMemberDeclaration, data: D): R {
return visitNamedDeclaration(memberDeclaration, data)
return visitElement(memberDeclaration, data)
}
open fun <F : FirClassLikeDeclaration<F>> visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration<F>, data: D): R {
return visitMemberDeclaration(classLikeDeclaration, data)
return visitElement(classLikeDeclaration, data)
}
open fun visitRegularClass(regularClass: FirRegularClass, data: D): R {
return visitClassLikeDeclaration(regularClass, data)
return visitElement(regularClass, data)
}
open fun visitEnumEntry(enumEntry: FirEnumEntry, data: D): R {
return visitRegularClass(enumEntry, data)
return visitElement(enumEntry, data)
}
open fun visitTypeAlias(typeAlias: FirTypeAlias, data: D): R {
return visitClassLikeDeclaration(typeAlias, data)
return visitElement(typeAlias, data)
}
open fun visitTypeParameter(typeParameter: FirTypeParameter, data: D): R {
return visitNamedDeclaration(typeParameter, data)
return visitElement(typeParameter, data)
}
open fun visitProperty(property: FirProperty, data: D): R {
return visitDeclaration(property, data)
return visitElement(property, data)
}
open fun visitTypedDeclaration(typedDeclaration: FirTypedDeclaration, data: D): R {
return visitDeclaration(typedDeclaration, data)
return visitElement(typedDeclaration, data)
}
open fun visitValueParameter(valueParameter: FirValueParameter, data: D): R {
return visitDeclaration(valueParameter, data)
return visitElement(valueParameter, data)
}
open fun <F : FirVariable<F>> visitVariable(variable: FirVariable<F>, data: D): R {
return visitDeclaration(variable, data)
return visitElement(variable, data)
}
open fun visitDeclarationStatus(declarationStatus: FirDeclarationStatus, data: D): R {
@@ -126,7 +126,7 @@ abstract class FirVisitor<out R, in D> {
}
open fun visitResolvedDeclarationStatus(resolvedDeclarationStatus: FirResolvedDeclarationStatus, data: D): R {
return visitDeclarationStatus(resolvedDeclarationStatus, data)
return visitElement(resolvedDeclarationStatus, data)
}
open fun visitImport(import: FirImport, data: D): R {
@@ -134,7 +134,7 @@ abstract class FirVisitor<out R, in D> {
}
open fun visitResolvedImport(resolvedImport: FirResolvedImport, data: D): R {
return visitImport(resolvedImport, data)
return visitElement(resolvedImport, data)
}
open fun visitLabel(label: FirLabel, data: D): R {
@@ -146,7 +146,7 @@ abstract class FirVisitor<out R, in D> {
}
open fun visitFile(file: FirFile, data: D): R {
return visitPackageFragment(file, data)
return visitElement(file, data)
}
open fun visitReference(reference: FirReference, data: D): R {
@@ -154,31 +154,31 @@ abstract class FirVisitor<out R, in D> {
}
open fun visitControlFlowGraphReference(controlFlowGraphReference: FirControlFlowGraphReference, data: D): R {
return visitReference(controlFlowGraphReference, data)
return visitElement(controlFlowGraphReference, data)
}
open fun visitNamedReference(namedReference: FirNamedReference, data: D): R {
return visitReference(namedReference, data)
return visitElement(namedReference, data)
}
open fun visitResolvedCallableReference(resolvedCallableReference: FirResolvedCallableReference, data: D): R {
return visitNamedReference(resolvedCallableReference, data)
return visitElement(resolvedCallableReference, data)
}
open fun visitBackingFieldReference(backingFieldReference: FirBackingFieldReference, data: D): R {
return visitResolvedCallableReference(backingFieldReference, data)
return visitElement(backingFieldReference, data)
}
open fun visitDelegateFieldReference(delegateFieldReference: FirDelegateFieldReference, data: D): R {
return visitResolvedCallableReference(delegateFieldReference, data)
return visitElement(delegateFieldReference, data)
}
open fun visitSuperReference(superReference: FirSuperReference, data: D): R {
return visitReference(superReference, data)
return visitElement(superReference, data)
}
open fun visitThisReference(thisReference: FirThisReference, data: D): R {
return visitReference(thisReference, data)
return visitElement(thisReference, data)
}
open fun visitStatement(statement: FirStatement, data: D): R {
@@ -186,223 +186,223 @@ abstract class FirVisitor<out R, in D> {
}
open fun visitAnnotatedStatement(annotatedStatement: FirAnnotatedStatement, data: D): R {
return visitStatement(annotatedStatement, data)
return visitElement(annotatedStatement, data)
}
open fun visitExpression(expression: FirExpression, data: D): R {
return visitAnnotatedStatement(expression, data)
return visitElement(expression, data)
}
open fun visitCall(call: FirCall, data: D): R {
return visitExpression(call, data)
return visitElement(call, data)
}
open fun visitArraySetCall(arraySetCall: FirArraySetCall, data: D): R {
return visitCall(arraySetCall, data)
return visitElement(arraySetCall, data)
}
open fun visitCallWithArgumentList(callWithArgumentList: FirCallWithArgumentList, data: D): R {
return visitCall(callWithArgumentList, data)
return visitElement(callWithArgumentList, data)
}
open fun visitAnnotationCall(annotationCall: FirAnnotationCall, data: D): R {
return visitCallWithArgumentList(annotationCall, data)
return visitElement(annotationCall, data)
}
open fun visitDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall, data: D): R {
return visitCallWithArgumentList(delegatedConstructorCall, data)
return visitElement(delegatedConstructorCall, data)
}
open fun visitOperatorCall(operatorCall: FirOperatorCall, data: D): R {
return visitCallWithArgumentList(operatorCall, data)
return visitElement(operatorCall, data)
}
open fun visitOperationBasedCall(operationBasedCall: FirOperationBasedCall, data: D): R {
return visitOperatorCall(operationBasedCall, data)
return visitElement(operationBasedCall, data)
}
open fun visitTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: D): R {
return visitOperationBasedCall(typeOperatorCall, data)
return visitElement(typeOperatorCall, data)
}
open fun visitStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall, data: D): R {
return visitCallWithArgumentList(stringConcatenationCall, data)
return visitElement(stringConcatenationCall, data)
}
open fun visitUnknownTypeCallWithArgumentList(unknownTypeCallWithArgumentList: FirUnknownTypeCallWithArgumentList, data: D): R {
return visitCallWithArgumentList(unknownTypeCallWithArgumentList, data)
return visitElement(unknownTypeCallWithArgumentList, data)
}
open fun visitArrayOfCall(arrayOfCall: FirArrayOfCall, data: D): R {
return visitUnknownTypeCallWithArgumentList(arrayOfCall, data)
return visitElement(arrayOfCall, data)
}
open fun visitFunctionCall(functionCall: FirFunctionCall, data: D): R {
return visitUnknownTypeCallWithArgumentList(functionCall, data)
return visitElement(functionCall, data)
}
open fun visitComponentCall(componentCall: FirComponentCall, data: D): R {
return visitFunctionCall(componentCall, data)
return visitElement(componentCall, data)
}
open fun visitGetClassCall(getClassCall: FirGetClassCall, data: D): R {
return visitUnknownTypeCallWithArgumentList(getClassCall, data)
return visitElement(getClassCall, data)
}
open fun visitUncheckedNotNullCast(uncheckedNotNullCast: FirUncheckedNotNullCast, data: D): R {
return visitUnknownTypeCallWithArgumentList(uncheckedNotNullCast, data)
return visitElement(uncheckedNotNullCast, data)
}
open fun <E : FirTargetElement> visitJump(jump: FirJump<E>, data: D): R {
return visitExpression(jump, data)
return visitElement(jump, data)
}
open fun visitLoopJump(loopJump: FirLoopJump, data: D): R {
return visitJump(loopJump, data)
return visitElement(loopJump, data)
}
open fun visitBreakExpression(breakExpression: FirBreakExpression, data: D): R {
return visitLoopJump(breakExpression, data)
return visitElement(breakExpression, data)
}
open fun visitContinueExpression(continueExpression: FirContinueExpression, data: D): R {
return visitLoopJump(continueExpression, data)
return visitElement(continueExpression, data)
}
open fun visitReturnExpression(returnExpression: FirReturnExpression, data: D): R {
return visitJump(returnExpression, data)
return visitElement(returnExpression, data)
}
open fun visitThrowExpression(throwExpression: FirThrowExpression, data: D): R {
return visitExpression(throwExpression, data)
return visitElement(throwExpression, data)
}
open fun visitUnknownTypeExpression(unknownTypeExpression: FirUnknownTypeExpression, data: D): R {
return visitExpression(unknownTypeExpression, data)
return visitElement(unknownTypeExpression, data)
}
open fun visitBinaryLogicExpression(binaryLogicExpression: FirBinaryLogicExpression, data: D): R {
return visitUnknownTypeExpression(binaryLogicExpression, data)
return visitElement(binaryLogicExpression, data)
}
open fun visitBlock(block: FirBlock, data: D): R {
return visitUnknownTypeExpression(block, data)
return visitElement(block, data)
}
open fun visitCallLikeControlFlowExpression(callLikeControlFlowExpression: FirCallLikeControlFlowExpression, data: D): R {
return visitUnknownTypeExpression(callLikeControlFlowExpression, data)
return visitElement(callLikeControlFlowExpression, data)
}
open fun visitTryExpression(tryExpression: FirTryExpression, data: D): R {
return visitCallLikeControlFlowExpression(tryExpression, data)
return visitElement(tryExpression, data)
}
open fun visitWhenExpression(whenExpression: FirWhenExpression, data: D): R {
return visitCallLikeControlFlowExpression(whenExpression, data)
return visitElement(whenExpression, data)
}
open fun visitClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression, data: D): R {
return visitUnknownTypeExpression(classReferenceExpression, data)
return visitElement(classReferenceExpression, data)
}
open fun <T> visitConstExpression(constExpression: FirConstExpression<T>, data: D): R {
return visitUnknownTypeExpression(constExpression, data)
return visitElement(constExpression, data)
}
open fun visitErrorExpression(errorExpression: FirErrorExpression, data: D): R {
return visitUnknownTypeExpression(errorExpression, data)
return visitElement(errorExpression, data)
}
open fun visitQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression, data: D): R {
return visitUnknownTypeExpression(qualifiedAccessExpression, data)
return visitElement(qualifiedAccessExpression, data)
}
open fun visitCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess, data: D): R {
return visitQualifiedAccessExpression(callableReferenceAccess, data)
return visitElement(callableReferenceAccess, data)
}
open fun visitExpressionWithSmartcast(expressionWithSmartcast: FirExpressionWithSmartcast, data: D): R {
return visitQualifiedAccessExpression(expressionWithSmartcast, data)
return visitElement(expressionWithSmartcast, data)
}
open fun visitResolvedQualifier(resolvedQualifier: FirResolvedQualifier, data: D): R {
return visitUnknownTypeExpression(resolvedQualifier, data)
return visitElement(resolvedQualifier, data)
}
open fun visitWhenSubjectExpression(whenSubjectExpression: FirWhenSubjectExpression, data: D): R {
return visitUnknownTypeExpression(whenSubjectExpression, data)
return visitElement(whenSubjectExpression, data)
}
open fun visitWrappedExpression(wrappedExpression: FirWrappedExpression, data: D): R {
return visitExpression(wrappedExpression, data)
return visitElement(wrappedExpression, data)
}
open fun visitWrappedArgumentExpression(wrappedArgumentExpression: FirWrappedArgumentExpression, data: D): R {
return visitWrappedExpression(wrappedArgumentExpression, data)
return visitElement(wrappedArgumentExpression, data)
}
open fun visitLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression, data: D): R {
return visitWrappedArgumentExpression(lambdaArgumentExpression, data)
return visitElement(lambdaArgumentExpression, data)
}
open fun visitNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression, data: D): R {
return visitWrappedArgumentExpression(namedArgumentExpression, data)
return visitElement(namedArgumentExpression, data)
}
open fun visitSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression, data: D): R {
return visitWrappedArgumentExpression(spreadArgumentExpression, data)
return visitElement(spreadArgumentExpression, data)
}
open fun visitWrappedDelegateExpression(wrappedDelegateExpression: FirWrappedDelegateExpression, data: D): R {
return visitWrappedExpression(wrappedDelegateExpression, data)
return visitElement(wrappedDelegateExpression, data)
}
open fun visitClass(klass: FirClass, data: D): R {
return visitStatement(klass, data)
return visitElement(klass, data)
}
open fun visitAnonymousObject(anonymousObject: FirAnonymousObject, data: D): R {
return visitClass(anonymousObject, data)
return visitElement(anonymousObject, data)
}
open fun visitModifiableClass(modifiableClass: FirModifiableClass, data: D): R {
return visitClass(modifiableClass, data)
return visitElement(modifiableClass, data)
}
open fun visitErrorStatement(errorStatement: FirErrorStatement, data: D): R {
return visitStatement(errorStatement, data)
return visitElement(errorStatement, data)
}
open fun visitLoop(loop: FirLoop, data: D): R {
return visitStatement(loop, data)
return visitElement(loop, data)
}
open fun visitDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: D): R {
return visitLoop(doWhileLoop, data)
return visitElement(doWhileLoop, data)
}
open fun visitWhileLoop(whileLoop: FirWhileLoop, data: D): R {
return visitLoop(whileLoop, data)
return visitElement(whileLoop, data)
}
open fun visitResolvable(resolvable: FirResolvable, data: D): R {
return visitStatement(resolvable, data)
return visitElement(resolvable, data)
}
open fun visitQualifiedAccess(qualifiedAccess: FirQualifiedAccess, data: D): R {
return visitResolvable(qualifiedAccess, data)
return visitElement(qualifiedAccess, data)
}
open fun visitAssignment(assignment: FirAssignment, data: D): R {
return visitQualifiedAccess(assignment, data)
return visitElement(assignment, data)
}
open fun visitVariableAssignment(variableAssignment: FirVariableAssignment, data: D): R {
return visitAssignment(variableAssignment, data)
return visitElement(variableAssignment, data)
}
open fun <C : FirReference> visitModifiableQualifiedAccess(modifiableQualifiedAccess: FirModifiableQualifiedAccess<C>, data: D): R {
return visitQualifiedAccess(modifiableQualifiedAccess, data)
return visitElement(modifiableQualifiedAccess, data)
}
open fun visitTargetElement(targetElement: FirTargetElement, data: D): R {
@@ -410,7 +410,7 @@ abstract class FirVisitor<out R, in D> {
}
open fun visitLabeledElement(labeledElement: FirLabeledElement, data: D): R {
return visitTargetElement(labeledElement, data)
return visitElement(labeledElement, data)
}
open fun visitTypeProjection(typeProjection: FirTypeProjection, data: D): R {
@@ -418,11 +418,11 @@ abstract class FirVisitor<out R, in D> {
}
open fun visitStarProjection(starProjection: FirStarProjection, data: D): R {
return visitTypeProjection(starProjection, data)
return visitElement(starProjection, data)
}
open fun visitTypeProjectionWithVariance(typeProjectionWithVariance: FirTypeProjectionWithVariance, data: D): R {
return visitTypeProjection(typeProjectionWithVariance, data)
return visitElement(typeProjectionWithVariance, data)
}
open fun visitTypeRef(typeRef: FirTypeRef, data: D): R {
@@ -430,39 +430,39 @@ abstract class FirVisitor<out R, in D> {
}
open fun visitDelegatedTypeRef(delegatedTypeRef: FirDelegatedTypeRef, data: D): R {
return visitTypeRef(delegatedTypeRef, data)
return visitElement(delegatedTypeRef, data)
}
open fun visitImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: D): R {
return visitTypeRef(implicitTypeRef, data)
return visitElement(implicitTypeRef, data)
}
open fun visitResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: D): R {
return visitTypeRef(resolvedTypeRef, data)
return visitElement(resolvedTypeRef, data)
}
open fun visitErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: D): R {
return visitResolvedTypeRef(errorTypeRef, data)
return visitElement(errorTypeRef, data)
}
open fun visitResolvedFunctionTypeRef(resolvedFunctionTypeRef: FirResolvedFunctionTypeRef, data: D): R {
return visitResolvedTypeRef(resolvedFunctionTypeRef, data)
return visitElement(resolvedFunctionTypeRef, data)
}
open fun visitTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability, data: D): R {
return visitTypeRef(typeRefWithNullability, data)
return visitElement(typeRefWithNullability, data)
}
open fun visitDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: D): R {
return visitTypeRefWithNullability(dynamicTypeRef, data)
return visitElement(dynamicTypeRef, data)
}
open fun visitFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: D): R {
return visitTypeRefWithNullability(functionTypeRef, data)
return visitElement(functionTypeRef, data)
}
open fun visitUserTypeRef(userTypeRef: FirUserTypeRef, data: D): R {
return visitTypeRefWithNullability(userTypeRef, data)
return visitElement(userTypeRef, data)
}
open fun visitWhenBranch(whenBranch: FirWhenBranch, data: D): R {
compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorVoidGenerated.kt
+101 -101
View File
@@ -26,99 +26,99 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
}
open fun <F : FirCallableDeclaration<F>> visitCallableDeclaration(callableDeclaration: FirCallableDeclaration<F>) {
visitDeclaration(callableDeclaration, null)
visitElement(callableDeclaration, null)
}
open fun <F : FirCallableMemberDeclaration<F>> visitCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration<F>) {
visitDeclaration(callableMemberDeclaration, null)
visitElement(callableMemberDeclaration, null)
}
open fun visitDeclarationWithBody(declarationWithBody: FirDeclarationWithBody) {
visitDeclaration(declarationWithBody, null)
visitElement(declarationWithBody, null)
}
open fun visitAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer) {
visitDeclarationWithBody(anonymousInitializer, null)
visitElement(anonymousInitializer, null)
}
open fun <F : FirFunction<F>> visitFunction(function: FirFunction<F>) {
visitDeclarationWithBody(function, null)
visitElement(function, null)
}
open fun visitAnonymousFunction(anonymousFunction: FirAnonymousFunction) {
visitFunction(anonymousFunction, null)
visitElement(anonymousFunction, null)
}
open fun <F : FirMemberFunction<F>> visitMemberFunction(memberFunction: FirMemberFunction<F>) {
visitFunction(memberFunction, null)
visitElement(memberFunction, null)
}
open fun visitConstructor(constructor: FirConstructor) {
visitMemberFunction(constructor, null)
visitElement(constructor, null)
}
open fun visitNamedFunction(namedFunction: FirNamedFunction) {
visitMemberFunction(namedFunction, null)
visitElement(namedFunction, null)
}
open fun <F : FirFunction<F>> visitModifiableFunction(modifiableFunction: FirModifiableFunction<F>) {
visitFunction(modifiableFunction, null)
visitElement(modifiableFunction, null)
}
open fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor) {
visitFunction(propertyAccessor, null)
visitElement(propertyAccessor, null)
}
open fun visitErrorDeclaration(errorDeclaration: FirErrorDeclaration) {
visitDeclaration(errorDeclaration, null)
visitElement(errorDeclaration, null)
}
open fun visitField(field: FirField) {
visitDeclaration(field, null)
visitElement(field, null)
}
open fun visitNamedDeclaration(namedDeclaration: FirNamedDeclaration) {
visitDeclaration(namedDeclaration, null)
visitElement(namedDeclaration, null)
}
open fun visitMemberDeclaration(memberDeclaration: FirMemberDeclaration) {
visitNamedDeclaration(memberDeclaration, null)
visitElement(memberDeclaration, null)
}
open fun <F : FirClassLikeDeclaration<F>> visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration<F>) {
visitMemberDeclaration(classLikeDeclaration, null)
visitElement(classLikeDeclaration, null)
}
open fun visitRegularClass(regularClass: FirRegularClass) {
visitClassLikeDeclaration(regularClass, null)
visitElement(regularClass, null)
}
open fun visitEnumEntry(enumEntry: FirEnumEntry) {
visitRegularClass(enumEntry, null)
visitElement(enumEntry, null)
}
open fun visitTypeAlias(typeAlias: FirTypeAlias) {
visitClassLikeDeclaration(typeAlias, null)
visitElement(typeAlias, null)
}
open fun visitTypeParameter(typeParameter: FirTypeParameter) {
visitNamedDeclaration(typeParameter, null)
visitElement(typeParameter, null)
}
open fun visitProperty(property: FirProperty) {
visitDeclaration(property, null)
visitElement(property, null)
}
open fun visitTypedDeclaration(typedDeclaration: FirTypedDeclaration) {
visitDeclaration(typedDeclaration, null)
visitElement(typedDeclaration, null)
}
open fun visitValueParameter(valueParameter: FirValueParameter) {
visitDeclaration(valueParameter, null)
visitElement(valueParameter, null)
}
open fun <F : FirVariable<F>> visitVariable(variable: FirVariable<F>) {
visitDeclaration(variable, null)
visitElement(variable, null)
}
open fun visitDeclarationStatus(declarationStatus: FirDeclarationStatus) {
@@ -126,7 +126,7 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
}
open fun visitResolvedDeclarationStatus(resolvedDeclarationStatus: FirResolvedDeclarationStatus) {
visitDeclarationStatus(resolvedDeclarationStatus, null)
visitElement(resolvedDeclarationStatus, null)
}
open fun visitImport(import: FirImport) {
@@ -134,7 +134,7 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
}
open fun visitResolvedImport(resolvedImport: FirResolvedImport) {
visitImport(resolvedImport, null)
visitElement(resolvedImport, null)
}
open fun visitLabel(label: FirLabel) {
@@ -146,7 +146,7 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
}
open fun visitFile(file: FirFile) {
visitPackageFragment(file, null)
visitElement(file, null)
}
open fun visitReference(reference: FirReference) {
@@ -154,31 +154,31 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
}
open fun visitControlFlowGraphReference(controlFlowGraphReference: FirControlFlowGraphReference) {
visitReference(controlFlowGraphReference, null)
visitElement(controlFlowGraphReference, null)
}
open fun visitNamedReference(namedReference: FirNamedReference) {
visitReference(namedReference, null)
visitElement(namedReference, null)
}
open fun visitResolvedCallableReference(resolvedCallableReference: FirResolvedCallableReference) {
visitNamedReference(resolvedCallableReference, null)
visitElement(resolvedCallableReference, null)
}
open fun visitBackingFieldReference(backingFieldReference: FirBackingFieldReference) {
visitResolvedCallableReference(backingFieldReference, null)
visitElement(backingFieldReference, null)
}
open fun visitDelegateFieldReference(delegateFieldReference: FirDelegateFieldReference) {
visitResolvedCallableReference(delegateFieldReference, null)
visitElement(delegateFieldReference, null)
}
open fun visitSuperReference(superReference: FirSuperReference) {
visitReference(superReference, null)
visitElement(superReference, null)
}
open fun visitThisReference(thisReference: FirThisReference) {
visitReference(thisReference, null)
visitElement(thisReference, null)
}
open fun visitStatement(statement: FirStatement) {
@@ -186,223 +186,223 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
}
open fun visitAnnotatedStatement(annotatedStatement: FirAnnotatedStatement) {
visitStatement(annotatedStatement, null)
visitElement(annotatedStatement, null)
}
open fun visitExpression(expression: FirExpression) {
visitAnnotatedStatement(expression, null)
visitElement(expression, null)
}
open fun visitCall(call: FirCall) {
visitExpression(call, null)
visitElement(call, null)
}
open fun visitArraySetCall(arraySetCall: FirArraySetCall) {
visitCall(arraySetCall, null)
visitElement(arraySetCall, null)
}
open fun visitCallWithArgumentList(callWithArgumentList: FirCallWithArgumentList) {
visitCall(callWithArgumentList, null)
visitElement(callWithArgumentList, null)
}
open fun visitAnnotationCall(annotationCall: FirAnnotationCall) {
visitCallWithArgumentList(annotationCall, null)
visitElement(annotationCall, null)
}
open fun visitDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall) {
visitCallWithArgumentList(delegatedConstructorCall, null)
visitElement(delegatedConstructorCall, null)
}
open fun visitOperatorCall(operatorCall: FirOperatorCall) {
visitCallWithArgumentList(operatorCall, null)
visitElement(operatorCall, null)
}
open fun visitOperationBasedCall(operationBasedCall: FirOperationBasedCall) {
visitOperatorCall(operationBasedCall, null)
visitElement(operationBasedCall, null)
}
open fun visitTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall) {
visitOperationBasedCall(typeOperatorCall, null)
visitElement(typeOperatorCall, null)
}
open fun visitStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall) {
visitCallWithArgumentList(stringConcatenationCall, null)
visitElement(stringConcatenationCall, null)
}
open fun visitUnknownTypeCallWithArgumentList(unknownTypeCallWithArgumentList: FirUnknownTypeCallWithArgumentList) {
visitCallWithArgumentList(unknownTypeCallWithArgumentList, null)
visitElement(unknownTypeCallWithArgumentList, null)
}
open fun visitArrayOfCall(arrayOfCall: FirArrayOfCall) {
visitUnknownTypeCallWithArgumentList(arrayOfCall, null)
visitElement(arrayOfCall, null)
}
open fun visitFunctionCall(functionCall: FirFunctionCall) {
visitUnknownTypeCallWithArgumentList(functionCall, null)
visitElement(functionCall, null)
}
open fun visitComponentCall(componentCall: FirComponentCall) {
visitFunctionCall(componentCall, null)
visitElement(componentCall, null)
}
open fun visitGetClassCall(getClassCall: FirGetClassCall) {
visitUnknownTypeCallWithArgumentList(getClassCall, null)
visitElement(getClassCall, null)
}
open fun visitUncheckedNotNullCast(uncheckedNotNullCast: FirUncheckedNotNullCast) {
visitUnknownTypeCallWithArgumentList(uncheckedNotNullCast, null)
visitElement(uncheckedNotNullCast, null)
}
open fun <E : FirTargetElement> visitJump(jump: FirJump<E>) {
visitExpression(jump, null)
visitElement(jump, null)
}
open fun visitLoopJump(loopJump: FirLoopJump) {
visitJump(loopJump, null)
visitElement(loopJump, null)
}
open fun visitBreakExpression(breakExpression: FirBreakExpression) {
visitLoopJump(breakExpression, null)
visitElement(breakExpression, null)
}
open fun visitContinueExpression(continueExpression: FirContinueExpression) {
visitLoopJump(continueExpression, null)
visitElement(continueExpression, null)
}
open fun visitReturnExpression(returnExpression: FirReturnExpression) {
visitJump(returnExpression, null)
visitElement(returnExpression, null)
}
open fun visitThrowExpression(throwExpression: FirThrowExpression) {
visitExpression(throwExpression, null)
visitElement(throwExpression, null)
}
open fun visitUnknownTypeExpression(unknownTypeExpression: FirUnknownTypeExpression) {
visitExpression(unknownTypeExpression, null)
visitElement(unknownTypeExpression, null)
}
open fun visitBinaryLogicExpression(binaryLogicExpression: FirBinaryLogicExpression) {
visitUnknownTypeExpression(binaryLogicExpression, null)
visitElement(binaryLogicExpression, null)
}
open fun visitBlock(block: FirBlock) {
visitUnknownTypeExpression(block, null)
visitElement(block, null)
}
open fun visitCallLikeControlFlowExpression(callLikeControlFlowExpression: FirCallLikeControlFlowExpression) {
visitUnknownTypeExpression(callLikeControlFlowExpression, null)
visitElement(callLikeControlFlowExpression, null)
}
open fun visitTryExpression(tryExpression: FirTryExpression) {
visitCallLikeControlFlowExpression(tryExpression, null)
visitElement(tryExpression, null)
}
open fun visitWhenExpression(whenExpression: FirWhenExpression) {
visitCallLikeControlFlowExpression(whenExpression, null)
visitElement(whenExpression, null)
}
open fun visitClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression) {
visitUnknownTypeExpression(classReferenceExpression, null)
visitElement(classReferenceExpression, null)
}
open fun <T> visitConstExpression(constExpression: FirConstExpression<T>) {
visitUnknownTypeExpression(constExpression, null)
visitElement(constExpression, null)
}
open fun visitErrorExpression(errorExpression: FirErrorExpression) {
visitUnknownTypeExpression(errorExpression, null)
visitElement(errorExpression, null)
}
open fun visitQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression) {
visitUnknownTypeExpression(qualifiedAccessExpression, null)
visitElement(qualifiedAccessExpression, null)
}
open fun visitCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess) {
visitQualifiedAccessExpression(callableReferenceAccess, null)
visitElement(callableReferenceAccess, null)
}
open fun visitExpressionWithSmartcast(expressionWithSmartcast: FirExpressionWithSmartcast) {
visitQualifiedAccessExpression(expressionWithSmartcast, null)
visitElement(expressionWithSmartcast, null)
}
open fun visitResolvedQualifier(resolvedQualifier: FirResolvedQualifier) {
visitUnknownTypeExpression(resolvedQualifier, null)
visitElement(resolvedQualifier, null)
}
open fun visitWhenSubjectExpression(whenSubjectExpression: FirWhenSubjectExpression) {
visitUnknownTypeExpression(whenSubjectExpression, null)
visitElement(whenSubjectExpression, null)
}
open fun visitWrappedExpression(wrappedExpression: FirWrappedExpression) {
visitExpression(wrappedExpression, null)
visitElement(wrappedExpression, null)
}
open fun visitWrappedArgumentExpression(wrappedArgumentExpression: FirWrappedArgumentExpression) {
visitWrappedExpression(wrappedArgumentExpression, null)
visitElement(wrappedArgumentExpression, null)
}
open fun visitLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression) {
visitWrappedArgumentExpression(lambdaArgumentExpression, null)
visitElement(lambdaArgumentExpression, null)
}
open fun visitNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression) {
visitWrappedArgumentExpression(namedArgumentExpression, null)
visitElement(namedArgumentExpression, null)
}
open fun visitSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression) {
visitWrappedArgumentExpression(spreadArgumentExpression, null)
visitElement(spreadArgumentExpression, null)
}
open fun visitWrappedDelegateExpression(wrappedDelegateExpression: FirWrappedDelegateExpression) {
visitWrappedExpression(wrappedDelegateExpression, null)
visitElement(wrappedDelegateExpression, null)
}
open fun visitClass(klass: FirClass) {
visitStatement(klass, null)
visitElement(klass, null)
}
open fun visitAnonymousObject(anonymousObject: FirAnonymousObject) {
visitClass(anonymousObject, null)
visitElement(anonymousObject, null)
}
open fun visitModifiableClass(modifiableClass: FirModifiableClass) {
visitClass(modifiableClass, null)
visitElement(modifiableClass, null)
}
open fun visitErrorStatement(errorStatement: FirErrorStatement) {
visitStatement(errorStatement, null)
visitElement(errorStatement, null)
}
open fun visitLoop(loop: FirLoop) {
visitStatement(loop, null)
visitElement(loop, null)
}
open fun visitDoWhileLoop(doWhileLoop: FirDoWhileLoop) {
visitLoop(doWhileLoop, null)
visitElement(doWhileLoop, null)
}
open fun visitWhileLoop(whileLoop: FirWhileLoop) {
visitLoop(whileLoop, null)
visitElement(whileLoop, null)
}
open fun visitResolvable(resolvable: FirResolvable) {
visitStatement(resolvable, null)
visitElement(resolvable, null)
}
open fun visitQualifiedAccess(qualifiedAccess: FirQualifiedAccess) {
visitResolvable(qualifiedAccess, null)
visitElement(qualifiedAccess, null)
}
open fun visitAssignment(assignment: FirAssignment) {
visitQualifiedAccess(assignment, null)
visitElement(assignment, null)
}
open fun visitVariableAssignment(variableAssignment: FirVariableAssignment) {
visitAssignment(variableAssignment, null)
visitElement(variableAssignment, null)
}
open fun <C : FirReference> visitModifiableQualifiedAccess(modifiableQualifiedAccess: FirModifiableQualifiedAccess<C>) {
visitQualifiedAccess(modifiableQualifiedAccess, null)
visitElement(modifiableQualifiedAccess, null)
}
open fun visitTargetElement(targetElement: FirTargetElement) {
@@ -410,7 +410,7 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
}
open fun visitLabeledElement(labeledElement: FirLabeledElement) {
visitTargetElement(labeledElement, null)
visitElement(labeledElement, null)
}
open fun visitTypeProjection(typeProjection: FirTypeProjection) {
@@ -418,11 +418,11 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
}
open fun visitStarProjection(starProjection: FirStarProjection) {
visitTypeProjection(starProjection, null)
visitElement(starProjection, null)
}
open fun visitTypeProjectionWithVariance(typeProjectionWithVariance: FirTypeProjectionWithVariance) {
visitTypeProjection(typeProjectionWithVariance, null)
visitElement(typeProjectionWithVariance, null)
}
open fun visitTypeRef(typeRef: FirTypeRef) {
@@ -430,39 +430,39 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
}
open fun visitDelegatedTypeRef(delegatedTypeRef: FirDelegatedTypeRef) {
visitTypeRef(delegatedTypeRef, null)
visitElement(delegatedTypeRef, null)
}
open fun visitImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef) {
visitTypeRef(implicitTypeRef, null)
visitElement(implicitTypeRef, null)
}
open fun visitResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef) {
visitTypeRef(resolvedTypeRef, null)
visitElement(resolvedTypeRef, null)
}
open fun visitErrorTypeRef(errorTypeRef: FirErrorTypeRef) {
visitResolvedTypeRef(errorTypeRef, null)
visitElement(errorTypeRef, null)
}
open fun visitResolvedFunctionTypeRef(resolvedFunctionTypeRef: FirResolvedFunctionTypeRef) {
visitResolvedTypeRef(resolvedFunctionTypeRef, null)
visitElement(resolvedFunctionTypeRef, null)
}
open fun visitTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability) {
visitTypeRef(typeRefWithNullability, null)
visitElement(typeRefWithNullability, null)
}
open fun visitDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef) {
visitTypeRefWithNullability(dynamicTypeRef, null)
visitElement(dynamicTypeRef, null)
}
open fun visitFunctionTypeRef(functionTypeRef: FirFunctionTypeRef) {
visitTypeRefWithNullability(functionTypeRef, null)
visitElement(functionTypeRef, null)
}
open fun visitUserTypeRef(userTypeRef: FirUserTypeRef) {
visitTypeRefWithNullability(userTypeRef, null)
visitElement(userTypeRef, null)
}
open fun visitWhenBranch(whenBranch: FirWhenBranch) {
compiler/visualizer/render-fir/src/org/jetbrains/kotlin/compiler/visualizer/FirVisualizer.kt
+1 -1
View File
@@ -361,7 +361,7 @@ class FirVisualizer(private val firFile: FirFile) : BaseRenderer() {
data.append("[ERROR : ${namedReference.errorReason}]")
return
}
super.visitNamedReference(namedReference, data)
visitElement(namedReference, data)
}
override fun visitResolvedCallableReference(resolvedCallableReference: FirResolvedCallableReference, data: StringBuilder) {
idea/idea-analysis/src/org/jetbrains/kotlin/idea/fir/FirResolutionApi.kt
+16 -3
View File
@@ -6,10 +6,9 @@
package org.jetbrains.kotlin.idea.fir
import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirReference
import org.jetbrains.kotlin.fir.*
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.render
import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
import org.jetbrains.kotlin.fir.resolve.FirProvider
import org.jetbrains.kotlin.fir.resolve.ScopeSession
import org.jetbrains.kotlin.fir.resolve.transformers.*
@@ -173,6 +172,20 @@ fun KtElement.getOrBuildFir(
override fun visitReference(reference: FirReference) {}
override fun visitControlFlowGraphReference(controlFlowGraphReference: FirControlFlowGraphReference) {}
override fun visitNamedReference(namedReference: FirNamedReference) {}
override fun visitResolvedCallableReference(resolvedCallableReference: FirResolvedCallableReference) {}
override fun visitDelegateFieldReference(delegateFieldReference: FirDelegateFieldReference) {}
override fun visitBackingFieldReference(backingFieldReference: FirBackingFieldReference) {}
override fun visitSuperReference(superReference: FirSuperReference) {}
override fun visitThisReference(thisReference: FirThisReference) {}
override fun visitErrorTypeRef(errorTypeRef: FirErrorTypeRef) {}
})
var current: PsiElement? = psi