From e70c1d6959618f9f0e269911340df7fc8d772e1d Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Tue, 17 Sep 2019 14:17:29 +0300 Subject: [PATCH] [FIR] Remove default visited hierarchy --- .../jetbrains/kotlin/fir/dump/HtmlFirDump.kt | 14 +- .../kotlin/fir/backend/Fir2IrVisitor.kt | 24 ++- .../RawFirBuilderTotalKotlinTestCase.kt | 2 +- .../fir/resolve/impl/FirProviderImpl.kt | 4 + .../transformers/FirBodyResolveTransformer.kt | 68 ++++-- ...rCallCompletionResultsWriterTransformer.kt | 16 +- .../FirSpecificTypeResolverTransformer.kt | 30 +++ .../FirStatusResolveTransformer.kt | 28 ++- .../FirSupertypeResolverTransformer.kt | 41 +++- .../transformers/FirTypeResolveTransformer.kt | 57 ++++- .../transformers/FirTypeTransformer.kt | 60 ++++++ .../resolve/transformers/TransformUtils.kt | 38 ++-- .../kotlin/fir/AbstractFirCfgBuildingTest.kt | 2 +- .../jetbrains/kotlin/fir/FirResolveBench.kt | 42 +++- .../org/jetbrains/kotlin/fir/FirRenderer.kt | 2 +- .../src/ParametricTransformerGenerator.kt | 4 +- .../src/SimpleVisitorGenerator.kt | 2 +- .../src/UnitVisitorGenerator.kt | 2 +- .../fir/visitors/FirTransformerGenerated.kt | 202 +++++++++--------- .../fir/visitors/FirVisitorGenerated.kt | 202 +++++++++--------- .../fir/visitors/FirVisitorVoidGenerated.kt | 202 +++++++++--------- .../compiler/visualizer/FirVisualizer.kt | 2 +- .../kotlin/idea/fir/FirResolutionApi.kt | 19 +- 23 files changed, 673 insertions(+), 390 deletions(-) create mode 100644 compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeTransformer.kt diff --git a/compiler/fir/dump/src/org/jetbrains/kotlin/fir/dump/HtmlFirDump.kt b/compiler/fir/dump/src/org/jetbrains/kotlin/fir/dump/HtmlFirDump.kt index 183b2934a61..7cb4fe69058 100644 --- a/compiler/fir/dump/src/org/jetbrains/kotlin/fir/dump/HtmlFirDump.kt +++ b/compiler/fir/dump/src/org/jetbrains/kotlin/fir/dump/HtmlFirDump.kt @@ -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 > visitVariable(variable: FirVariable) { 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) } } } diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt index cd2105bd1ed..2610baf5150 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt @@ -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 { diff --git a/compiler/fir/psi2fir/tests/org/jetbrains/kotlin/fir/builder/RawFirBuilderTotalKotlinTestCase.kt b/compiler/fir/psi2fir/tests/org/jetbrains/kotlin/fir/builder/RawFirBuilderTotalKotlinTestCase.kt index 4fc0f6e8d8b..44d17a4c674 100644 --- a/compiler/fir/psi2fir/tests/org/jetbrains/kotlin/fir/builder/RawFirBuilderTotalKotlinTestCase.kt +++ b/compiler/fir/psi2fir/tests/org/jetbrains/kotlin/fir/builder/RawFirBuilderTotalKotlinTestCase.kt @@ -80,7 +80,7 @@ class RawFirBuilderTotalKotlinTestCase : AbstractRawFirBuilderTestCase() { } else { normalReferences++ } - super.visitQualifiedAccess(qualifiedAccess) + visitStatement(qualifiedAccess) } override fun visitExpression(expression: FirExpression) { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirProviderImpl.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirProviderImpl.kt index 2875de48664..df66adc192f 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirProviderImpl.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirProviderImpl.kt @@ -102,6 +102,10 @@ class FirProviderImpl(val session: FirSession) : FirProvider() { override fun visitProperty(property: FirProperty) { visitCallableMemberDeclaration(property) } + + override fun visitEnumEntry(enumEntry: FirEnumEntry) { + visitRegularClass(enumEntry) + } }) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirBodyResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirBodyResolveTransformer.kt index e09f0230870..9ff1f30bca1 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirBodyResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirBodyResolveTransformer.kt @@ -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 { 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 { @@ -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 { + return transformRegularClass(enumEntry, data) + } + override fun transformUncheckedNotNullCast( uncheckedNotNullCast: FirUncheckedNotNullCast, data: Any? ): CompositeTransformResult { - 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().withNullability(ConeNullability.NOT_NULL)) @@ -268,6 +272,13 @@ open class FirBodyResolveTransformer( } } + override fun transformCallableReferenceAccess( + callableReferenceAccess: FirCallableReferenceAccess, + data: Any? + ): CompositeTransformResult { + 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 { + override fun transformComponentCall(componentCall: FirComponentCall, data: Any?): CompositeTransformResult { + return transformFunctionCall(componentCall, data) + } + + // override fun transformNamedReference(namedReference: FirNamedReference, data: Any?): CompositeTransformResult { // if (namedReference is FirErrorNamedReference || namedReference is FirResolvedCallableReference) return namedReference.compose() // val referents = data as? List ?: return namedReference.compose() // return createResolvedNamedReference(namedReference, referents).compose() @@ -503,13 +518,28 @@ open class FirBodyResolveTransformer( } override fun transformJump(jump: FirJump, data: Any?): CompositeTransformResult { - val result = super.transformJump(jump, data) + val result = transformExpression(jump, data) dataFlowAnalyzer.exitJump(jump) return result } + override fun transformBreakExpression(breakExpression: FirBreakExpression, data: Any?): CompositeTransformResult { + return transformJump(breakExpression, data) + } + + override fun transformContinueExpression( + continueExpression: FirContinueExpression, + data: Any? + ): CompositeTransformResult { + return transformJump(continueExpression, data) + } + + override fun transformReturnExpression(returnExpression: FirReturnExpression, data: Any?): CompositeTransformResult { + return transformJump(returnExpression, data) + } + override fun transformThrowExpression(throwExpression: FirThrowExpression, data: Any?): CompositeTransformResult { - 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 { 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 { - 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 { - 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() diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt index 706ccb476bd..fa0e372eca3 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt @@ -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 { + 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 { + 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 { @@ -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 { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSpecificTypeResolverTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSpecificTypeResolverTransformer.kt index 01468643bdd..8578a436837 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSpecificTypeResolverTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSpecificTypeResolverTransformer.kt @@ -58,4 +58,34 @@ class FirSpecificTypeResolverTransformer( override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: Nothing?): CompositeTransformResult { return implicitTypeRef.compose() } + + override fun transformErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: Nothing?): CompositeTransformResult { + return transformTypeRef(errorTypeRef, data) + } + + override fun transformResolvedFunctionTypeRef( + resolvedFunctionTypeRef: FirResolvedFunctionTypeRef, + data: Nothing? + ): CompositeTransformResult { + return transformTypeRef(resolvedFunctionTypeRef, data) + } + + override fun transformTypeRefWithNullability( + typeRefWithNullability: FirTypeRefWithNullability, + data: Nothing? + ): CompositeTransformResult { + return transformTypeRef(typeRefWithNullability, data) + } + + override fun transformUserTypeRef(userTypeRef: FirUserTypeRef, data: Nothing?): CompositeTransformResult { + return transformTypeRef(userTypeRef, data) + } + + override fun transformDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: Nothing?): CompositeTransformResult { + return transformTypeRef(dynamicTypeRef, data) + } + + override fun transformDelegatedTypeRef(delegatedTypeRef: FirDelegatedTypeRef, data: Nothing?): CompositeTransformResult { + return transformTypeRef(delegatedTypeRef, data) + } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt index 5dc013eb764..b24037e0e48 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt @@ -63,7 +63,7 @@ class FirStatusResolveTransformer : FirAbstractTreeTransformer(phase = FirResolv override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult { 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 { + return transformMemberDeclaration(typeAlias, data) + } + override fun transformRegularClass(regularClass: FirRegularClass, data: Nothing?): CompositeTransformResult { return storeClass(regularClass) { - super.transformRegularClass(regularClass, data) + transformMemberDeclaration(regularClass, data) } } @@ -115,7 +119,7 @@ class FirStatusResolveTransformer : FirAbstractTreeTransformer(phase = FirResolv data: Nothing? ): CompositeTransformResult { return storeDeclaration(memberDeclaration) { - super.transformMemberDeclaration(memberDeclaration, data) + transformDeclaration(memberDeclaration, data) } } @@ -124,7 +128,7 @@ class FirStatusResolveTransformer : FirAbstractTreeTransformer(phase = FirResolv data: Nothing? ): CompositeTransformResult { return storeDeclaration(propertyAccessor) { - super.transformPropertyAccessor(propertyAccessor, data) + transformDeclaration(propertyAccessor, data) } } @@ -133,7 +137,7 @@ class FirStatusResolveTransformer : FirAbstractTreeTransformer(phase = FirResolv data: Nothing? ): CompositeTransformResult { return storeDeclaration(constructor) { - super.transformConstructor(constructor, data) + transformDeclaration(constructor, data) } } @@ -142,7 +146,7 @@ class FirStatusResolveTransformer : FirAbstractTreeTransformer(phase = FirResolv data: Nothing? ): CompositeTransformResult { return storeDeclaration(namedFunction) { - super.transformNamedFunction(namedFunction, data) + transformDeclaration(namedFunction, data) } } @@ -151,7 +155,15 @@ class FirStatusResolveTransformer : FirAbstractTreeTransformer(phase = FirResolv data: Nothing? ): CompositeTransformResult { return storeDeclaration(property) { - super.transformProperty(property, data) + transformDeclaration(property, data) } } + + override fun transformValueParameter(valueParameter: FirValueParameter, data: Nothing?): CompositeTransformResult { + return transformDeclaration(valueParameter, data) + } + + override fun transformEnumEntry(enumEntry: FirEnumEntry, data: Nothing?): CompositeTransformResult { + return transformRegularClass(enumEntry, data) + } } \ No newline at end of file diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypeResolverTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypeResolverTransformer.kt index 1dbcc91569e..5d10d01a8aa 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypeResolverTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypeResolverTransformer.kt @@ -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 { 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 { +// return declarationWithBody.compose() +// } + + override fun transformAnonymousInitializer( + anonymousInitializer: FirAnonymousInitializer, data: Nothing? ): CompositeTransformResult { - return declarationWithBody.compose() + return anonymousInitializer.compose() + } + + override fun transformConstructor(constructor: FirConstructor, data: Nothing?): CompositeTransformResult { + return constructor.compose() + } + + override fun transformNamedFunction(namedFunction: FirNamedFunction, data: Nothing?): CompositeTransformResult { + return namedFunction.compose() } override fun transformProperty(property: FirProperty, data: Nothing?): CompositeTransformResult { return property.compose() } + override fun > transformFunction(function: FirFunction, data: Nothing?): CompositeTransformResult { + 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 { + 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) } } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeResolveTransformer.kt index f25d2cf2522..0c19f56481b 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeResolveTransformer.kt @@ -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 { return withScopeCleanup { constructor.addTypeParametersScope() - super.transformConstructor(constructor, data) + transformDeclaration(constructor, data) } } override fun transformTypeAlias(typeAlias: FirTypeAlias, data: Nothing?): CompositeTransformResult { 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 { return withScopeCleanup { property.addTypeParametersScope() - super.transformProperty(property, data) + transformDeclaration(property, data) } } override fun transformNamedFunction(namedFunction: FirNamedFunction, data: Nothing?): CompositeTransformResult { return withScopeCleanup { namedFunction.addTypeParametersScope() - super.transformNamedFunction(namedFunction, data) + transformDeclaration(namedFunction, data) } } override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: Nothing?): CompositeTransformResult { - 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 { + return transformTypeRef(resolvedTypeRef, data) + } + + override fun transformErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: Nothing?): CompositeTransformResult { + return transformTypeRef(errorTypeRef, data) + } + + override fun transformResolvedFunctionTypeRef( + resolvedFunctionTypeRef: FirResolvedFunctionTypeRef, + data: Nothing? + ): CompositeTransformResult { + return transformTypeRef(resolvedFunctionTypeRef, data) + } + + override fun transformTypeRefWithNullability( + typeRefWithNullability: FirTypeRefWithNullability, + data: Nothing? + ): CompositeTransformResult { + return transformTypeRef(typeRefWithNullability, data) + } + + override fun transformUserTypeRef(userTypeRef: FirUserTypeRef, data: Nothing?): CompositeTransformResult { + return transformTypeRef(userTypeRef, data) + } + + override fun transformDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: Nothing?): CompositeTransformResult { + return transformTypeRef(dynamicTypeRef, data) + } + + override fun transformFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: Nothing?): CompositeTransformResult { + return transformTypeRef(functionTypeRef, data) + } + + override fun transformDelegatedTypeRef(delegatedTypeRef: FirDelegatedTypeRef, data: Nothing?): CompositeTransformResult { + return transformTypeRef(delegatedTypeRef, data) + } + override fun transformTypeRef(typeRef: FirTypeRef, data: Nothing?): CompositeTransformResult { return FirSpecificTypeResolverTransformer(towerScope, FirPosition.OTHER, session).transformTypeRef(typeRef, data) } override fun transformValueParameter(valueParameter: FirValueParameter, data: Nothing?): CompositeTransformResult { - 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() diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeTransformer.kt new file mode 100644 index 00000000000..b6d47df7948 --- /dev/null +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeTransformer.kt @@ -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 : FirTransformer() { + override fun transformElement(element: E, data: D): CompositeTransformResult { + return element.compose() + } + + override fun transformTypeRef(typeRef: FirTypeRef, data: D): CompositeTransformResult { + return transformElement(typeRef, data) + } + + override fun transformDelegatedTypeRef(delegatedTypeRef: FirDelegatedTypeRef, data: D): CompositeTransformResult { + return transformTypeRef(delegatedTypeRef, data) + } + + override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: D): CompositeTransformResult { + return transformTypeRef(implicitTypeRef, data) + } + + override fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: D): CompositeTransformResult { + return transformTypeRef(resolvedTypeRef, data) + } + + override fun transformErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: D): CompositeTransformResult { + return transformResolvedTypeRef(errorTypeRef, data) + } + + override fun transformResolvedFunctionTypeRef(resolvedFunctionTypeRef: FirResolvedFunctionTypeRef, data: D): CompositeTransformResult { + return transformResolvedTypeRef(resolvedFunctionTypeRef, data) + } + + override fun transformTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability, data: D): CompositeTransformResult { + return transformTypeRef(typeRefWithNullability, data) + } + + override fun transformDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: D): CompositeTransformResult { + return transformTypeRefWithNullability(dynamicTypeRef, data) + } + + override fun transformFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: D): CompositeTransformResult { + return transformTypeRefWithNullability(functionTypeRef, data) + } + + override fun transformUserTypeRef(userTypeRef: FirUserTypeRef, data: D): CompositeTransformResult { + return transformTypeRefWithNullability(userTypeRef, data) + } + + +} \ No newline at end of file diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/TransformUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/TransformUtils.kt index 78f42672a8f..35bf4181dad 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/TransformUtils.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/TransformUtils.kt @@ -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>() { ): CompositeTransformResult { return (wrappedArgumentExpression.transformChildren(this, data) as FirStatement).compose() } -} -internal object StoreType : FirTransformer() { - override fun transformElement(element: E, data: FirTypeRef): CompositeTransformResult { - return element.compose() + override fun transformLambdaArgumentExpression( + lambdaArgumentExpression: FirLambdaArgumentExpression, + data: Map + ): CompositeTransformResult { + return transformWrappedArgumentExpression(lambdaArgumentExpression, data) } + override fun transformSpreadArgumentExpression( + spreadArgumentExpression: FirSpreadArgumentExpression, + data: Map + ): CompositeTransformResult { + return transformWrappedArgumentExpression(spreadArgumentExpression, data) + } + + override fun transformNamedArgumentExpression( + namedArgumentExpression: FirNamedArgumentExpression, + data: Map + ): CompositeTransformResult { + return transformWrappedArgumentExpression(namedArgumentExpression, data) + } +} + +internal object StoreType : FirTypeTransformer() { override fun transformTypeRef(typeRef: FirTypeRef, data: FirTypeRef): CompositeTransformResult { return data.compose() } } -internal object TransformImplicitType : FirTransformer() { - override fun transformElement(element: E, data: FirTypeRef): CompositeTransformResult { - return element.compose() - } - +internal object TransformImplicitType : FirTypeTransformer() { override fun transformImplicitTypeRef( implicitTypeRef: FirImplicitTypeRef, data: FirTypeRef @@ -61,11 +73,7 @@ internal object TransformImplicitType : FirTransformer() { } -internal object StoreNameReference : FirTransformer() { - override fun transformElement(element: E, data: FirNamedReference): CompositeTransformResult { - return element.compose() - } - +internal object StoreNameReference : FirTypeTransformer() { override fun transformNamedReference( namedReference: FirNamedReference, data: FirNamedReference diff --git a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/AbstractFirCfgBuildingTest.kt b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/AbstractFirCfgBuildingTest.kt index 3565e31225b..f18cfe40d67 100644 --- a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/AbstractFirCfgBuildingTest.kt +++ b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/AbstractFirCfgBuildingTest.kt @@ -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("}") } diff --git a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirResolveBench.kt b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirResolveBench.kt index 3e941f47136..538db877472 100644 --- a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirResolveBench.kt +++ b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirResolveBench.kt @@ -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) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt index fa85c006044..8e30e7c51d1 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt @@ -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() } diff --git a/compiler/fir/tree/visitors-generator/src/ParametricTransformerGenerator.kt b/compiler/fir/tree/visitors-generator/src/ParametricTransformerGenerator.kt index 4a1f9ffad01..5eef9eb9951 100644 --- a/compiler/fir/tree/visitors-generator/src/ParametricTransformerGenerator.kt +++ b/compiler/fir/tree/visitors-generator/src/ParametricTransformerGenerator.kt @@ -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() } } diff --git a/compiler/fir/tree/visitors-generator/src/SimpleVisitorGenerator.kt b/compiler/fir/tree/visitors-generator/src/SimpleVisitorGenerator.kt index 4ba0f97de6e..bea3ba67c56 100644 --- a/compiler/fir/tree/visitors-generator/src/SimpleVisitorGenerator.kt +++ b/compiler/fir/tree/visitors-generator/src/SimpleVisitorGenerator.kt @@ -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() } } diff --git a/compiler/fir/tree/visitors-generator/src/UnitVisitorGenerator.kt b/compiler/fir/tree/visitors-generator/src/UnitVisitorGenerator.kt index d672f10df78..23650f87a47 100644 --- a/compiler/fir/tree/visitors-generator/src/UnitVisitorGenerator.kt +++ b/compiler/fir/tree/visitors-generator/src/UnitVisitorGenerator.kt @@ -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() } } diff --git a/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirTransformerGenerated.kt b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirTransformerGenerated.kt index 4fb5dba6729..efe7bc82493 100644 --- a/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirTransformerGenerated.kt +++ b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirTransformerGenerated.kt @@ -26,99 +26,99 @@ abstract class FirTransformer : FirVisitor> transformCallableDeclaration(callableDeclaration: FirCallableDeclaration, data: D): CompositeTransformResult { - return transformDeclaration(callableDeclaration, data) + return transformElement(callableDeclaration, data) } open fun > transformCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration, data: D): CompositeTransformResult { - return transformDeclaration(callableMemberDeclaration, data) + return transformElement(callableMemberDeclaration, data) } open fun transformDeclarationWithBody(declarationWithBody: FirDeclarationWithBody, data: D): CompositeTransformResult { - return transformDeclaration(declarationWithBody, data) + return transformElement(declarationWithBody, data) } open fun transformAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, data: D): CompositeTransformResult { - return transformDeclarationWithBody(anonymousInitializer, data) + return transformElement(anonymousInitializer, data) } open fun > transformFunction(function: FirFunction, data: D): CompositeTransformResult { - return transformDeclarationWithBody(function, data) + return transformElement(function, data) } open fun transformAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: D): CompositeTransformResult { - return transformFunction(anonymousFunction, data) + return transformElement(anonymousFunction, data) } open fun > transformMemberFunction(memberFunction: FirMemberFunction, data: D): CompositeTransformResult { - return transformFunction(memberFunction, data) + return transformElement(memberFunction, data) } open fun transformConstructor(constructor: FirConstructor, data: D): CompositeTransformResult { - return transformMemberFunction(constructor, data) + return transformElement(constructor, data) } open fun transformNamedFunction(namedFunction: FirNamedFunction, data: D): CompositeTransformResult { - return transformMemberFunction(namedFunction, data) + return transformElement(namedFunction, data) } open fun > transformModifiableFunction(modifiableFunction: FirModifiableFunction, data: D): CompositeTransformResult { - return transformFunction(modifiableFunction, data) + return transformElement(modifiableFunction, data) } open fun transformPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: D): CompositeTransformResult { - return transformFunction(propertyAccessor, data) + return transformElement(propertyAccessor, data) } open fun transformErrorDeclaration(errorDeclaration: FirErrorDeclaration, data: D): CompositeTransformResult { - return transformDeclaration(errorDeclaration, data) + return transformElement(errorDeclaration, data) } open fun transformField(field: FirField, data: D): CompositeTransformResult { - return transformDeclaration(field, data) + return transformElement(field, data) } open fun transformNamedDeclaration(namedDeclaration: FirNamedDeclaration, data: D): CompositeTransformResult { - return transformDeclaration(namedDeclaration, data) + return transformElement(namedDeclaration, data) } open fun transformMemberDeclaration(memberDeclaration: FirMemberDeclaration, data: D): CompositeTransformResult { - return transformNamedDeclaration(memberDeclaration, data) + return transformElement(memberDeclaration, data) } open fun > transformClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, data: D): CompositeTransformResult { - return transformMemberDeclaration(classLikeDeclaration, data) + return transformElement(classLikeDeclaration, data) } open fun transformRegularClass(regularClass: FirRegularClass, data: D): CompositeTransformResult { - return transformClassLikeDeclaration(regularClass, data) + return transformElement(regularClass, data) } open fun transformEnumEntry(enumEntry: FirEnumEntry, data: D): CompositeTransformResult { - return transformRegularClass(enumEntry, data) + return transformElement(enumEntry, data) } open fun transformTypeAlias(typeAlias: FirTypeAlias, data: D): CompositeTransformResult { - return transformClassLikeDeclaration(typeAlias, data) + return transformElement(typeAlias, data) } open fun transformTypeParameter(typeParameter: FirTypeParameter, data: D): CompositeTransformResult { - return transformNamedDeclaration(typeParameter, data) + return transformElement(typeParameter, data) } open fun transformProperty(property: FirProperty, data: D): CompositeTransformResult { - return transformDeclaration(property, data) + return transformElement(property, data) } open fun transformTypedDeclaration(typedDeclaration: FirTypedDeclaration, data: D): CompositeTransformResult { - return transformDeclaration(typedDeclaration, data) + return transformElement(typedDeclaration, data) } open fun transformValueParameter(valueParameter: FirValueParameter, data: D): CompositeTransformResult { - return transformDeclaration(valueParameter, data) + return transformElement(valueParameter, data) } open fun > transformVariable(variable: FirVariable, data: D): CompositeTransformResult { - return transformDeclaration(variable, data) + return transformElement(variable, data) } open fun transformDeclarationStatus(declarationStatus: FirDeclarationStatus, data: D): CompositeTransformResult { @@ -126,7 +126,7 @@ abstract class FirTransformer : FirVisitor { - return transformDeclarationStatus(resolvedDeclarationStatus, data) + return transformElement(resolvedDeclarationStatus, data) } open fun transformImport(import: FirImport, data: D): CompositeTransformResult { @@ -134,7 +134,7 @@ abstract class FirTransformer : FirVisitor { - return transformImport(resolvedImport, data) + return transformElement(resolvedImport, data) } open fun transformLabel(label: E, data: D): CompositeTransformResult { @@ -146,7 +146,7 @@ abstract class FirTransformer : FirVisitor { - return transformPackageFragment(file, data) + return transformElement(file, data) } open fun transformReference(reference: E, data: D): CompositeTransformResult { @@ -154,31 +154,31 @@ abstract class FirTransformer : FirVisitor { - return transformReference(controlFlowGraphReference, data) + return transformElement(controlFlowGraphReference, data) } open fun transformNamedReference(namedReference: FirNamedReference, data: D): CompositeTransformResult { - return transformReference(namedReference, data) + return transformElement(namedReference, data) } open fun transformResolvedCallableReference(resolvedCallableReference: FirResolvedCallableReference, data: D): CompositeTransformResult { - return transformNamedReference(resolvedCallableReference, data) + return transformElement(resolvedCallableReference, data) } open fun transformBackingFieldReference(backingFieldReference: FirBackingFieldReference, data: D): CompositeTransformResult { - return transformResolvedCallableReference(backingFieldReference, data) + return transformElement(backingFieldReference, data) } open fun transformDelegateFieldReference(delegateFieldReference: FirDelegateFieldReference, data: D): CompositeTransformResult { - return transformResolvedCallableReference(delegateFieldReference, data) + return transformElement(delegateFieldReference, data) } open fun transformSuperReference(superReference: E, data: D): CompositeTransformResult { - return transformReference(superReference, data) + return transformElement(superReference, data) } open fun transformThisReference(thisReference: E, data: D): CompositeTransformResult { - return transformReference(thisReference, data) + return transformElement(thisReference, data) } open fun transformStatement(statement: FirStatement, data: D): CompositeTransformResult { @@ -186,223 +186,223 @@ abstract class FirTransformer : FirVisitor { - return transformStatement(annotatedStatement, data) + return transformElement(annotatedStatement, data) } open fun transformExpression(expression: FirExpression, data: D): CompositeTransformResult { - return transformAnnotatedStatement(expression, data) + return transformElement(expression, data) } open fun transformCall(call: FirCall, data: D): CompositeTransformResult { - return transformExpression(call, data) + return transformElement(call, data) } open fun transformArraySetCall(arraySetCall: FirArraySetCall, data: D): CompositeTransformResult { - return transformCall(arraySetCall, data) + return transformElement(arraySetCall, data) } open fun transformCallWithArgumentList(callWithArgumentList: FirCallWithArgumentList, data: D): CompositeTransformResult { - return transformCall(callWithArgumentList, data) + return transformElement(callWithArgumentList, data) } open fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: D): CompositeTransformResult { - return transformCallWithArgumentList(annotationCall, data) + return transformElement(annotationCall, data) } open fun transformDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall, data: D): CompositeTransformResult { - return transformCallWithArgumentList(delegatedConstructorCall, data) + return transformElement(delegatedConstructorCall, data) } open fun transformOperatorCall(operatorCall: FirOperatorCall, data: D): CompositeTransformResult { - return transformCallWithArgumentList(operatorCall, data) + return transformElement(operatorCall, data) } open fun transformOperationBasedCall(operationBasedCall: FirOperationBasedCall, data: D): CompositeTransformResult { - return transformOperatorCall(operationBasedCall, data) + return transformElement(operationBasedCall, data) } open fun transformTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: D): CompositeTransformResult { - return transformOperationBasedCall(typeOperatorCall, data) + return transformElement(typeOperatorCall, data) } open fun transformStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall, data: D): CompositeTransformResult { - return transformCallWithArgumentList(stringConcatenationCall, data) + return transformElement(stringConcatenationCall, data) } open fun transformUnknownTypeCallWithArgumentList(unknownTypeCallWithArgumentList: FirUnknownTypeCallWithArgumentList, data: D): CompositeTransformResult { - return transformCallWithArgumentList(unknownTypeCallWithArgumentList, data) + return transformElement(unknownTypeCallWithArgumentList, data) } open fun transformArrayOfCall(arrayOfCall: FirArrayOfCall, data: D): CompositeTransformResult { - return transformUnknownTypeCallWithArgumentList(arrayOfCall, data) + return transformElement(arrayOfCall, data) } open fun transformFunctionCall(functionCall: FirFunctionCall, data: D): CompositeTransformResult { - return transformUnknownTypeCallWithArgumentList(functionCall, data) + return transformElement(functionCall, data) } open fun transformComponentCall(componentCall: FirComponentCall, data: D): CompositeTransformResult { - return transformFunctionCall(componentCall, data) + return transformElement(componentCall, data) } open fun transformGetClassCall(getClassCall: FirGetClassCall, data: D): CompositeTransformResult { - return transformUnknownTypeCallWithArgumentList(getClassCall, data) + return transformElement(getClassCall, data) } open fun transformUncheckedNotNullCast(uncheckedNotNullCast: FirUncheckedNotNullCast, data: D): CompositeTransformResult { - return transformUnknownTypeCallWithArgumentList(uncheckedNotNullCast, data) + return transformElement(uncheckedNotNullCast, data) } open fun transformJump(jump: FirJump, data: D): CompositeTransformResult { - return transformExpression(jump, data) + return transformElement(jump, data) } open fun transformLoopJump(loopJump: FirLoopJump, data: D): CompositeTransformResult { - return transformJump(loopJump, data) + return transformElement(loopJump, data) } open fun transformBreakExpression(breakExpression: FirBreakExpression, data: D): CompositeTransformResult { - return transformLoopJump(breakExpression, data) + return transformElement(breakExpression, data) } open fun transformContinueExpression(continueExpression: FirContinueExpression, data: D): CompositeTransformResult { - return transformLoopJump(continueExpression, data) + return transformElement(continueExpression, data) } open fun transformReturnExpression(returnExpression: FirReturnExpression, data: D): CompositeTransformResult { - return transformJump(returnExpression, data) + return transformElement(returnExpression, data) } open fun transformThrowExpression(throwExpression: FirThrowExpression, data: D): CompositeTransformResult { - return transformExpression(throwExpression, data) + return transformElement(throwExpression, data) } open fun transformUnknownTypeExpression(unknownTypeExpression: FirUnknownTypeExpression, data: D): CompositeTransformResult { - return transformExpression(unknownTypeExpression, data) + return transformElement(unknownTypeExpression, data) } open fun transformBinaryLogicExpression(binaryLogicExpression: FirBinaryLogicExpression, data: D): CompositeTransformResult { - return transformUnknownTypeExpression(binaryLogicExpression, data) + return transformElement(binaryLogicExpression, data) } open fun transformBlock(block: FirBlock, data: D): CompositeTransformResult { - return transformUnknownTypeExpression(block, data) + return transformElement(block, data) } open fun transformCallLikeControlFlowExpression(callLikeControlFlowExpression: FirCallLikeControlFlowExpression, data: D): CompositeTransformResult { - return transformUnknownTypeExpression(callLikeControlFlowExpression, data) + return transformElement(callLikeControlFlowExpression, data) } open fun transformTryExpression(tryExpression: FirTryExpression, data: D): CompositeTransformResult { - return transformCallLikeControlFlowExpression(tryExpression, data) + return transformElement(tryExpression, data) } open fun transformWhenExpression(whenExpression: FirWhenExpression, data: D): CompositeTransformResult { - return transformCallLikeControlFlowExpression(whenExpression, data) + return transformElement(whenExpression, data) } open fun transformClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression, data: D): CompositeTransformResult { - return transformUnknownTypeExpression(classReferenceExpression, data) + return transformElement(classReferenceExpression, data) } open fun transformConstExpression(constExpression: FirConstExpression, data: D): CompositeTransformResult { - return transformUnknownTypeExpression(constExpression, data) + return transformElement(constExpression, data) } open fun transformErrorExpression(errorExpression: FirErrorExpression, data: D): CompositeTransformResult { - return transformUnknownTypeExpression(errorExpression, data) + return transformElement(errorExpression, data) } open fun transformQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression, data: D): CompositeTransformResult { - return transformUnknownTypeExpression(qualifiedAccessExpression, data) + return transformElement(qualifiedAccessExpression, data) } open fun transformCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess, data: D): CompositeTransformResult { - return transformQualifiedAccessExpression(callableReferenceAccess, data) + return transformElement(callableReferenceAccess, data) } open fun transformExpressionWithSmartcast(expressionWithSmartcast: FirExpressionWithSmartcast, data: D): CompositeTransformResult { - return transformQualifiedAccessExpression(expressionWithSmartcast, data) + return transformElement(expressionWithSmartcast, data) } open fun transformResolvedQualifier(resolvedQualifier: FirResolvedQualifier, data: D): CompositeTransformResult { - return transformUnknownTypeExpression(resolvedQualifier, data) + return transformElement(resolvedQualifier, data) } open fun transformWhenSubjectExpression(whenSubjectExpression: FirWhenSubjectExpression, data: D): CompositeTransformResult { - return transformUnknownTypeExpression(whenSubjectExpression, data) + return transformElement(whenSubjectExpression, data) } open fun transformWrappedExpression(wrappedExpression: FirWrappedExpression, data: D): CompositeTransformResult { - return transformExpression(wrappedExpression, data) + return transformElement(wrappedExpression, data) } open fun transformWrappedArgumentExpression(wrappedArgumentExpression: FirWrappedArgumentExpression, data: D): CompositeTransformResult { - return transformWrappedExpression(wrappedArgumentExpression, data) + return transformElement(wrappedArgumentExpression, data) } open fun transformLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression, data: D): CompositeTransformResult { - return transformWrappedArgumentExpression(lambdaArgumentExpression, data) + return transformElement(lambdaArgumentExpression, data) } open fun transformNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression, data: D): CompositeTransformResult { - return transformWrappedArgumentExpression(namedArgumentExpression, data) + return transformElement(namedArgumentExpression, data) } open fun transformSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression, data: D): CompositeTransformResult { - return transformWrappedArgumentExpression(spreadArgumentExpression, data) + return transformElement(spreadArgumentExpression, data) } open fun transformWrappedDelegateExpression(wrappedDelegateExpression: FirWrappedDelegateExpression, data: D): CompositeTransformResult { - return transformWrappedExpression(wrappedDelegateExpression, data) + return transformElement(wrappedDelegateExpression, data) } open fun transformClass(klass: FirClass, data: D): CompositeTransformResult { - return transformStatement(klass, data) + return transformElement(klass, data) } open fun transformAnonymousObject(anonymousObject: FirAnonymousObject, data: D): CompositeTransformResult { - return transformClass(anonymousObject, data) + return transformElement(anonymousObject, data) } open fun transformModifiableClass(modifiableClass: FirModifiableClass, data: D): CompositeTransformResult { - return transformClass(modifiableClass, data) + return transformElement(modifiableClass, data) } open fun transformErrorStatement(errorStatement: FirErrorStatement, data: D): CompositeTransformResult { - return transformStatement(errorStatement, data) + return transformElement(errorStatement, data) } open fun transformLoop(loop: FirLoop, data: D): CompositeTransformResult { - return transformStatement(loop, data) + return transformElement(loop, data) } open fun transformDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: D): CompositeTransformResult { - return transformLoop(doWhileLoop, data) + return transformElement(doWhileLoop, data) } open fun transformWhileLoop(whileLoop: FirWhileLoop, data: D): CompositeTransformResult { - return transformLoop(whileLoop, data) + return transformElement(whileLoop, data) } open fun transformResolvable(resolvable: FirResolvable, data: D): CompositeTransformResult { - return transformStatement(resolvable, data) + return transformElement(resolvable, data) } open fun transformQualifiedAccess(qualifiedAccess: FirQualifiedAccess, data: D): CompositeTransformResult { - return transformResolvable(qualifiedAccess, data) + return transformElement(qualifiedAccess, data) } open fun transformAssignment(assignment: FirAssignment, data: D): CompositeTransformResult { - return transformQualifiedAccess(assignment, data) + return transformElement(assignment, data) } open fun transformVariableAssignment(variableAssignment: FirVariableAssignment, data: D): CompositeTransformResult { - return transformAssignment(variableAssignment, data) + return transformElement(variableAssignment, data) } open fun transformModifiableQualifiedAccess(modifiableQualifiedAccess: FirModifiableQualifiedAccess, data: D): CompositeTransformResult { - return transformQualifiedAccess(modifiableQualifiedAccess, data) + return transformElement(modifiableQualifiedAccess, data) } open fun transformTargetElement(targetElement: E, data: D): CompositeTransformResult { @@ -410,7 +410,7 @@ abstract class FirTransformer : FirVisitor transformLabeledElement(labeledElement: E, data: D): CompositeTransformResult { - return transformTargetElement(labeledElement, data) + return transformElement(labeledElement, data) } open fun transformTypeProjection(typeProjection: FirTypeProjection, data: D): CompositeTransformResult { @@ -418,11 +418,11 @@ abstract class FirTransformer : FirVisitor { - return transformTypeProjection(starProjection, data) + return transformElement(starProjection, data) } open fun transformTypeProjectionWithVariance(typeProjectionWithVariance: FirTypeProjectionWithVariance, data: D): CompositeTransformResult { - return transformTypeProjection(typeProjectionWithVariance, data) + return transformElement(typeProjectionWithVariance, data) } open fun transformTypeRef(typeRef: FirTypeRef, data: D): CompositeTransformResult { @@ -430,39 +430,39 @@ abstract class FirTransformer : FirVisitor { - return transformTypeRef(delegatedTypeRef, data) + return transformElement(delegatedTypeRef, data) } open fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: D): CompositeTransformResult { - return transformTypeRef(implicitTypeRef, data) + return transformElement(implicitTypeRef, data) } open fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: D): CompositeTransformResult { - return transformTypeRef(resolvedTypeRef, data) + return transformElement(resolvedTypeRef, data) } open fun transformErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: D): CompositeTransformResult { - return transformResolvedTypeRef(errorTypeRef, data) + return transformElement(errorTypeRef, data) } open fun transformResolvedFunctionTypeRef(resolvedFunctionTypeRef: FirResolvedFunctionTypeRef, data: D): CompositeTransformResult { - return transformResolvedTypeRef(resolvedFunctionTypeRef, data) + return transformElement(resolvedFunctionTypeRef, data) } open fun transformTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability, data: D): CompositeTransformResult { - return transformTypeRef(typeRefWithNullability, data) + return transformElement(typeRefWithNullability, data) } open fun transformDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: D): CompositeTransformResult { - return transformTypeRefWithNullability(dynamicTypeRef, data) + return transformElement(dynamicTypeRef, data) } open fun transformFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: D): CompositeTransformResult { - return transformTypeRefWithNullability(functionTypeRef, data) + return transformElement(functionTypeRef, data) } open fun transformUserTypeRef(userTypeRef: FirUserTypeRef, data: D): CompositeTransformResult { - return transformTypeRefWithNullability(userTypeRef, data) + return transformElement(userTypeRef, data) } open fun transformWhenBranch(whenBranch: FirWhenBranch, data: D): CompositeTransformResult { diff --git a/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorGenerated.kt b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorGenerated.kt index cbd5114911d..737c8da0331 100644 --- a/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorGenerated.kt +++ b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorGenerated.kt @@ -26,99 +26,99 @@ abstract class FirVisitor { } open fun > visitCallableDeclaration(callableDeclaration: FirCallableDeclaration, data: D): R { - return visitDeclaration(callableDeclaration, data) + return visitElement(callableDeclaration, data) } open fun > visitCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration, 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 > visitFunction(function: FirFunction, 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 > visitMemberFunction(memberFunction: FirMemberFunction, 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 > visitModifiableFunction(modifiableFunction: FirModifiableFunction, 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 > visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, 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 > visitVariable(variable: FirVariable, 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 { } 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 { } 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 { } 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 { } 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 { } 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 visitJump(jump: FirJump, 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 visitConstExpression(constExpression: FirConstExpression, 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 visitModifiableQualifiedAccess(modifiableQualifiedAccess: FirModifiableQualifiedAccess, 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 { } 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 { } 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 { } 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 { diff --git a/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorVoidGenerated.kt b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorVoidGenerated.kt index eaf4ba2a266..98f4bfa5e41 100644 --- a/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorVoidGenerated.kt +++ b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorVoidGenerated.kt @@ -26,99 +26,99 @@ abstract class FirVisitorVoid : FirVisitor() { } open fun > visitCallableDeclaration(callableDeclaration: FirCallableDeclaration) { - visitDeclaration(callableDeclaration, null) + visitElement(callableDeclaration, null) } open fun > visitCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration) { - 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 > visitFunction(function: FirFunction) { - visitDeclarationWithBody(function, null) + visitElement(function, null) } open fun visitAnonymousFunction(anonymousFunction: FirAnonymousFunction) { - visitFunction(anonymousFunction, null) + visitElement(anonymousFunction, null) } open fun > visitMemberFunction(memberFunction: FirMemberFunction) { - 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 > visitModifiableFunction(modifiableFunction: FirModifiableFunction) { - 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 > visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration) { - 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 > visitVariable(variable: FirVariable) { - visitDeclaration(variable, null) + visitElement(variable, null) } open fun visitDeclarationStatus(declarationStatus: FirDeclarationStatus) { @@ -126,7 +126,7 @@ abstract class FirVisitorVoid : FirVisitor() { } open fun visitResolvedDeclarationStatus(resolvedDeclarationStatus: FirResolvedDeclarationStatus) { - visitDeclarationStatus(resolvedDeclarationStatus, null) + visitElement(resolvedDeclarationStatus, null) } open fun visitImport(import: FirImport) { @@ -134,7 +134,7 @@ abstract class FirVisitorVoid : FirVisitor() { } open fun visitResolvedImport(resolvedImport: FirResolvedImport) { - visitImport(resolvedImport, null) + visitElement(resolvedImport, null) } open fun visitLabel(label: FirLabel) { @@ -146,7 +146,7 @@ abstract class FirVisitorVoid : FirVisitor() { } open fun visitFile(file: FirFile) { - visitPackageFragment(file, null) + visitElement(file, null) } open fun visitReference(reference: FirReference) { @@ -154,31 +154,31 @@ abstract class FirVisitorVoid : FirVisitor() { } 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() { } 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 visitJump(jump: FirJump) { - 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 visitConstExpression(constExpression: FirConstExpression) { - 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 visitModifiableQualifiedAccess(modifiableQualifiedAccess: FirModifiableQualifiedAccess) { - visitQualifiedAccess(modifiableQualifiedAccess, null) + visitElement(modifiableQualifiedAccess, null) } open fun visitTargetElement(targetElement: FirTargetElement) { @@ -410,7 +410,7 @@ abstract class FirVisitorVoid : FirVisitor() { } open fun visitLabeledElement(labeledElement: FirLabeledElement) { - visitTargetElement(labeledElement, null) + visitElement(labeledElement, null) } open fun visitTypeProjection(typeProjection: FirTypeProjection) { @@ -418,11 +418,11 @@ abstract class FirVisitorVoid : FirVisitor() { } 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() { } 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) { diff --git a/compiler/visualizer/render-fir/src/org/jetbrains/kotlin/compiler/visualizer/FirVisualizer.kt b/compiler/visualizer/render-fir/src/org/jetbrains/kotlin/compiler/visualizer/FirVisualizer.kt index 627af2fd1c6..f23bcd9dd45 100644 --- a/compiler/visualizer/render-fir/src/org/jetbrains/kotlin/compiler/visualizer/FirVisualizer.kt +++ b/compiler/visualizer/render-fir/src/org/jetbrains/kotlin/compiler/visualizer/FirVisualizer.kt @@ -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) { diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/fir/FirResolutionApi.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/fir/FirResolutionApi.kt index 0219bb8e3bc..455663c4f52 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/fir/FirResolutionApi.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/fir/FirResolutionApi.kt @@ -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