From c5f519f7c73143705087bf05e8134d0ec583d43f Mon Sep 17 00:00:00 2001 From: Sergej Jaskiewicz Date: Wed, 20 Sep 2023 14:13:40 +0200 Subject: [PATCH] [FIR/IR generator] Commonize visitor printing logic This is a step towards commonizing the code generator between FIR and IR: KT-61970 Also, don't use kotlinpoet for generating IR visitors (KT-61703) --- .../kotlin/fir/visitors/FirDefaultVisitor.kt | 2 +- .../kotlin/fir/visitors/FirTransformer.kt | 1241 ++++++++-------- .../kotlin/fir/visitors/FirVisitor.kt | 2 +- .../kotlin/fir/visitors/FirVisitorVoid.kt | 1242 ++++++++--------- .../fir/tree/generator/NodeConfigurator.kt | 4 + .../kotlin/fir/tree/generator/Types.kt | 11 +- .../fir/tree/generator/model/Element.kt | 12 + .../fir/tree/generator/printer/element.kt | 4 +- .../tree/generator/printer/implementation.kt | 2 +- .../fir/tree/generator/printer/transformer.kt | 132 +- .../fir/tree/generator/printer/visitor.kt | 249 ++-- .../ir/visitors/IrElementTransformer.kt | 303 ++-- .../kotlin/ir/visitors/IrElementVisitor.kt | 265 +--- .../ir/visitors/IrElementVisitorVoid.kt | 840 ++++++----- .../kotlin/ir/visitors/IrTypeTransformer.kt | 39 +- .../kotlin/ir/generator/CommonTypes.kt | 2 + .../kotlin/ir/generator/model/Model.kt | 6 +- .../ir/generator/model/Transformations.kt | 4 +- .../kotlin/ir/generator/print/Elements.kt | 2 +- .../print/VisitorsAndTransformers.kt | 354 +++-- .../org/jetbrains/kotlin/utils/addToStdlib.kt | 30 + .../kotlin/generators/tree/AbstractElement.kt | 15 + .../generators/tree/AbstractVisitorPrinter.kt | 159 +++ .../tree/AbstractVisitorVoidPrinter.kt | 81 ++ .../kotlin/generators/tree/StandardTypes.kt | 2 + .../generators/tree/printer/printUtils.kt | 98 +- 26 files changed, 2708 insertions(+), 2393 deletions(-) create mode 100644 generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/AbstractVisitorPrinter.kt create mode 100644 generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/AbstractVisitorVoidPrinter.kt diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitor.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitor.kt index b57527c7c7a..e7a26ca33c1 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitor.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitor.kt @@ -19,6 +19,7 @@ import org.jetbrains.kotlin.fir.references.* import org.jetbrains.kotlin.fir.types.* abstract class FirDefaultVisitor : FirVisitor() { + override fun visitTypeRef(typeRef: FirTypeRef, data: D): R = visitAnnotationContainer(typeRef, data) override fun visitResolvedDeclarationStatus(resolvedDeclarationStatus: FirResolvedDeclarationStatus, data: D): R = visitDeclarationStatus(resolvedDeclarationStatus, data) @@ -188,5 +189,4 @@ abstract class FirDefaultVisitor : FirVisitor() { override fun visitRawContractDescription(rawContractDescription: FirRawContractDescription, data: D): R = visitContractDescription(rawContractDescription, data) override fun visitResolvedContractDescription(resolvedContractDescription: FirResolvedContractDescription, data: D): R = visitContractDescription(resolvedContractDescription, data) - } diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt index ec7ca05baf9..a43d4743a05 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt @@ -20,1248 +20,1247 @@ abstract class FirTransformer : FirVisitor() { abstract fun transformElement(element: E, data: D): E - open fun transformAnnotationContainer(annotationContainer: FirAnnotationContainer, data: D): FirAnnotationContainer { - return transformElement(annotationContainer, data) - } - - open fun transformTypeRef(typeRef: FirTypeRef, data: D): FirTypeRef { - return transformElement(typeRef, data) - } - - open fun transformReference(reference: FirReference, data: D): FirReference { - return transformElement(reference, data) - } - - open fun transformLabel(label: FirLabel, data: D): FirLabel { - return transformElement(label, data) - } - - open fun transformResolvable(resolvable: FirResolvable, data: D): FirResolvable { - return transformElement(resolvable, data) - } - - open fun transformTargetElement(targetElement: FirTargetElement, data: D): FirTargetElement { - return transformElement(targetElement, data) - } - - open fun transformDeclarationStatus(declarationStatus: FirDeclarationStatus, data: D): FirDeclarationStatus { - return transformElement(declarationStatus, data) - } - - open fun transformResolvedDeclarationStatus(resolvedDeclarationStatus: FirResolvedDeclarationStatus, data: D): FirDeclarationStatus { - return transformElement(resolvedDeclarationStatus, data) - } - - open fun transformControlFlowGraphOwner(controlFlowGraphOwner: FirControlFlowGraphOwner, data: D): FirControlFlowGraphOwner { - return transformElement(controlFlowGraphOwner, data) - } - - open fun transformStatement(statement: FirStatement, data: D): FirStatement { - return transformElement(statement, data) - } - - open fun transformExpression(expression: FirExpression, data: D): FirStatement { - return transformElement(expression, data) - } - - open fun transformLazyExpression(lazyExpression: FirLazyExpression, data: D): FirStatement { - return transformElement(lazyExpression, data) - } - - open fun transformContextReceiver(contextReceiver: FirContextReceiver, data: D): FirContextReceiver { - return transformElement(contextReceiver, data) - } - - open fun transformElementWithResolveState(elementWithResolveState: FirElementWithResolveState, data: D): FirElementWithResolveState { - return transformElement(elementWithResolveState, data) - } - - open fun transformFileAnnotationsContainer(fileAnnotationsContainer: FirFileAnnotationsContainer, data: D): FirFileAnnotationsContainer { - return transformElement(fileAnnotationsContainer, data) - } - - open fun transformDeclaration(declaration: FirDeclaration, data: D): FirDeclaration { - return transformElement(declaration, data) - } - - open fun transformTypeParameterRefsOwner(typeParameterRefsOwner: FirTypeParameterRefsOwner, data: D): FirTypeParameterRefsOwner { - return transformElement(typeParameterRefsOwner, data) - } - - open fun transformTypeParametersOwner(typeParametersOwner: FirTypeParametersOwner, data: D): FirTypeParametersOwner { - return transformElement(typeParametersOwner, data) - } - - open fun transformMemberDeclaration(memberDeclaration: FirMemberDeclaration, data: D): FirMemberDeclaration { - return transformElement(memberDeclaration, data) - } - - open fun transformAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, data: D): FirAnonymousInitializer { - return transformElement(anonymousInitializer, data) - } - - open fun transformCallableDeclaration(callableDeclaration: FirCallableDeclaration, data: D): FirCallableDeclaration { - return transformElement(callableDeclaration, data) - } - - open fun transformTypeParameterRef(typeParameterRef: FirTypeParameterRef, data: D): FirTypeParameterRef { - return transformElement(typeParameterRef, data) - } - - open fun transformTypeParameter(typeParameter: FirTypeParameter, data: D): FirTypeParameterRef { - return transformElement(typeParameter, data) - } - - open fun transformConstructedClassTypeParameterRef(constructedClassTypeParameterRef: FirConstructedClassTypeParameterRef, data: D): FirTypeParameterRef { - return transformElement(constructedClassTypeParameterRef, data) - } - - open fun transformOuterClassTypeParameterRef(outerClassTypeParameterRef: FirOuterClassTypeParameterRef, data: D): FirTypeParameterRef { - return transformElement(outerClassTypeParameterRef, data) - } - - open fun transformVariable(variable: FirVariable, data: D): FirStatement { - return transformElement(variable, data) - } - - open fun transformValueParameter(valueParameter: FirValueParameter, data: D): FirStatement { - return transformElement(valueParameter, data) - } - - open fun transformReceiverParameter(receiverParameter: FirReceiverParameter, data: D): FirReceiverParameter { - return transformElement(receiverParameter, data) - } - - open fun transformProperty(property: FirProperty, data: D): FirStatement { - return transformElement(property, data) - } - - open fun transformField(field: FirField, data: D): FirStatement { - return transformElement(field, data) - } - - open fun transformEnumEntry(enumEntry: FirEnumEntry, data: D): FirStatement { - return transformElement(enumEntry, data) - } - - open fun transformFunctionTypeParameter(functionTypeParameter: FirFunctionTypeParameter, data: D): FirFunctionTypeParameter { - return transformElement(functionTypeParameter, data) - } - - open fun transformClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, data: D): FirStatement { - return transformElement(classLikeDeclaration, data) - } - - open fun transformClass(klass: FirClass, data: D): FirStatement { - return transformElement(klass, data) - } - - open fun transformRegularClass(regularClass: FirRegularClass, data: D): FirStatement { - return transformElement(regularClass, data) - } - - open fun transformTypeAlias(typeAlias: FirTypeAlias, data: D): FirStatement { - return transformElement(typeAlias, data) - } - - open fun transformFunction(function: FirFunction, data: D): FirStatement { - return transformElement(function, data) - } - - open fun transformContractDescriptionOwner(contractDescriptionOwner: FirContractDescriptionOwner, data: D): FirContractDescriptionOwner { - return transformElement(contractDescriptionOwner, data) - } - - open fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: D): FirStatement { - return transformElement(simpleFunction, data) - } - - open fun transformPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: D): FirStatement { - return transformElement(propertyAccessor, data) - } - - open fun transformBackingField(backingField: FirBackingField, data: D): FirStatement { - return transformElement(backingField, data) - } - - open fun transformConstructor(constructor: FirConstructor, data: D): FirStatement { - return transformElement(constructor, data) - } - - open fun transformFile(file: FirFile, data: D): FirFile { - return transformElement(file, data) - } - - open fun transformScript(script: FirScript, data: D): FirScript { - return transformElement(script, data) - } - - open fun transformCodeFragment(codeFragment: FirCodeFragment, data: D): FirCodeFragment { - return transformElement(codeFragment, data) - } - - open fun transformPackageDirective(packageDirective: FirPackageDirective, data: D): FirPackageDirective { - return transformElement(packageDirective, data) - } - - open fun transformAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: D): FirStatement { - return transformElement(anonymousFunction, data) - } - - open fun transformAnonymousFunctionExpression(anonymousFunctionExpression: FirAnonymousFunctionExpression, data: D): FirStatement { - return transformElement(anonymousFunctionExpression, data) - } - - open fun transformAnonymousObject(anonymousObject: FirAnonymousObject, data: D): FirStatement { - return transformElement(anonymousObject, data) - } - - open fun transformAnonymousObjectExpression(anonymousObjectExpression: FirAnonymousObjectExpression, data: D): FirStatement { - return transformElement(anonymousObjectExpression, data) - } - - open fun transformDiagnosticHolder(diagnosticHolder: FirDiagnosticHolder, data: D): FirDiagnosticHolder { - return transformElement(diagnosticHolder, data) - } - - open fun transformImport(import: FirImport, data: D): FirImport { - return transformElement(import, data) - } - - open fun transformResolvedImport(resolvedImport: FirResolvedImport, data: D): FirImport { - return transformElement(resolvedImport, data) - } - - open fun transformErrorImport(errorImport: FirErrorImport, data: D): FirImport { - return transformElement(errorImport, data) - } - - open fun transformLoop(loop: FirLoop, data: D): FirStatement { - return transformElement(loop, data) - } - - open fun transformErrorLoop(errorLoop: FirErrorLoop, data: D): FirStatement { - return transformElement(errorLoop, data) - } - - open fun transformDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: D): FirStatement { - return transformElement(doWhileLoop, data) - } - - open fun transformWhileLoop(whileLoop: FirWhileLoop, data: D): FirStatement { - return transformElement(whileLoop, data) - } - - open fun transformBlock(block: FirBlock, data: D): FirStatement { - return transformElement(block, data) - } - - open fun transformLazyBlock(lazyBlock: FirLazyBlock, data: D): FirStatement { - return transformElement(lazyBlock, data) - } - - open fun transformBinaryLogicExpression(binaryLogicExpression: FirBinaryLogicExpression, data: D): FirStatement { - return transformElement(binaryLogicExpression, data) - } - - open fun transformJump(jump: FirJump, data: D): FirStatement { - return transformElement(jump, data) - } - - open fun transformLoopJump(loopJump: FirLoopJump, data: D): FirStatement { - return transformElement(loopJump, data) - } - - open fun transformBreakExpression(breakExpression: FirBreakExpression, data: D): FirStatement { - return transformElement(breakExpression, data) - } - - open fun transformContinueExpression(continueExpression: FirContinueExpression, data: D): FirStatement { - return transformElement(continueExpression, data) - } - - open fun transformCatch(catch: FirCatch, data: D): FirCatch { - return transformElement(catch, data) - } - - open fun transformTryExpression(tryExpression: FirTryExpression, data: D): FirStatement { - return transformElement(tryExpression, data) - } - - open fun transformConstExpression(constExpression: FirConstExpression, data: D): FirStatement { - return transformElement(constExpression, data) - } - - open fun transformTypeProjection(typeProjection: FirTypeProjection, data: D): FirTypeProjection { - return transformElement(typeProjection, data) - } - - open fun transformStarProjection(starProjection: FirStarProjection, data: D): FirTypeProjection { - return transformElement(starProjection, data) - } - - open fun transformPlaceholderProjection(placeholderProjection: FirPlaceholderProjection, data: D): FirTypeProjection { - return transformElement(placeholderProjection, data) - } - - open fun transformTypeProjectionWithVariance(typeProjectionWithVariance: FirTypeProjectionWithVariance, data: D): FirTypeProjection { - return transformElement(typeProjectionWithVariance, data) - } - - open fun transformArgumentList(argumentList: FirArgumentList, data: D): FirArgumentList { - return transformElement(argumentList, data) - } - - open fun transformCall(call: FirCall, data: D): FirStatement { - return transformElement(call, data) - } - - open fun transformAnnotation(annotation: FirAnnotation, data: D): FirStatement { - return transformElement(annotation, data) - } - - open fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: D): FirStatement { - return transformElement(annotationCall, data) - } - - open fun transformAnnotationArgumentMapping(annotationArgumentMapping: FirAnnotationArgumentMapping, data: D): FirAnnotationArgumentMapping { - return transformElement(annotationArgumentMapping, data) - } - - open fun transformErrorAnnotationCall(errorAnnotationCall: FirErrorAnnotationCall, data: D): FirStatement { - return transformElement(errorAnnotationCall, data) - } - - open fun transformComparisonExpression(comparisonExpression: FirComparisonExpression, data: D): FirStatement { - return transformElement(comparisonExpression, data) - } - - open fun transformTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: D): FirStatement { - return transformElement(typeOperatorCall, data) - } - - open fun transformAssignmentOperatorStatement(assignmentOperatorStatement: FirAssignmentOperatorStatement, data: D): FirStatement { - return transformElement(assignmentOperatorStatement, data) - } - - open fun transformIncrementDecrementExpression(incrementDecrementExpression: FirIncrementDecrementExpression, data: D): FirStatement { - return transformElement(incrementDecrementExpression, data) - } - - open fun transformEqualityOperatorCall(equalityOperatorCall: FirEqualityOperatorCall, data: D): FirStatement { - return transformElement(equalityOperatorCall, data) - } - - open fun transformWhenExpression(whenExpression: FirWhenExpression, data: D): FirStatement { - return transformElement(whenExpression, data) - } - - open fun transformWhenBranch(whenBranch: FirWhenBranch, data: D): FirWhenBranch { - return transformElement(whenBranch, data) - } - - open fun transformContextReceiverArgumentListOwner(contextReceiverArgumentListOwner: FirContextReceiverArgumentListOwner, data: D): FirContextReceiverArgumentListOwner { - return transformElement(contextReceiverArgumentListOwner, data) - } - - open fun transformCheckNotNullCall(checkNotNullCall: FirCheckNotNullCall, data: D): FirStatement { - return transformElement(checkNotNullCall, data) - } - - open fun transformElvisExpression(elvisExpression: FirElvisExpression, data: D): FirStatement { - return transformElement(elvisExpression, data) - } - - open fun transformArrayLiteral(arrayLiteral: FirArrayLiteral, data: D): FirStatement { - return transformElement(arrayLiteral, data) - } - - open fun transformAugmentedArraySetCall(augmentedArraySetCall: FirAugmentedArraySetCall, data: D): FirStatement { - return transformElement(augmentedArraySetCall, data) - } - - open fun transformClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression, data: D): FirStatement { - return transformElement(classReferenceExpression, data) - } - - open fun transformErrorExpression(errorExpression: FirErrorExpression, data: D): FirStatement { - return transformElement(errorExpression, data) - } - - open fun transformErrorFunction(errorFunction: FirErrorFunction, data: D): FirStatement { - return transformElement(errorFunction, data) - } - - open fun transformErrorProperty(errorProperty: FirErrorProperty, data: D): FirStatement { - return transformElement(errorProperty, data) - } - - open fun transformErrorPrimaryConstructor(errorPrimaryConstructor: FirErrorPrimaryConstructor, data: D): FirStatement { - return transformElement(errorPrimaryConstructor, data) - } - - open fun transformDanglingModifierList(danglingModifierList: FirDanglingModifierList, data: D): FirDanglingModifierList { - return transformElement(danglingModifierList, data) - } - - open fun transformQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression, data: D): FirStatement { - return transformElement(qualifiedAccessExpression, data) - } - - open fun transformQualifiedErrorAccessExpression(qualifiedErrorAccessExpression: FirQualifiedErrorAccessExpression, data: D): FirStatement { - return transformElement(qualifiedErrorAccessExpression, data) - } - - open fun transformPropertyAccessExpression(propertyAccessExpression: FirPropertyAccessExpression, data: D): FirStatement { - return transformElement(propertyAccessExpression, data) - } - - open fun transformFunctionCall(functionCall: FirFunctionCall, data: D): FirStatement { - return transformElement(functionCall, data) - } - - open fun transformIntegerLiteralOperatorCall(integerLiteralOperatorCall: FirIntegerLiteralOperatorCall, data: D): FirStatement { - return transformElement(integerLiteralOperatorCall, data) - } - - open fun transformImplicitInvokeCall(implicitInvokeCall: FirImplicitInvokeCall, data: D): FirStatement { - return transformElement(implicitInvokeCall, data) - } - - open fun transformDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall, data: D): FirStatement { - return transformElement(delegatedConstructorCall, data) - } - - open fun transformMultiDelegatedConstructorCall(multiDelegatedConstructorCall: FirMultiDelegatedConstructorCall, data: D): FirStatement { - return transformElement(multiDelegatedConstructorCall, data) - } - - open fun transformComponentCall(componentCall: FirComponentCall, data: D): FirStatement { - return transformElement(componentCall, data) - } - - open fun transformCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess, data: D): FirStatement { - return transformElement(callableReferenceAccess, data) - } - - open fun transformThisReceiverExpression(thisReceiverExpression: FirThisReceiverExpression, data: D): FirStatement { - return transformElement(thisReceiverExpression, data) - } - - open fun transformInaccessibleReceiverExpression(inaccessibleReceiverExpression: FirInaccessibleReceiverExpression, data: D): FirStatement { - return transformElement(inaccessibleReceiverExpression, data) - } - - open fun transformSmartCastExpression(smartCastExpression: FirSmartCastExpression, data: D): FirStatement { - return transformElement(smartCastExpression, data) - } - - open fun transformSafeCallExpression(safeCallExpression: FirSafeCallExpression, data: D): FirStatement { - return transformElement(safeCallExpression, data) - } - - open fun transformCheckedSafeCallSubject(checkedSafeCallSubject: FirCheckedSafeCallSubject, data: D): FirStatement { - return transformElement(checkedSafeCallSubject, data) - } - - open fun transformGetClassCall(getClassCall: FirGetClassCall, data: D): FirStatement { - return transformElement(getClassCall, data) - } - - open fun transformWrappedExpression(wrappedExpression: FirWrappedExpression, data: D): FirStatement { - return transformElement(wrappedExpression, data) - } - - open fun transformWrappedArgumentExpression(wrappedArgumentExpression: FirWrappedArgumentExpression, data: D): FirStatement { - return transformElement(wrappedArgumentExpression, data) - } - - open fun transformLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression, data: D): FirStatement { - return transformElement(lambdaArgumentExpression, data) - } - - open fun transformSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression, data: D): FirStatement { - return transformElement(spreadArgumentExpression, data) - } - - open fun transformNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression, data: D): FirStatement { - return transformElement(namedArgumentExpression, data) - } - - open fun transformVarargArgumentsExpression(varargArgumentsExpression: FirVarargArgumentsExpression, data: D): FirStatement { - return transformElement(varargArgumentsExpression, data) - } - - open fun transformResolvedQualifier(resolvedQualifier: FirResolvedQualifier, data: D): FirStatement { - return transformElement(resolvedQualifier, data) - } - - open fun transformErrorResolvedQualifier(errorResolvedQualifier: FirErrorResolvedQualifier, data: D): FirStatement { - return transformElement(errorResolvedQualifier, data) - } - - open fun transformResolvedReifiedParameterReference(resolvedReifiedParameterReference: FirResolvedReifiedParameterReference, data: D): FirStatement { - return transformElement(resolvedReifiedParameterReference, data) - } - - open fun transformReturnExpression(returnExpression: FirReturnExpression, data: D): FirStatement { - return transformElement(returnExpression, data) - } - - open fun transformStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall, data: D): FirStatement { - return transformElement(stringConcatenationCall, data) - } - - open fun transformThrowExpression(throwExpression: FirThrowExpression, data: D): FirStatement { - return transformElement(throwExpression, data) - } - - open fun transformVariableAssignment(variableAssignment: FirVariableAssignment, data: D): FirStatement { - return transformElement(variableAssignment, data) - } - - open fun transformWhenSubjectExpression(whenSubjectExpression: FirWhenSubjectExpression, data: D): FirStatement { - return transformElement(whenSubjectExpression, data) - } - - open fun transformDesugaredAssignmentValueReferenceExpression(desugaredAssignmentValueReferenceExpression: FirDesugaredAssignmentValueReferenceExpression, data: D): FirStatement { - return transformElement(desugaredAssignmentValueReferenceExpression, data) - } - - open fun transformWrappedDelegateExpression(wrappedDelegateExpression: FirWrappedDelegateExpression, data: D): FirStatement { - return transformElement(wrappedDelegateExpression, data) - } - - open fun transformEnumEntryDeserializedAccessExpression(enumEntryDeserializedAccessExpression: FirEnumEntryDeserializedAccessExpression, data: D): FirStatement { - return transformElement(enumEntryDeserializedAccessExpression, data) - } - - open fun transformNamedReference(namedReference: FirNamedReference, data: D): FirReference { - return transformElement(namedReference, data) - } - - open fun transformNamedReferenceWithCandidateBase(namedReferenceWithCandidateBase: FirNamedReferenceWithCandidateBase, data: D): FirReference { - return transformElement(namedReferenceWithCandidateBase, data) - } - - open fun transformErrorNamedReference(errorNamedReference: FirErrorNamedReference, data: D): FirReference { - return transformElement(errorNamedReference, data) - } - - open fun transformFromMissingDependenciesNamedReference(fromMissingDependenciesNamedReference: FirFromMissingDependenciesNamedReference, data: D): FirReference { - return transformElement(fromMissingDependenciesNamedReference, data) - } - - open fun transformSuperReference(superReference: FirSuperReference, data: D): FirReference { - return transformElement(superReference, data) - } - - open fun transformThisReference(thisReference: FirThisReference, data: D): FirReference { - return transformElement(thisReference, data) - } - - open fun transformControlFlowGraphReference(controlFlowGraphReference: FirControlFlowGraphReference, data: D): FirReference { - return transformElement(controlFlowGraphReference, data) - } - - open fun transformResolvedNamedReference(resolvedNamedReference: FirResolvedNamedReference, data: D): FirReference { - return transformElement(resolvedNamedReference, data) - } - - open fun transformResolvedErrorReference(resolvedErrorReference: FirResolvedErrorReference, data: D): FirReference { - return transformElement(resolvedErrorReference, data) - } - - open fun transformDelegateFieldReference(delegateFieldReference: FirDelegateFieldReference, data: D): FirReference { - return transformElement(delegateFieldReference, data) - } - - open fun transformBackingFieldReference(backingFieldReference: FirBackingFieldReference, data: D): FirReference { - return transformElement(backingFieldReference, data) - } - - open fun transformResolvedCallableReference(resolvedCallableReference: FirResolvedCallableReference, data: D): FirReference { - return transformElement(resolvedCallableReference, data) - } - - open fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: D): FirTypeRef { - return transformElement(resolvedTypeRef, data) - } - - open fun transformErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: D): FirTypeRef { - return transformElement(errorTypeRef, data) - } - - open fun transformTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability, data: D): FirTypeRef { - return transformElement(typeRefWithNullability, data) - } - - open fun transformUserTypeRef(userTypeRef: FirUserTypeRef, data: D): FirTypeRef { - return transformElement(userTypeRef, data) - } - - open fun transformDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: D): FirTypeRef { - return transformElement(dynamicTypeRef, data) - } - - open fun transformFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: D): FirTypeRef { - return transformElement(functionTypeRef, data) - } - - open fun transformIntersectionTypeRef(intersectionTypeRef: FirIntersectionTypeRef, data: D): FirTypeRef { - return transformElement(intersectionTypeRef, data) - } - - open fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: D): FirTypeRef { - return transformElement(implicitTypeRef, data) - } - - open fun transformContractElementDeclaration(contractElementDeclaration: FirContractElementDeclaration, data: D): FirContractElementDeclaration { - return transformElement(contractElementDeclaration, data) - } - - open fun transformEffectDeclaration(effectDeclaration: FirEffectDeclaration, data: D): FirContractElementDeclaration { - return transformElement(effectDeclaration, data) - } - - open fun transformContractDescription(contractDescription: FirContractDescription, data: D): FirContractDescription { - return transformElement(contractDescription, data) - } - - open fun transformLegacyRawContractDescription(legacyRawContractDescription: FirLegacyRawContractDescription, data: D): FirContractDescription { - return transformElement(legacyRawContractDescription, data) - } - - open fun transformRawContractDescription(rawContractDescription: FirRawContractDescription, data: D): FirContractDescription { - return transformElement(rawContractDescription, data) - } - - open fun transformResolvedContractDescription(resolvedContractDescription: FirResolvedContractDescription, data: D): FirContractDescription { - return transformElement(resolvedContractDescription, data) - } - final override fun visitElement(element: FirElement, data: D): FirElement { return transformElement(element, data) } + open fun transformAnnotationContainer(annotationContainer: FirAnnotationContainer, data: D): FirAnnotationContainer { + return transformElement(annotationContainer, data) + } + final override fun visitAnnotationContainer(annotationContainer: FirAnnotationContainer, data: D): FirAnnotationContainer { return transformAnnotationContainer(annotationContainer, data) } + open fun transformTypeRef(typeRef: FirTypeRef, data: D): FirTypeRef { + return transformElement(typeRef, data) + } + final override fun visitTypeRef(typeRef: FirTypeRef, data: D): FirTypeRef { return transformTypeRef(typeRef, data) } + open fun transformReference(reference: FirReference, data: D): FirReference { + return transformElement(reference, data) + } + final override fun visitReference(reference: FirReference, data: D): FirReference { return transformReference(reference, data) } + open fun transformLabel(label: FirLabel, data: D): FirLabel { + return transformElement(label, data) + } + final override fun visitLabel(label: FirLabel, data: D): FirLabel { return transformLabel(label, data) } + open fun transformResolvable(resolvable: FirResolvable, data: D): FirResolvable { + return transformElement(resolvable, data) + } + final override fun visitResolvable(resolvable: FirResolvable, data: D): FirResolvable { return transformResolvable(resolvable, data) } + open fun transformTargetElement(targetElement: FirTargetElement, data: D): FirTargetElement { + return transformElement(targetElement, data) + } + final override fun visitTargetElement(targetElement: FirTargetElement, data: D): FirTargetElement { return transformTargetElement(targetElement, data) } + open fun transformDeclarationStatus(declarationStatus: FirDeclarationStatus, data: D): FirDeclarationStatus { + return transformElement(declarationStatus, data) + } + final override fun visitDeclarationStatus(declarationStatus: FirDeclarationStatus, data: D): FirDeclarationStatus { return transformDeclarationStatus(declarationStatus, data) } + open fun transformResolvedDeclarationStatus(resolvedDeclarationStatus: FirResolvedDeclarationStatus, data: D): FirDeclarationStatus { + return transformElement(resolvedDeclarationStatus, data) + } + final override fun visitResolvedDeclarationStatus(resolvedDeclarationStatus: FirResolvedDeclarationStatus, data: D): FirDeclarationStatus { return transformResolvedDeclarationStatus(resolvedDeclarationStatus, data) } + open fun transformControlFlowGraphOwner(controlFlowGraphOwner: FirControlFlowGraphOwner, data: D): FirControlFlowGraphOwner { + return transformElement(controlFlowGraphOwner, data) + } + final override fun visitControlFlowGraphOwner(controlFlowGraphOwner: FirControlFlowGraphOwner, data: D): FirControlFlowGraphOwner { return transformControlFlowGraphOwner(controlFlowGraphOwner, data) } + open fun transformStatement(statement: FirStatement, data: D): FirStatement { + return transformElement(statement, data) + } + final override fun visitStatement(statement: FirStatement, data: D): FirStatement { return transformStatement(statement, data) } + open fun transformExpression(expression: FirExpression, data: D): FirStatement { + return transformElement(expression, data) + } + final override fun visitExpression(expression: FirExpression, data: D): FirStatement { return transformExpression(expression, data) } + open fun transformLazyExpression(lazyExpression: FirLazyExpression, data: D): FirStatement { + return transformElement(lazyExpression, data) + } + final override fun visitLazyExpression(lazyExpression: FirLazyExpression, data: D): FirStatement { return transformLazyExpression(lazyExpression, data) } + open fun transformContextReceiver(contextReceiver: FirContextReceiver, data: D): FirContextReceiver { + return transformElement(contextReceiver, data) + } + final override fun visitContextReceiver(contextReceiver: FirContextReceiver, data: D): FirContextReceiver { return transformContextReceiver(contextReceiver, data) } + open fun transformElementWithResolveState(elementWithResolveState: FirElementWithResolveState, data: D): FirElementWithResolveState { + return transformElement(elementWithResolveState, data) + } + final override fun visitElementWithResolveState(elementWithResolveState: FirElementWithResolveState, data: D): FirElementWithResolveState { return transformElementWithResolveState(elementWithResolveState, data) } + open fun transformFileAnnotationsContainer(fileAnnotationsContainer: FirFileAnnotationsContainer, data: D): FirFileAnnotationsContainer { + return transformElement(fileAnnotationsContainer, data) + } + final override fun visitFileAnnotationsContainer(fileAnnotationsContainer: FirFileAnnotationsContainer, data: D): FirFileAnnotationsContainer { return transformFileAnnotationsContainer(fileAnnotationsContainer, data) } + open fun transformDeclaration(declaration: FirDeclaration, data: D): FirDeclaration { + return transformElement(declaration, data) + } + final override fun visitDeclaration(declaration: FirDeclaration, data: D): FirDeclaration { return transformDeclaration(declaration, data) } + open fun transformTypeParameterRefsOwner(typeParameterRefsOwner: FirTypeParameterRefsOwner, data: D): FirTypeParameterRefsOwner { + return transformElement(typeParameterRefsOwner, data) + } + final override fun visitTypeParameterRefsOwner(typeParameterRefsOwner: FirTypeParameterRefsOwner, data: D): FirTypeParameterRefsOwner { return transformTypeParameterRefsOwner(typeParameterRefsOwner, data) } + open fun transformTypeParametersOwner(typeParametersOwner: FirTypeParametersOwner, data: D): FirTypeParametersOwner { + return transformElement(typeParametersOwner, data) + } + final override fun visitTypeParametersOwner(typeParametersOwner: FirTypeParametersOwner, data: D): FirTypeParametersOwner { return transformTypeParametersOwner(typeParametersOwner, data) } + open fun transformMemberDeclaration(memberDeclaration: FirMemberDeclaration, data: D): FirMemberDeclaration { + return transformElement(memberDeclaration, data) + } + final override fun visitMemberDeclaration(memberDeclaration: FirMemberDeclaration, data: D): FirMemberDeclaration { return transformMemberDeclaration(memberDeclaration, data) } + open fun transformAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, data: D): FirAnonymousInitializer { + return transformElement(anonymousInitializer, data) + } + final override fun visitAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, data: D): FirAnonymousInitializer { return transformAnonymousInitializer(anonymousInitializer, data) } + open fun transformCallableDeclaration(callableDeclaration: FirCallableDeclaration, data: D): FirCallableDeclaration { + return transformElement(callableDeclaration, data) + } + final override fun visitCallableDeclaration(callableDeclaration: FirCallableDeclaration, data: D): FirCallableDeclaration { return transformCallableDeclaration(callableDeclaration, data) } + open fun transformTypeParameterRef(typeParameterRef: FirTypeParameterRef, data: D): FirTypeParameterRef { + return transformElement(typeParameterRef, data) + } + final override fun visitTypeParameterRef(typeParameterRef: FirTypeParameterRef, data: D): FirTypeParameterRef { return transformTypeParameterRef(typeParameterRef, data) } + open fun transformTypeParameter(typeParameter: FirTypeParameter, data: D): FirTypeParameterRef { + return transformElement(typeParameter, data) + } + final override fun visitTypeParameter(typeParameter: FirTypeParameter, data: D): FirTypeParameterRef { return transformTypeParameter(typeParameter, data) } + open fun transformConstructedClassTypeParameterRef(constructedClassTypeParameterRef: FirConstructedClassTypeParameterRef, data: D): FirTypeParameterRef { + return transformElement(constructedClassTypeParameterRef, data) + } + final override fun visitConstructedClassTypeParameterRef(constructedClassTypeParameterRef: FirConstructedClassTypeParameterRef, data: D): FirTypeParameterRef { return transformConstructedClassTypeParameterRef(constructedClassTypeParameterRef, data) } + open fun transformOuterClassTypeParameterRef(outerClassTypeParameterRef: FirOuterClassTypeParameterRef, data: D): FirTypeParameterRef { + return transformElement(outerClassTypeParameterRef, data) + } + final override fun visitOuterClassTypeParameterRef(outerClassTypeParameterRef: FirOuterClassTypeParameterRef, data: D): FirTypeParameterRef { return transformOuterClassTypeParameterRef(outerClassTypeParameterRef, data) } + open fun transformVariable(variable: FirVariable, data: D): FirStatement { + return transformElement(variable, data) + } + final override fun visitVariable(variable: FirVariable, data: D): FirStatement { return transformVariable(variable, data) } + open fun transformValueParameter(valueParameter: FirValueParameter, data: D): FirStatement { + return transformElement(valueParameter, data) + } + final override fun visitValueParameter(valueParameter: FirValueParameter, data: D): FirStatement { return transformValueParameter(valueParameter, data) } + open fun transformReceiverParameter(receiverParameter: FirReceiverParameter, data: D): FirReceiverParameter { + return transformElement(receiverParameter, data) + } + final override fun visitReceiverParameter(receiverParameter: FirReceiverParameter, data: D): FirReceiverParameter { return transformReceiverParameter(receiverParameter, data) } + open fun transformProperty(property: FirProperty, data: D): FirStatement { + return transformElement(property, data) + } + final override fun visitProperty(property: FirProperty, data: D): FirStatement { return transformProperty(property, data) } + open fun transformField(field: FirField, data: D): FirStatement { + return transformElement(field, data) + } + final override fun visitField(field: FirField, data: D): FirStatement { return transformField(field, data) } + open fun transformEnumEntry(enumEntry: FirEnumEntry, data: D): FirStatement { + return transformElement(enumEntry, data) + } + final override fun visitEnumEntry(enumEntry: FirEnumEntry, data: D): FirStatement { return transformEnumEntry(enumEntry, data) } + open fun transformFunctionTypeParameter(functionTypeParameter: FirFunctionTypeParameter, data: D): FirFunctionTypeParameter { + return transformElement(functionTypeParameter, data) + } + final override fun visitFunctionTypeParameter(functionTypeParameter: FirFunctionTypeParameter, data: D): FirFunctionTypeParameter { return transformFunctionTypeParameter(functionTypeParameter, data) } + open fun transformClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, data: D): FirStatement { + return transformElement(classLikeDeclaration, data) + } + final override fun visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, data: D): FirStatement { return transformClassLikeDeclaration(classLikeDeclaration, data) } + open fun transformClass(klass: FirClass, data: D): FirStatement { + return transformElement(klass, data) + } + final override fun visitClass(klass: FirClass, data: D): FirStatement { return transformClass(klass, data) } + open fun transformRegularClass(regularClass: FirRegularClass, data: D): FirStatement { + return transformElement(regularClass, data) + } + final override fun visitRegularClass(regularClass: FirRegularClass, data: D): FirStatement { return transformRegularClass(regularClass, data) } + open fun transformTypeAlias(typeAlias: FirTypeAlias, data: D): FirStatement { + return transformElement(typeAlias, data) + } + final override fun visitTypeAlias(typeAlias: FirTypeAlias, data: D): FirStatement { return transformTypeAlias(typeAlias, data) } + open fun transformFunction(function: FirFunction, data: D): FirStatement { + return transformElement(function, data) + } + final override fun visitFunction(function: FirFunction, data: D): FirStatement { return transformFunction(function, data) } + open fun transformContractDescriptionOwner(contractDescriptionOwner: FirContractDescriptionOwner, data: D): FirContractDescriptionOwner { + return transformElement(contractDescriptionOwner, data) + } + final override fun visitContractDescriptionOwner(contractDescriptionOwner: FirContractDescriptionOwner, data: D): FirContractDescriptionOwner { return transformContractDescriptionOwner(contractDescriptionOwner, data) } + open fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: D): FirStatement { + return transformElement(simpleFunction, data) + } + final override fun visitSimpleFunction(simpleFunction: FirSimpleFunction, data: D): FirStatement { return transformSimpleFunction(simpleFunction, data) } + open fun transformPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: D): FirStatement { + return transformElement(propertyAccessor, data) + } + final override fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: D): FirStatement { return transformPropertyAccessor(propertyAccessor, data) } + open fun transformBackingField(backingField: FirBackingField, data: D): FirStatement { + return transformElement(backingField, data) + } + final override fun visitBackingField(backingField: FirBackingField, data: D): FirStatement { return transformBackingField(backingField, data) } + open fun transformConstructor(constructor: FirConstructor, data: D): FirStatement { + return transformElement(constructor, data) + } + final override fun visitConstructor(constructor: FirConstructor, data: D): FirStatement { return transformConstructor(constructor, data) } + open fun transformFile(file: FirFile, data: D): FirFile { + return transformElement(file, data) + } + final override fun visitFile(file: FirFile, data: D): FirFile { return transformFile(file, data) } + open fun transformScript(script: FirScript, data: D): FirScript { + return transformElement(script, data) + } + final override fun visitScript(script: FirScript, data: D): FirScript { return transformScript(script, data) } + open fun transformCodeFragment(codeFragment: FirCodeFragment, data: D): FirCodeFragment { + return transformElement(codeFragment, data) + } + final override fun visitCodeFragment(codeFragment: FirCodeFragment, data: D): FirCodeFragment { return transformCodeFragment(codeFragment, data) } + open fun transformPackageDirective(packageDirective: FirPackageDirective, data: D): FirPackageDirective { + return transformElement(packageDirective, data) + } + final override fun visitPackageDirective(packageDirective: FirPackageDirective, data: D): FirPackageDirective { return transformPackageDirective(packageDirective, data) } + open fun transformAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: D): FirStatement { + return transformElement(anonymousFunction, data) + } + final override fun visitAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: D): FirStatement { return transformAnonymousFunction(anonymousFunction, data) } + open fun transformAnonymousFunctionExpression(anonymousFunctionExpression: FirAnonymousFunctionExpression, data: D): FirStatement { + return transformElement(anonymousFunctionExpression, data) + } + final override fun visitAnonymousFunctionExpression(anonymousFunctionExpression: FirAnonymousFunctionExpression, data: D): FirStatement { return transformAnonymousFunctionExpression(anonymousFunctionExpression, data) } + open fun transformAnonymousObject(anonymousObject: FirAnonymousObject, data: D): FirStatement { + return transformElement(anonymousObject, data) + } + final override fun visitAnonymousObject(anonymousObject: FirAnonymousObject, data: D): FirStatement { return transformAnonymousObject(anonymousObject, data) } + open fun transformAnonymousObjectExpression(anonymousObjectExpression: FirAnonymousObjectExpression, data: D): FirStatement { + return transformElement(anonymousObjectExpression, data) + } + final override fun visitAnonymousObjectExpression(anonymousObjectExpression: FirAnonymousObjectExpression, data: D): FirStatement { return transformAnonymousObjectExpression(anonymousObjectExpression, data) } + open fun transformDiagnosticHolder(diagnosticHolder: FirDiagnosticHolder, data: D): FirDiagnosticHolder { + return transformElement(diagnosticHolder, data) + } + final override fun visitDiagnosticHolder(diagnosticHolder: FirDiagnosticHolder, data: D): FirDiagnosticHolder { return transformDiagnosticHolder(diagnosticHolder, data) } + open fun transformImport(import: FirImport, data: D): FirImport { + return transformElement(import, data) + } + final override fun visitImport(import: FirImport, data: D): FirImport { return transformImport(import, data) } + open fun transformResolvedImport(resolvedImport: FirResolvedImport, data: D): FirImport { + return transformElement(resolvedImport, data) + } + final override fun visitResolvedImport(resolvedImport: FirResolvedImport, data: D): FirImport { return transformResolvedImport(resolvedImport, data) } + open fun transformErrorImport(errorImport: FirErrorImport, data: D): FirImport { + return transformElement(errorImport, data) + } + final override fun visitErrorImport(errorImport: FirErrorImport, data: D): FirImport { return transformErrorImport(errorImport, data) } + open fun transformLoop(loop: FirLoop, data: D): FirStatement { + return transformElement(loop, data) + } + final override fun visitLoop(loop: FirLoop, data: D): FirStatement { return transformLoop(loop, data) } + open fun transformErrorLoop(errorLoop: FirErrorLoop, data: D): FirStatement { + return transformElement(errorLoop, data) + } + final override fun visitErrorLoop(errorLoop: FirErrorLoop, data: D): FirStatement { return transformErrorLoop(errorLoop, data) } + open fun transformDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: D): FirStatement { + return transformElement(doWhileLoop, data) + } + final override fun visitDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: D): FirStatement { return transformDoWhileLoop(doWhileLoop, data) } + open fun transformWhileLoop(whileLoop: FirWhileLoop, data: D): FirStatement { + return transformElement(whileLoop, data) + } + final override fun visitWhileLoop(whileLoop: FirWhileLoop, data: D): FirStatement { return transformWhileLoop(whileLoop, data) } + open fun transformBlock(block: FirBlock, data: D): FirStatement { + return transformElement(block, data) + } + final override fun visitBlock(block: FirBlock, data: D): FirStatement { return transformBlock(block, data) } + open fun transformLazyBlock(lazyBlock: FirLazyBlock, data: D): FirStatement { + return transformElement(lazyBlock, data) + } + final override fun visitLazyBlock(lazyBlock: FirLazyBlock, data: D): FirStatement { return transformLazyBlock(lazyBlock, data) } + open fun transformBinaryLogicExpression(binaryLogicExpression: FirBinaryLogicExpression, data: D): FirStatement { + return transformElement(binaryLogicExpression, data) + } + final override fun visitBinaryLogicExpression(binaryLogicExpression: FirBinaryLogicExpression, data: D): FirStatement { return transformBinaryLogicExpression(binaryLogicExpression, data) } + open fun transformJump(jump: FirJump, data: D): FirStatement { + return transformElement(jump, data) + } + final override fun visitJump(jump: FirJump, data: D): FirStatement { return transformJump(jump, data) } + open fun transformLoopJump(loopJump: FirLoopJump, data: D): FirStatement { + return transformElement(loopJump, data) + } + final override fun visitLoopJump(loopJump: FirLoopJump, data: D): FirStatement { return transformLoopJump(loopJump, data) } + open fun transformBreakExpression(breakExpression: FirBreakExpression, data: D): FirStatement { + return transformElement(breakExpression, data) + } + final override fun visitBreakExpression(breakExpression: FirBreakExpression, data: D): FirStatement { return transformBreakExpression(breakExpression, data) } + open fun transformContinueExpression(continueExpression: FirContinueExpression, data: D): FirStatement { + return transformElement(continueExpression, data) + } + final override fun visitContinueExpression(continueExpression: FirContinueExpression, data: D): FirStatement { return transformContinueExpression(continueExpression, data) } + open fun transformCatch(catch: FirCatch, data: D): FirCatch { + return transformElement(catch, data) + } + final override fun visitCatch(catch: FirCatch, data: D): FirCatch { return transformCatch(catch, data) } + open fun transformTryExpression(tryExpression: FirTryExpression, data: D): FirStatement { + return transformElement(tryExpression, data) + } + final override fun visitTryExpression(tryExpression: FirTryExpression, data: D): FirStatement { return transformTryExpression(tryExpression, data) } + open fun transformConstExpression(constExpression: FirConstExpression, data: D): FirStatement { + return transformElement(constExpression, data) + } + final override fun visitConstExpression(constExpression: FirConstExpression, data: D): FirStatement { return transformConstExpression(constExpression, data) } + open fun transformTypeProjection(typeProjection: FirTypeProjection, data: D): FirTypeProjection { + return transformElement(typeProjection, data) + } + final override fun visitTypeProjection(typeProjection: FirTypeProjection, data: D): FirTypeProjection { return transformTypeProjection(typeProjection, data) } + open fun transformStarProjection(starProjection: FirStarProjection, data: D): FirTypeProjection { + return transformElement(starProjection, data) + } + final override fun visitStarProjection(starProjection: FirStarProjection, data: D): FirTypeProjection { return transformStarProjection(starProjection, data) } + open fun transformPlaceholderProjection(placeholderProjection: FirPlaceholderProjection, data: D): FirTypeProjection { + return transformElement(placeholderProjection, data) + } + final override fun visitPlaceholderProjection(placeholderProjection: FirPlaceholderProjection, data: D): FirTypeProjection { return transformPlaceholderProjection(placeholderProjection, data) } + open fun transformTypeProjectionWithVariance(typeProjectionWithVariance: FirTypeProjectionWithVariance, data: D): FirTypeProjection { + return transformElement(typeProjectionWithVariance, data) + } + final override fun visitTypeProjectionWithVariance(typeProjectionWithVariance: FirTypeProjectionWithVariance, data: D): FirTypeProjection { return transformTypeProjectionWithVariance(typeProjectionWithVariance, data) } + open fun transformArgumentList(argumentList: FirArgumentList, data: D): FirArgumentList { + return transformElement(argumentList, data) + } + final override fun visitArgumentList(argumentList: FirArgumentList, data: D): FirArgumentList { return transformArgumentList(argumentList, data) } + open fun transformCall(call: FirCall, data: D): FirStatement { + return transformElement(call, data) + } + final override fun visitCall(call: FirCall, data: D): FirStatement { return transformCall(call, data) } + open fun transformAnnotation(annotation: FirAnnotation, data: D): FirStatement { + return transformElement(annotation, data) + } + final override fun visitAnnotation(annotation: FirAnnotation, data: D): FirStatement { return transformAnnotation(annotation, data) } + open fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: D): FirStatement { + return transformElement(annotationCall, data) + } + final override fun visitAnnotationCall(annotationCall: FirAnnotationCall, data: D): FirStatement { return transformAnnotationCall(annotationCall, data) } + open fun transformAnnotationArgumentMapping(annotationArgumentMapping: FirAnnotationArgumentMapping, data: D): FirAnnotationArgumentMapping { + return transformElement(annotationArgumentMapping, data) + } + final override fun visitAnnotationArgumentMapping(annotationArgumentMapping: FirAnnotationArgumentMapping, data: D): FirAnnotationArgumentMapping { return transformAnnotationArgumentMapping(annotationArgumentMapping, data) } + open fun transformErrorAnnotationCall(errorAnnotationCall: FirErrorAnnotationCall, data: D): FirStatement { + return transformElement(errorAnnotationCall, data) + } + final override fun visitErrorAnnotationCall(errorAnnotationCall: FirErrorAnnotationCall, data: D): FirStatement { return transformErrorAnnotationCall(errorAnnotationCall, data) } + open fun transformComparisonExpression(comparisonExpression: FirComparisonExpression, data: D): FirStatement { + return transformElement(comparisonExpression, data) + } + final override fun visitComparisonExpression(comparisonExpression: FirComparisonExpression, data: D): FirStatement { return transformComparisonExpression(comparisonExpression, data) } + open fun transformTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: D): FirStatement { + return transformElement(typeOperatorCall, data) + } + final override fun visitTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: D): FirStatement { return transformTypeOperatorCall(typeOperatorCall, data) } + open fun transformAssignmentOperatorStatement(assignmentOperatorStatement: FirAssignmentOperatorStatement, data: D): FirStatement { + return transformElement(assignmentOperatorStatement, data) + } + final override fun visitAssignmentOperatorStatement(assignmentOperatorStatement: FirAssignmentOperatorStatement, data: D): FirStatement { return transformAssignmentOperatorStatement(assignmentOperatorStatement, data) } + open fun transformIncrementDecrementExpression(incrementDecrementExpression: FirIncrementDecrementExpression, data: D): FirStatement { + return transformElement(incrementDecrementExpression, data) + } + final override fun visitIncrementDecrementExpression(incrementDecrementExpression: FirIncrementDecrementExpression, data: D): FirStatement { return transformIncrementDecrementExpression(incrementDecrementExpression, data) } + open fun transformEqualityOperatorCall(equalityOperatorCall: FirEqualityOperatorCall, data: D): FirStatement { + return transformElement(equalityOperatorCall, data) + } + final override fun visitEqualityOperatorCall(equalityOperatorCall: FirEqualityOperatorCall, data: D): FirStatement { return transformEqualityOperatorCall(equalityOperatorCall, data) } + open fun transformWhenExpression(whenExpression: FirWhenExpression, data: D): FirStatement { + return transformElement(whenExpression, data) + } + final override fun visitWhenExpression(whenExpression: FirWhenExpression, data: D): FirStatement { return transformWhenExpression(whenExpression, data) } + open fun transformWhenBranch(whenBranch: FirWhenBranch, data: D): FirWhenBranch { + return transformElement(whenBranch, data) + } + final override fun visitWhenBranch(whenBranch: FirWhenBranch, data: D): FirWhenBranch { return transformWhenBranch(whenBranch, data) } + open fun transformContextReceiverArgumentListOwner(contextReceiverArgumentListOwner: FirContextReceiverArgumentListOwner, data: D): FirContextReceiverArgumentListOwner { + return transformElement(contextReceiverArgumentListOwner, data) + } + final override fun visitContextReceiverArgumentListOwner(contextReceiverArgumentListOwner: FirContextReceiverArgumentListOwner, data: D): FirContextReceiverArgumentListOwner { return transformContextReceiverArgumentListOwner(contextReceiverArgumentListOwner, data) } + open fun transformCheckNotNullCall(checkNotNullCall: FirCheckNotNullCall, data: D): FirStatement { + return transformElement(checkNotNullCall, data) + } + final override fun visitCheckNotNullCall(checkNotNullCall: FirCheckNotNullCall, data: D): FirStatement { return transformCheckNotNullCall(checkNotNullCall, data) } + open fun transformElvisExpression(elvisExpression: FirElvisExpression, data: D): FirStatement { + return transformElement(elvisExpression, data) + } + final override fun visitElvisExpression(elvisExpression: FirElvisExpression, data: D): FirStatement { return transformElvisExpression(elvisExpression, data) } + open fun transformArrayLiteral(arrayLiteral: FirArrayLiteral, data: D): FirStatement { + return transformElement(arrayLiteral, data) + } + final override fun visitArrayLiteral(arrayLiteral: FirArrayLiteral, data: D): FirStatement { return transformArrayLiteral(arrayLiteral, data) } + open fun transformAugmentedArraySetCall(augmentedArraySetCall: FirAugmentedArraySetCall, data: D): FirStatement { + return transformElement(augmentedArraySetCall, data) + } + final override fun visitAugmentedArraySetCall(augmentedArraySetCall: FirAugmentedArraySetCall, data: D): FirStatement { return transformAugmentedArraySetCall(augmentedArraySetCall, data) } + open fun transformClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression, data: D): FirStatement { + return transformElement(classReferenceExpression, data) + } + final override fun visitClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression, data: D): FirStatement { return transformClassReferenceExpression(classReferenceExpression, data) } + open fun transformErrorExpression(errorExpression: FirErrorExpression, data: D): FirStatement { + return transformElement(errorExpression, data) + } + final override fun visitErrorExpression(errorExpression: FirErrorExpression, data: D): FirStatement { return transformErrorExpression(errorExpression, data) } + open fun transformErrorFunction(errorFunction: FirErrorFunction, data: D): FirStatement { + return transformElement(errorFunction, data) + } + final override fun visitErrorFunction(errorFunction: FirErrorFunction, data: D): FirStatement { return transformErrorFunction(errorFunction, data) } + open fun transformErrorProperty(errorProperty: FirErrorProperty, data: D): FirStatement { + return transformElement(errorProperty, data) + } + final override fun visitErrorProperty(errorProperty: FirErrorProperty, data: D): FirStatement { return transformErrorProperty(errorProperty, data) } + open fun transformErrorPrimaryConstructor(errorPrimaryConstructor: FirErrorPrimaryConstructor, data: D): FirStatement { + return transformElement(errorPrimaryConstructor, data) + } + final override fun visitErrorPrimaryConstructor(errorPrimaryConstructor: FirErrorPrimaryConstructor, data: D): FirStatement { return transformErrorPrimaryConstructor(errorPrimaryConstructor, data) } + open fun transformDanglingModifierList(danglingModifierList: FirDanglingModifierList, data: D): FirDanglingModifierList { + return transformElement(danglingModifierList, data) + } + final override fun visitDanglingModifierList(danglingModifierList: FirDanglingModifierList, data: D): FirDanglingModifierList { return transformDanglingModifierList(danglingModifierList, data) } + open fun transformQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression, data: D): FirStatement { + return transformElement(qualifiedAccessExpression, data) + } + final override fun visitQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression, data: D): FirStatement { return transformQualifiedAccessExpression(qualifiedAccessExpression, data) } + open fun transformQualifiedErrorAccessExpression(qualifiedErrorAccessExpression: FirQualifiedErrorAccessExpression, data: D): FirStatement { + return transformElement(qualifiedErrorAccessExpression, data) + } + final override fun visitQualifiedErrorAccessExpression(qualifiedErrorAccessExpression: FirQualifiedErrorAccessExpression, data: D): FirStatement { return transformQualifiedErrorAccessExpression(qualifiedErrorAccessExpression, data) } + open fun transformPropertyAccessExpression(propertyAccessExpression: FirPropertyAccessExpression, data: D): FirStatement { + return transformElement(propertyAccessExpression, data) + } + final override fun visitPropertyAccessExpression(propertyAccessExpression: FirPropertyAccessExpression, data: D): FirStatement { return transformPropertyAccessExpression(propertyAccessExpression, data) } + open fun transformFunctionCall(functionCall: FirFunctionCall, data: D): FirStatement { + return transformElement(functionCall, data) + } + final override fun visitFunctionCall(functionCall: FirFunctionCall, data: D): FirStatement { return transformFunctionCall(functionCall, data) } + open fun transformIntegerLiteralOperatorCall(integerLiteralOperatorCall: FirIntegerLiteralOperatorCall, data: D): FirStatement { + return transformElement(integerLiteralOperatorCall, data) + } + final override fun visitIntegerLiteralOperatorCall(integerLiteralOperatorCall: FirIntegerLiteralOperatorCall, data: D): FirStatement { return transformIntegerLiteralOperatorCall(integerLiteralOperatorCall, data) } + open fun transformImplicitInvokeCall(implicitInvokeCall: FirImplicitInvokeCall, data: D): FirStatement { + return transformElement(implicitInvokeCall, data) + } + final override fun visitImplicitInvokeCall(implicitInvokeCall: FirImplicitInvokeCall, data: D): FirStatement { return transformImplicitInvokeCall(implicitInvokeCall, data) } + open fun transformDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall, data: D): FirStatement { + return transformElement(delegatedConstructorCall, data) + } + final override fun visitDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall, data: D): FirStatement { return transformDelegatedConstructorCall(delegatedConstructorCall, data) } + open fun transformMultiDelegatedConstructorCall(multiDelegatedConstructorCall: FirMultiDelegatedConstructorCall, data: D): FirStatement { + return transformElement(multiDelegatedConstructorCall, data) + } + final override fun visitMultiDelegatedConstructorCall(multiDelegatedConstructorCall: FirMultiDelegatedConstructorCall, data: D): FirStatement { return transformMultiDelegatedConstructorCall(multiDelegatedConstructorCall, data) } + open fun transformComponentCall(componentCall: FirComponentCall, data: D): FirStatement { + return transformElement(componentCall, data) + } + final override fun visitComponentCall(componentCall: FirComponentCall, data: D): FirStatement { return transformComponentCall(componentCall, data) } + open fun transformCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess, data: D): FirStatement { + return transformElement(callableReferenceAccess, data) + } + final override fun visitCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess, data: D): FirStatement { return transformCallableReferenceAccess(callableReferenceAccess, data) } + open fun transformThisReceiverExpression(thisReceiverExpression: FirThisReceiverExpression, data: D): FirStatement { + return transformElement(thisReceiverExpression, data) + } + final override fun visitThisReceiverExpression(thisReceiverExpression: FirThisReceiverExpression, data: D): FirStatement { return transformThisReceiverExpression(thisReceiverExpression, data) } + open fun transformInaccessibleReceiverExpression(inaccessibleReceiverExpression: FirInaccessibleReceiverExpression, data: D): FirStatement { + return transformElement(inaccessibleReceiverExpression, data) + } + final override fun visitInaccessibleReceiverExpression(inaccessibleReceiverExpression: FirInaccessibleReceiverExpression, data: D): FirStatement { return transformInaccessibleReceiverExpression(inaccessibleReceiverExpression, data) } + open fun transformSmartCastExpression(smartCastExpression: FirSmartCastExpression, data: D): FirStatement { + return transformElement(smartCastExpression, data) + } + final override fun visitSmartCastExpression(smartCastExpression: FirSmartCastExpression, data: D): FirStatement { return transformSmartCastExpression(smartCastExpression, data) } + open fun transformSafeCallExpression(safeCallExpression: FirSafeCallExpression, data: D): FirStatement { + return transformElement(safeCallExpression, data) + } + final override fun visitSafeCallExpression(safeCallExpression: FirSafeCallExpression, data: D): FirStatement { return transformSafeCallExpression(safeCallExpression, data) } + open fun transformCheckedSafeCallSubject(checkedSafeCallSubject: FirCheckedSafeCallSubject, data: D): FirStatement { + return transformElement(checkedSafeCallSubject, data) + } + final override fun visitCheckedSafeCallSubject(checkedSafeCallSubject: FirCheckedSafeCallSubject, data: D): FirStatement { return transformCheckedSafeCallSubject(checkedSafeCallSubject, data) } + open fun transformGetClassCall(getClassCall: FirGetClassCall, data: D): FirStatement { + return transformElement(getClassCall, data) + } + final override fun visitGetClassCall(getClassCall: FirGetClassCall, data: D): FirStatement { return transformGetClassCall(getClassCall, data) } + open fun transformWrappedExpression(wrappedExpression: FirWrappedExpression, data: D): FirStatement { + return transformElement(wrappedExpression, data) + } + final override fun visitWrappedExpression(wrappedExpression: FirWrappedExpression, data: D): FirStatement { return transformWrappedExpression(wrappedExpression, data) } + open fun transformWrappedArgumentExpression(wrappedArgumentExpression: FirWrappedArgumentExpression, data: D): FirStatement { + return transformElement(wrappedArgumentExpression, data) + } + final override fun visitWrappedArgumentExpression(wrappedArgumentExpression: FirWrappedArgumentExpression, data: D): FirStatement { return transformWrappedArgumentExpression(wrappedArgumentExpression, data) } + open fun transformLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression, data: D): FirStatement { + return transformElement(lambdaArgumentExpression, data) + } + final override fun visitLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression, data: D): FirStatement { return transformLambdaArgumentExpression(lambdaArgumentExpression, data) } + open fun transformSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression, data: D): FirStatement { + return transformElement(spreadArgumentExpression, data) + } + final override fun visitSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression, data: D): FirStatement { return transformSpreadArgumentExpression(spreadArgumentExpression, data) } + open fun transformNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression, data: D): FirStatement { + return transformElement(namedArgumentExpression, data) + } + final override fun visitNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression, data: D): FirStatement { return transformNamedArgumentExpression(namedArgumentExpression, data) } + open fun transformVarargArgumentsExpression(varargArgumentsExpression: FirVarargArgumentsExpression, data: D): FirStatement { + return transformElement(varargArgumentsExpression, data) + } + final override fun visitVarargArgumentsExpression(varargArgumentsExpression: FirVarargArgumentsExpression, data: D): FirStatement { return transformVarargArgumentsExpression(varargArgumentsExpression, data) } + open fun transformResolvedQualifier(resolvedQualifier: FirResolvedQualifier, data: D): FirStatement { + return transformElement(resolvedQualifier, data) + } + final override fun visitResolvedQualifier(resolvedQualifier: FirResolvedQualifier, data: D): FirStatement { return transformResolvedQualifier(resolvedQualifier, data) } + open fun transformErrorResolvedQualifier(errorResolvedQualifier: FirErrorResolvedQualifier, data: D): FirStatement { + return transformElement(errorResolvedQualifier, data) + } + final override fun visitErrorResolvedQualifier(errorResolvedQualifier: FirErrorResolvedQualifier, data: D): FirStatement { return transformErrorResolvedQualifier(errorResolvedQualifier, data) } + open fun transformResolvedReifiedParameterReference(resolvedReifiedParameterReference: FirResolvedReifiedParameterReference, data: D): FirStatement { + return transformElement(resolvedReifiedParameterReference, data) + } + final override fun visitResolvedReifiedParameterReference(resolvedReifiedParameterReference: FirResolvedReifiedParameterReference, data: D): FirStatement { return transformResolvedReifiedParameterReference(resolvedReifiedParameterReference, data) } + open fun transformReturnExpression(returnExpression: FirReturnExpression, data: D): FirStatement { + return transformElement(returnExpression, data) + } + final override fun visitReturnExpression(returnExpression: FirReturnExpression, data: D): FirStatement { return transformReturnExpression(returnExpression, data) } + open fun transformStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall, data: D): FirStatement { + return transformElement(stringConcatenationCall, data) + } + final override fun visitStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall, data: D): FirStatement { return transformStringConcatenationCall(stringConcatenationCall, data) } + open fun transformThrowExpression(throwExpression: FirThrowExpression, data: D): FirStatement { + return transformElement(throwExpression, data) + } + final override fun visitThrowExpression(throwExpression: FirThrowExpression, data: D): FirStatement { return transformThrowExpression(throwExpression, data) } + open fun transformVariableAssignment(variableAssignment: FirVariableAssignment, data: D): FirStatement { + return transformElement(variableAssignment, data) + } + final override fun visitVariableAssignment(variableAssignment: FirVariableAssignment, data: D): FirStatement { return transformVariableAssignment(variableAssignment, data) } + open fun transformWhenSubjectExpression(whenSubjectExpression: FirWhenSubjectExpression, data: D): FirStatement { + return transformElement(whenSubjectExpression, data) + } + final override fun visitWhenSubjectExpression(whenSubjectExpression: FirWhenSubjectExpression, data: D): FirStatement { return transformWhenSubjectExpression(whenSubjectExpression, data) } + open fun transformDesugaredAssignmentValueReferenceExpression(desugaredAssignmentValueReferenceExpression: FirDesugaredAssignmentValueReferenceExpression, data: D): FirStatement { + return transformElement(desugaredAssignmentValueReferenceExpression, data) + } + final override fun visitDesugaredAssignmentValueReferenceExpression(desugaredAssignmentValueReferenceExpression: FirDesugaredAssignmentValueReferenceExpression, data: D): FirStatement { return transformDesugaredAssignmentValueReferenceExpression(desugaredAssignmentValueReferenceExpression, data) } + open fun transformWrappedDelegateExpression(wrappedDelegateExpression: FirWrappedDelegateExpression, data: D): FirStatement { + return transformElement(wrappedDelegateExpression, data) + } + final override fun visitWrappedDelegateExpression(wrappedDelegateExpression: FirWrappedDelegateExpression, data: D): FirStatement { return transformWrappedDelegateExpression(wrappedDelegateExpression, data) } + open fun transformEnumEntryDeserializedAccessExpression(enumEntryDeserializedAccessExpression: FirEnumEntryDeserializedAccessExpression, data: D): FirStatement { + return transformElement(enumEntryDeserializedAccessExpression, data) + } + final override fun visitEnumEntryDeserializedAccessExpression(enumEntryDeserializedAccessExpression: FirEnumEntryDeserializedAccessExpression, data: D): FirStatement { return transformEnumEntryDeserializedAccessExpression(enumEntryDeserializedAccessExpression, data) } + open fun transformNamedReference(namedReference: FirNamedReference, data: D): FirReference { + return transformElement(namedReference, data) + } + final override fun visitNamedReference(namedReference: FirNamedReference, data: D): FirReference { return transformNamedReference(namedReference, data) } + open fun transformNamedReferenceWithCandidateBase(namedReferenceWithCandidateBase: FirNamedReferenceWithCandidateBase, data: D): FirReference { + return transformElement(namedReferenceWithCandidateBase, data) + } + final override fun visitNamedReferenceWithCandidateBase(namedReferenceWithCandidateBase: FirNamedReferenceWithCandidateBase, data: D): FirReference { return transformNamedReferenceWithCandidateBase(namedReferenceWithCandidateBase, data) } + open fun transformErrorNamedReference(errorNamedReference: FirErrorNamedReference, data: D): FirReference { + return transformElement(errorNamedReference, data) + } + final override fun visitErrorNamedReference(errorNamedReference: FirErrorNamedReference, data: D): FirReference { return transformErrorNamedReference(errorNamedReference, data) } + open fun transformFromMissingDependenciesNamedReference(fromMissingDependenciesNamedReference: FirFromMissingDependenciesNamedReference, data: D): FirReference { + return transformElement(fromMissingDependenciesNamedReference, data) + } + final override fun visitFromMissingDependenciesNamedReference(fromMissingDependenciesNamedReference: FirFromMissingDependenciesNamedReference, data: D): FirReference { return transformFromMissingDependenciesNamedReference(fromMissingDependenciesNamedReference, data) } + open fun transformSuperReference(superReference: FirSuperReference, data: D): FirReference { + return transformElement(superReference, data) + } + final override fun visitSuperReference(superReference: FirSuperReference, data: D): FirReference { return transformSuperReference(superReference, data) } + open fun transformThisReference(thisReference: FirThisReference, data: D): FirReference { + return transformElement(thisReference, data) + } + final override fun visitThisReference(thisReference: FirThisReference, data: D): FirReference { return transformThisReference(thisReference, data) } + open fun transformControlFlowGraphReference(controlFlowGraphReference: FirControlFlowGraphReference, data: D): FirReference { + return transformElement(controlFlowGraphReference, data) + } + final override fun visitControlFlowGraphReference(controlFlowGraphReference: FirControlFlowGraphReference, data: D): FirReference { return transformControlFlowGraphReference(controlFlowGraphReference, data) } + open fun transformResolvedNamedReference(resolvedNamedReference: FirResolvedNamedReference, data: D): FirReference { + return transformElement(resolvedNamedReference, data) + } + final override fun visitResolvedNamedReference(resolvedNamedReference: FirResolvedNamedReference, data: D): FirReference { return transformResolvedNamedReference(resolvedNamedReference, data) } + open fun transformResolvedErrorReference(resolvedErrorReference: FirResolvedErrorReference, data: D): FirReference { + return transformElement(resolvedErrorReference, data) + } + final override fun visitResolvedErrorReference(resolvedErrorReference: FirResolvedErrorReference, data: D): FirReference { return transformResolvedErrorReference(resolvedErrorReference, data) } + open fun transformDelegateFieldReference(delegateFieldReference: FirDelegateFieldReference, data: D): FirReference { + return transformElement(delegateFieldReference, data) + } + final override fun visitDelegateFieldReference(delegateFieldReference: FirDelegateFieldReference, data: D): FirReference { return transformDelegateFieldReference(delegateFieldReference, data) } + open fun transformBackingFieldReference(backingFieldReference: FirBackingFieldReference, data: D): FirReference { + return transformElement(backingFieldReference, data) + } + final override fun visitBackingFieldReference(backingFieldReference: FirBackingFieldReference, data: D): FirReference { return transformBackingFieldReference(backingFieldReference, data) } + open fun transformResolvedCallableReference(resolvedCallableReference: FirResolvedCallableReference, data: D): FirReference { + return transformElement(resolvedCallableReference, data) + } + final override fun visitResolvedCallableReference(resolvedCallableReference: FirResolvedCallableReference, data: D): FirReference { return transformResolvedCallableReference(resolvedCallableReference, data) } + open fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: D): FirTypeRef { + return transformElement(resolvedTypeRef, data) + } + final override fun visitResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: D): FirTypeRef { return transformResolvedTypeRef(resolvedTypeRef, data) } + open fun transformErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: D): FirTypeRef { + return transformElement(errorTypeRef, data) + } + final override fun visitErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: D): FirTypeRef { return transformErrorTypeRef(errorTypeRef, data) } + open fun transformTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability, data: D): FirTypeRef { + return transformElement(typeRefWithNullability, data) + } + final override fun visitTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability, data: D): FirTypeRef { return transformTypeRefWithNullability(typeRefWithNullability, data) } + open fun transformUserTypeRef(userTypeRef: FirUserTypeRef, data: D): FirTypeRef { + return transformElement(userTypeRef, data) + } + final override fun visitUserTypeRef(userTypeRef: FirUserTypeRef, data: D): FirTypeRef { return transformUserTypeRef(userTypeRef, data) } + open fun transformDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: D): FirTypeRef { + return transformElement(dynamicTypeRef, data) + } + final override fun visitDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: D): FirTypeRef { return transformDynamicTypeRef(dynamicTypeRef, data) } + open fun transformFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: D): FirTypeRef { + return transformElement(functionTypeRef, data) + } + final override fun visitFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: D): FirTypeRef { return transformFunctionTypeRef(functionTypeRef, data) } + open fun transformIntersectionTypeRef(intersectionTypeRef: FirIntersectionTypeRef, data: D): FirTypeRef { + return transformElement(intersectionTypeRef, data) + } + final override fun visitIntersectionTypeRef(intersectionTypeRef: FirIntersectionTypeRef, data: D): FirTypeRef { return transformIntersectionTypeRef(intersectionTypeRef, data) } + open fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: D): FirTypeRef { + return transformElement(implicitTypeRef, data) + } + final override fun visitImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: D): FirTypeRef { return transformImplicitTypeRef(implicitTypeRef, data) } + open fun transformContractElementDeclaration(contractElementDeclaration: FirContractElementDeclaration, data: D): FirContractElementDeclaration { + return transformElement(contractElementDeclaration, data) + } + final override fun visitContractElementDeclaration(contractElementDeclaration: FirContractElementDeclaration, data: D): FirContractElementDeclaration { return transformContractElementDeclaration(contractElementDeclaration, data) } + open fun transformEffectDeclaration(effectDeclaration: FirEffectDeclaration, data: D): FirContractElementDeclaration { + return transformElement(effectDeclaration, data) + } + final override fun visitEffectDeclaration(effectDeclaration: FirEffectDeclaration, data: D): FirContractElementDeclaration { return transformEffectDeclaration(effectDeclaration, data) } + open fun transformContractDescription(contractDescription: FirContractDescription, data: D): FirContractDescription { + return transformElement(contractDescription, data) + } + final override fun visitContractDescription(contractDescription: FirContractDescription, data: D): FirContractDescription { return transformContractDescription(contractDescription, data) } + open fun transformLegacyRawContractDescription(legacyRawContractDescription: FirLegacyRawContractDescription, data: D): FirContractDescription { + return transformElement(legacyRawContractDescription, data) + } + final override fun visitLegacyRawContractDescription(legacyRawContractDescription: FirLegacyRawContractDescription, data: D): FirContractDescription { return transformLegacyRawContractDescription(legacyRawContractDescription, data) } + open fun transformRawContractDescription(rawContractDescription: FirRawContractDescription, data: D): FirContractDescription { + return transformElement(rawContractDescription, data) + } + final override fun visitRawContractDescription(rawContractDescription: FirRawContractDescription, data: D): FirContractDescription { return transformRawContractDescription(rawContractDescription, data) } + open fun transformResolvedContractDescription(resolvedContractDescription: FirResolvedContractDescription, data: D): FirContractDescription { + return transformElement(resolvedContractDescription, data) + } + final override fun visitResolvedContractDescription(resolvedContractDescription: FirResolvedContractDescription, data: D): FirContractDescription { return transformResolvedContractDescription(resolvedContractDescription, data) } - } diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt index eb4941bbe8c..de601c26b5d 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt @@ -17,6 +17,7 @@ import org.jetbrains.kotlin.fir.references.* import org.jetbrains.kotlin.fir.types.* abstract class FirVisitor { + abstract fun visitElement(element: FirElement, data: D): R open fun visitAnnotationContainer(annotationContainer: FirAnnotationContainer, data: D): R = visitElement(annotationContainer, data) @@ -328,5 +329,4 @@ abstract class FirVisitor { open fun visitRawContractDescription(rawContractDescription: FirRawContractDescription, data: D): R = visitElement(rawContractDescription, data) open fun visitResolvedContractDescription(resolvedContractDescription: FirResolvedContractDescription, data: D): R = visitElement(resolvedContractDescription, data) - } diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitorVoid.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitorVoid.kt index 0c059395baa..4d47fdec253 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitorVoid.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitorVoid.kt @@ -17,1250 +17,1250 @@ import org.jetbrains.kotlin.fir.references.* import org.jetbrains.kotlin.fir.types.* abstract class FirVisitorVoid : FirVisitor() { - abstract fun visitElement(element: FirElement) - - open fun visitAnnotationContainer(annotationContainer: FirAnnotationContainer) { - visitElement(annotationContainer) - } - - open fun visitTypeRef(typeRef: FirTypeRef) { - visitElement(typeRef) - } - - open fun visitReference(reference: FirReference) { - visitElement(reference) - } - - open fun visitLabel(label: FirLabel) { - visitElement(label) - } - - open fun visitResolvable(resolvable: FirResolvable) { - visitElement(resolvable) - } - - open fun visitTargetElement(targetElement: FirTargetElement) { - visitElement(targetElement) - } - - open fun visitDeclarationStatus(declarationStatus: FirDeclarationStatus) { - visitElement(declarationStatus) - } - - open fun visitResolvedDeclarationStatus(resolvedDeclarationStatus: FirResolvedDeclarationStatus) { - visitElement(resolvedDeclarationStatus) - } - - open fun visitControlFlowGraphOwner(controlFlowGraphOwner: FirControlFlowGraphOwner) { - visitElement(controlFlowGraphOwner) - } - - open fun visitStatement(statement: FirStatement) { - visitElement(statement) - } - - open fun visitExpression(expression: FirExpression) { - visitElement(expression) - } - - open fun visitLazyExpression(lazyExpression: FirLazyExpression) { - visitElement(lazyExpression) - } - - open fun visitContextReceiver(contextReceiver: FirContextReceiver) { - visitElement(contextReceiver) - } - - open fun visitElementWithResolveState(elementWithResolveState: FirElementWithResolveState) { - visitElement(elementWithResolveState) - } - - open fun visitFileAnnotationsContainer(fileAnnotationsContainer: FirFileAnnotationsContainer) { - visitElement(fileAnnotationsContainer) - } - - open fun visitDeclaration(declaration: FirDeclaration) { - visitElement(declaration) - } - - open fun visitTypeParameterRefsOwner(typeParameterRefsOwner: FirTypeParameterRefsOwner) { - visitElement(typeParameterRefsOwner) - } - - open fun visitTypeParametersOwner(typeParametersOwner: FirTypeParametersOwner) { - visitElement(typeParametersOwner) - } - - open fun visitMemberDeclaration(memberDeclaration: FirMemberDeclaration) { - visitElement(memberDeclaration) - } - - open fun visitAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer) { - visitElement(anonymousInitializer) - } - - open fun visitCallableDeclaration(callableDeclaration: FirCallableDeclaration) { - visitElement(callableDeclaration) - } - - open fun visitTypeParameterRef(typeParameterRef: FirTypeParameterRef) { - visitElement(typeParameterRef) - } - - open fun visitTypeParameter(typeParameter: FirTypeParameter) { - visitElement(typeParameter) - } - - open fun visitConstructedClassTypeParameterRef(constructedClassTypeParameterRef: FirConstructedClassTypeParameterRef) { - visitElement(constructedClassTypeParameterRef) - } - - open fun visitOuterClassTypeParameterRef(outerClassTypeParameterRef: FirOuterClassTypeParameterRef) { - visitElement(outerClassTypeParameterRef) - } - - open fun visitVariable(variable: FirVariable) { - visitElement(variable) - } - - open fun visitValueParameter(valueParameter: FirValueParameter) { - visitElement(valueParameter) - } - - open fun visitReceiverParameter(receiverParameter: FirReceiverParameter) { - visitElement(receiverParameter) - } - - open fun visitProperty(property: FirProperty) { - visitElement(property) - } - - open fun visitField(field: FirField) { - visitElement(field) - } - - open fun visitEnumEntry(enumEntry: FirEnumEntry) { - visitElement(enumEntry) - } - - open fun visitFunctionTypeParameter(functionTypeParameter: FirFunctionTypeParameter) { - visitElement(functionTypeParameter) - } - - open fun visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration) { - visitElement(classLikeDeclaration) - } - - open fun visitClass(klass: FirClass) { - visitElement(klass) - } - - open fun visitRegularClass(regularClass: FirRegularClass) { - visitElement(regularClass) - } - - open fun visitTypeAlias(typeAlias: FirTypeAlias) { - visitElement(typeAlias) - } - - open fun visitFunction(function: FirFunction) { - visitElement(function) - } - - open fun visitContractDescriptionOwner(contractDescriptionOwner: FirContractDescriptionOwner) { - visitElement(contractDescriptionOwner) - } - - open fun visitSimpleFunction(simpleFunction: FirSimpleFunction) { - visitElement(simpleFunction) - } - - open fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor) { - visitElement(propertyAccessor) - } - - open fun visitBackingField(backingField: FirBackingField) { - visitElement(backingField) - } - - open fun visitConstructor(constructor: FirConstructor) { - visitElement(constructor) - } - - open fun visitFile(file: FirFile) { - visitElement(file) - } - - open fun visitScript(script: FirScript) { - visitElement(script) - } - - open fun visitCodeFragment(codeFragment: FirCodeFragment) { - visitElement(codeFragment) - } - - open fun visitPackageDirective(packageDirective: FirPackageDirective) { - visitElement(packageDirective) - } - - open fun visitAnonymousFunction(anonymousFunction: FirAnonymousFunction) { - visitElement(anonymousFunction) - } - - open fun visitAnonymousFunctionExpression(anonymousFunctionExpression: FirAnonymousFunctionExpression) { - visitElement(anonymousFunctionExpression) - } - - open fun visitAnonymousObject(anonymousObject: FirAnonymousObject) { - visitElement(anonymousObject) - } - - open fun visitAnonymousObjectExpression(anonymousObjectExpression: FirAnonymousObjectExpression) { - visitElement(anonymousObjectExpression) - } - - open fun visitDiagnosticHolder(diagnosticHolder: FirDiagnosticHolder) { - visitElement(diagnosticHolder) - } - - open fun visitImport(import: FirImport) { - visitElement(import) - } - - open fun visitResolvedImport(resolvedImport: FirResolvedImport) { - visitElement(resolvedImport) - } - - open fun visitErrorImport(errorImport: FirErrorImport) { - visitElement(errorImport) - } - - open fun visitLoop(loop: FirLoop) { - visitElement(loop) - } - - open fun visitErrorLoop(errorLoop: FirErrorLoop) { - visitElement(errorLoop) - } - - open fun visitDoWhileLoop(doWhileLoop: FirDoWhileLoop) { - visitElement(doWhileLoop) - } - - open fun visitWhileLoop(whileLoop: FirWhileLoop) { - visitElement(whileLoop) - } - - open fun visitBlock(block: FirBlock) { - visitElement(block) - } - - open fun visitLazyBlock(lazyBlock: FirLazyBlock) { - visitElement(lazyBlock) - } - - open fun visitBinaryLogicExpression(binaryLogicExpression: FirBinaryLogicExpression) { - visitElement(binaryLogicExpression) - } - - open fun visitJump(jump: FirJump) { - visitElement(jump) - } - - open fun visitLoopJump(loopJump: FirLoopJump) { - visitElement(loopJump) - } - - open fun visitBreakExpression(breakExpression: FirBreakExpression) { - visitElement(breakExpression) - } - - open fun visitContinueExpression(continueExpression: FirContinueExpression) { - visitElement(continueExpression) - } - - open fun visitCatch(catch: FirCatch) { - visitElement(catch) - } - - open fun visitTryExpression(tryExpression: FirTryExpression) { - visitElement(tryExpression) - } - - open fun visitConstExpression(constExpression: FirConstExpression) { - visitElement(constExpression) - } - - open fun visitTypeProjection(typeProjection: FirTypeProjection) { - visitElement(typeProjection) - } - - open fun visitStarProjection(starProjection: FirStarProjection) { - visitElement(starProjection) - } - - open fun visitPlaceholderProjection(placeholderProjection: FirPlaceholderProjection) { - visitElement(placeholderProjection) - } - - open fun visitTypeProjectionWithVariance(typeProjectionWithVariance: FirTypeProjectionWithVariance) { - visitElement(typeProjectionWithVariance) - } - - open fun visitArgumentList(argumentList: FirArgumentList) { - visitElement(argumentList) - } - - open fun visitCall(call: FirCall) { - visitElement(call) - } - - open fun visitAnnotation(annotation: FirAnnotation) { - visitElement(annotation) - } - - open fun visitAnnotationCall(annotationCall: FirAnnotationCall) { - visitElement(annotationCall) - } - - open fun visitAnnotationArgumentMapping(annotationArgumentMapping: FirAnnotationArgumentMapping) { - visitElement(annotationArgumentMapping) - } - - open fun visitErrorAnnotationCall(errorAnnotationCall: FirErrorAnnotationCall) { - visitElement(errorAnnotationCall) - } - - open fun visitComparisonExpression(comparisonExpression: FirComparisonExpression) { - visitElement(comparisonExpression) - } - - open fun visitTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall) { - visitElement(typeOperatorCall) - } - - open fun visitAssignmentOperatorStatement(assignmentOperatorStatement: FirAssignmentOperatorStatement) { - visitElement(assignmentOperatorStatement) - } - - open fun visitIncrementDecrementExpression(incrementDecrementExpression: FirIncrementDecrementExpression) { - visitElement(incrementDecrementExpression) - } - - open fun visitEqualityOperatorCall(equalityOperatorCall: FirEqualityOperatorCall) { - visitElement(equalityOperatorCall) - } - - open fun visitWhenExpression(whenExpression: FirWhenExpression) { - visitElement(whenExpression) - } - - open fun visitWhenBranch(whenBranch: FirWhenBranch) { - visitElement(whenBranch) - } - - open fun visitContextReceiverArgumentListOwner(contextReceiverArgumentListOwner: FirContextReceiverArgumentListOwner) { - visitElement(contextReceiverArgumentListOwner) - } - - open fun visitCheckNotNullCall(checkNotNullCall: FirCheckNotNullCall) { - visitElement(checkNotNullCall) - } - - open fun visitElvisExpression(elvisExpression: FirElvisExpression) { - visitElement(elvisExpression) - } - - open fun visitArrayLiteral(arrayLiteral: FirArrayLiteral) { - visitElement(arrayLiteral) - } - - open fun visitAugmentedArraySetCall(augmentedArraySetCall: FirAugmentedArraySetCall) { - visitElement(augmentedArraySetCall) - } - - open fun visitClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression) { - visitElement(classReferenceExpression) - } - - open fun visitErrorExpression(errorExpression: FirErrorExpression) { - visitElement(errorExpression) - } - - open fun visitErrorFunction(errorFunction: FirErrorFunction) { - visitElement(errorFunction) - } - - open fun visitErrorProperty(errorProperty: FirErrorProperty) { - visitElement(errorProperty) - } - - open fun visitErrorPrimaryConstructor(errorPrimaryConstructor: FirErrorPrimaryConstructor) { - visitElement(errorPrimaryConstructor) - } - - open fun visitDanglingModifierList(danglingModifierList: FirDanglingModifierList) { - visitElement(danglingModifierList) - } - - open fun visitQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression) { - visitElement(qualifiedAccessExpression) - } - - open fun visitQualifiedErrorAccessExpression(qualifiedErrorAccessExpression: FirQualifiedErrorAccessExpression) { - visitElement(qualifiedErrorAccessExpression) - } - - open fun visitPropertyAccessExpression(propertyAccessExpression: FirPropertyAccessExpression) { - visitElement(propertyAccessExpression) - } - - open fun visitFunctionCall(functionCall: FirFunctionCall) { - visitElement(functionCall) - } - - open fun visitIntegerLiteralOperatorCall(integerLiteralOperatorCall: FirIntegerLiteralOperatorCall) { - visitElement(integerLiteralOperatorCall) - } - - open fun visitImplicitInvokeCall(implicitInvokeCall: FirImplicitInvokeCall) { - visitElement(implicitInvokeCall) - } - - open fun visitDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall) { - visitElement(delegatedConstructorCall) - } - - open fun visitMultiDelegatedConstructorCall(multiDelegatedConstructorCall: FirMultiDelegatedConstructorCall) { - visitElement(multiDelegatedConstructorCall) - } - - open fun visitComponentCall(componentCall: FirComponentCall) { - visitElement(componentCall) - } - - open fun visitCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess) { - visitElement(callableReferenceAccess) - } - - open fun visitThisReceiverExpression(thisReceiverExpression: FirThisReceiverExpression) { - visitElement(thisReceiverExpression) - } - - open fun visitInaccessibleReceiverExpression(inaccessibleReceiverExpression: FirInaccessibleReceiverExpression) { - visitElement(inaccessibleReceiverExpression) - } - - open fun visitSmartCastExpression(smartCastExpression: FirSmartCastExpression) { - visitElement(smartCastExpression) - } - - open fun visitSafeCallExpression(safeCallExpression: FirSafeCallExpression) { - visitElement(safeCallExpression) - } - - open fun visitCheckedSafeCallSubject(checkedSafeCallSubject: FirCheckedSafeCallSubject) { - visitElement(checkedSafeCallSubject) - } - - open fun visitGetClassCall(getClassCall: FirGetClassCall) { - visitElement(getClassCall) - } - - open fun visitWrappedExpression(wrappedExpression: FirWrappedExpression) { - visitElement(wrappedExpression) - } - - open fun visitWrappedArgumentExpression(wrappedArgumentExpression: FirWrappedArgumentExpression) { - visitElement(wrappedArgumentExpression) - } - - open fun visitLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression) { - visitElement(lambdaArgumentExpression) - } - - open fun visitSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression) { - visitElement(spreadArgumentExpression) - } - - open fun visitNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression) { - visitElement(namedArgumentExpression) - } - - open fun visitVarargArgumentsExpression(varargArgumentsExpression: FirVarargArgumentsExpression) { - visitElement(varargArgumentsExpression) - } - - open fun visitResolvedQualifier(resolvedQualifier: FirResolvedQualifier) { - visitElement(resolvedQualifier) - } - - open fun visitErrorResolvedQualifier(errorResolvedQualifier: FirErrorResolvedQualifier) { - visitElement(errorResolvedQualifier) - } - - open fun visitResolvedReifiedParameterReference(resolvedReifiedParameterReference: FirResolvedReifiedParameterReference) { - visitElement(resolvedReifiedParameterReference) - } - - open fun visitReturnExpression(returnExpression: FirReturnExpression) { - visitElement(returnExpression) - } - - open fun visitStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall) { - visitElement(stringConcatenationCall) - } - - open fun visitThrowExpression(throwExpression: FirThrowExpression) { - visitElement(throwExpression) - } - - open fun visitVariableAssignment(variableAssignment: FirVariableAssignment) { - visitElement(variableAssignment) - } - - open fun visitWhenSubjectExpression(whenSubjectExpression: FirWhenSubjectExpression) { - visitElement(whenSubjectExpression) - } - - open fun visitDesugaredAssignmentValueReferenceExpression(desugaredAssignmentValueReferenceExpression: FirDesugaredAssignmentValueReferenceExpression) { - visitElement(desugaredAssignmentValueReferenceExpression) - } - - open fun visitWrappedDelegateExpression(wrappedDelegateExpression: FirWrappedDelegateExpression) { - visitElement(wrappedDelegateExpression) - } - - open fun visitEnumEntryDeserializedAccessExpression(enumEntryDeserializedAccessExpression: FirEnumEntryDeserializedAccessExpression) { - visitElement(enumEntryDeserializedAccessExpression) - } - - open fun visitNamedReference(namedReference: FirNamedReference) { - visitElement(namedReference) - } - - open fun visitNamedReferenceWithCandidateBase(namedReferenceWithCandidateBase: FirNamedReferenceWithCandidateBase) { - visitElement(namedReferenceWithCandidateBase) - } - - open fun visitErrorNamedReference(errorNamedReference: FirErrorNamedReference) { - visitElement(errorNamedReference) - } - - open fun visitFromMissingDependenciesNamedReference(fromMissingDependenciesNamedReference: FirFromMissingDependenciesNamedReference) { - visitElement(fromMissingDependenciesNamedReference) - } - - open fun visitSuperReference(superReference: FirSuperReference) { - visitElement(superReference) - } - - open fun visitThisReference(thisReference: FirThisReference) { - visitElement(thisReference) - } - - open fun visitControlFlowGraphReference(controlFlowGraphReference: FirControlFlowGraphReference) { - visitElement(controlFlowGraphReference) - } - - open fun visitResolvedNamedReference(resolvedNamedReference: FirResolvedNamedReference) { - visitElement(resolvedNamedReference) - } - - open fun visitResolvedErrorReference(resolvedErrorReference: FirResolvedErrorReference) { - visitElement(resolvedErrorReference) - } - - open fun visitDelegateFieldReference(delegateFieldReference: FirDelegateFieldReference) { - visitElement(delegateFieldReference) - } - - open fun visitBackingFieldReference(backingFieldReference: FirBackingFieldReference) { - visitElement(backingFieldReference) - } - - open fun visitResolvedCallableReference(resolvedCallableReference: FirResolvedCallableReference) { - visitElement(resolvedCallableReference) - } - - open fun visitResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef) { - visitElement(resolvedTypeRef) - } - - open fun visitErrorTypeRef(errorTypeRef: FirErrorTypeRef) { - visitElement(errorTypeRef) - } - - open fun visitTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability) { - visitElement(typeRefWithNullability) - } - - open fun visitUserTypeRef(userTypeRef: FirUserTypeRef) { - visitElement(userTypeRef) - } - - open fun visitDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef) { - visitElement(dynamicTypeRef) - } - - open fun visitFunctionTypeRef(functionTypeRef: FirFunctionTypeRef) { - visitElement(functionTypeRef) - } - - open fun visitIntersectionTypeRef(intersectionTypeRef: FirIntersectionTypeRef) { - visitElement(intersectionTypeRef) - } - - open fun visitImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef) { - visitElement(implicitTypeRef) - } - - open fun visitContractElementDeclaration(contractElementDeclaration: FirContractElementDeclaration) { - visitElement(contractElementDeclaration) - } - - open fun visitEffectDeclaration(effectDeclaration: FirEffectDeclaration) { - visitElement(effectDeclaration) - } - - open fun visitContractDescription(contractDescription: FirContractDescription) { - visitElement(contractDescription) - } - - open fun visitLegacyRawContractDescription(legacyRawContractDescription: FirLegacyRawContractDescription) { - visitElement(legacyRawContractDescription) - } - - open fun visitRawContractDescription(rawContractDescription: FirRawContractDescription) { - visitElement(rawContractDescription) - } - - open fun visitResolvedContractDescription(resolvedContractDescription: FirResolvedContractDescription) { - visitElement(resolvedContractDescription) - } final override fun visitElement(element: FirElement, data: Nothing?) { visitElement(element) } + abstract fun visitElement(element: FirElement) + final override fun visitAnnotationContainer(annotationContainer: FirAnnotationContainer, data: Nothing?) { visitAnnotationContainer(annotationContainer) } + open fun visitAnnotationContainer(annotationContainer: FirAnnotationContainer) { + visitElement(annotationContainer) + } + final override fun visitTypeRef(typeRef: FirTypeRef, data: Nothing?) { visitTypeRef(typeRef) } + open fun visitTypeRef(typeRef: FirTypeRef) { + visitElement(typeRef) + } + final override fun visitReference(reference: FirReference, data: Nothing?) { visitReference(reference) } + open fun visitReference(reference: FirReference) { + visitElement(reference) + } + final override fun visitLabel(label: FirLabel, data: Nothing?) { visitLabel(label) } + open fun visitLabel(label: FirLabel) { + visitElement(label) + } + final override fun visitResolvable(resolvable: FirResolvable, data: Nothing?) { visitResolvable(resolvable) } + open fun visitResolvable(resolvable: FirResolvable) { + visitElement(resolvable) + } + final override fun visitTargetElement(targetElement: FirTargetElement, data: Nothing?) { visitTargetElement(targetElement) } + open fun visitTargetElement(targetElement: FirTargetElement) { + visitElement(targetElement) + } + final override fun visitDeclarationStatus(declarationStatus: FirDeclarationStatus, data: Nothing?) { visitDeclarationStatus(declarationStatus) } + open fun visitDeclarationStatus(declarationStatus: FirDeclarationStatus) { + visitElement(declarationStatus) + } + final override fun visitResolvedDeclarationStatus(resolvedDeclarationStatus: FirResolvedDeclarationStatus, data: Nothing?) { visitResolvedDeclarationStatus(resolvedDeclarationStatus) } + open fun visitResolvedDeclarationStatus(resolvedDeclarationStatus: FirResolvedDeclarationStatus) { + visitElement(resolvedDeclarationStatus) + } + final override fun visitControlFlowGraphOwner(controlFlowGraphOwner: FirControlFlowGraphOwner, data: Nothing?) { visitControlFlowGraphOwner(controlFlowGraphOwner) } + open fun visitControlFlowGraphOwner(controlFlowGraphOwner: FirControlFlowGraphOwner) { + visitElement(controlFlowGraphOwner) + } + final override fun visitStatement(statement: FirStatement, data: Nothing?) { visitStatement(statement) } + open fun visitStatement(statement: FirStatement) { + visitElement(statement) + } + final override fun visitExpression(expression: FirExpression, data: Nothing?) { visitExpression(expression) } + open fun visitExpression(expression: FirExpression) { + visitElement(expression) + } + final override fun visitLazyExpression(lazyExpression: FirLazyExpression, data: Nothing?) { visitLazyExpression(lazyExpression) } + open fun visitLazyExpression(lazyExpression: FirLazyExpression) { + visitElement(lazyExpression) + } + final override fun visitContextReceiver(contextReceiver: FirContextReceiver, data: Nothing?) { visitContextReceiver(contextReceiver) } + open fun visitContextReceiver(contextReceiver: FirContextReceiver) { + visitElement(contextReceiver) + } + final override fun visitElementWithResolveState(elementWithResolveState: FirElementWithResolveState, data: Nothing?) { visitElementWithResolveState(elementWithResolveState) } + open fun visitElementWithResolveState(elementWithResolveState: FirElementWithResolveState) { + visitElement(elementWithResolveState) + } + final override fun visitFileAnnotationsContainer(fileAnnotationsContainer: FirFileAnnotationsContainer, data: Nothing?) { visitFileAnnotationsContainer(fileAnnotationsContainer) } + open fun visitFileAnnotationsContainer(fileAnnotationsContainer: FirFileAnnotationsContainer) { + visitElement(fileAnnotationsContainer) + } + final override fun visitDeclaration(declaration: FirDeclaration, data: Nothing?) { visitDeclaration(declaration) } + open fun visitDeclaration(declaration: FirDeclaration) { + visitElement(declaration) + } + final override fun visitTypeParameterRefsOwner(typeParameterRefsOwner: FirTypeParameterRefsOwner, data: Nothing?) { visitTypeParameterRefsOwner(typeParameterRefsOwner) } + open fun visitTypeParameterRefsOwner(typeParameterRefsOwner: FirTypeParameterRefsOwner) { + visitElement(typeParameterRefsOwner) + } + final override fun visitTypeParametersOwner(typeParametersOwner: FirTypeParametersOwner, data: Nothing?) { visitTypeParametersOwner(typeParametersOwner) } + open fun visitTypeParametersOwner(typeParametersOwner: FirTypeParametersOwner) { + visitElement(typeParametersOwner) + } + final override fun visitMemberDeclaration(memberDeclaration: FirMemberDeclaration, data: Nothing?) { visitMemberDeclaration(memberDeclaration) } + open fun visitMemberDeclaration(memberDeclaration: FirMemberDeclaration) { + visitElement(memberDeclaration) + } + final override fun visitAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, data: Nothing?) { visitAnonymousInitializer(anonymousInitializer) } + open fun visitAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer) { + visitElement(anonymousInitializer) + } + final override fun visitCallableDeclaration(callableDeclaration: FirCallableDeclaration, data: Nothing?) { visitCallableDeclaration(callableDeclaration) } + open fun visitCallableDeclaration(callableDeclaration: FirCallableDeclaration) { + visitElement(callableDeclaration) + } + final override fun visitTypeParameterRef(typeParameterRef: FirTypeParameterRef, data: Nothing?) { visitTypeParameterRef(typeParameterRef) } + open fun visitTypeParameterRef(typeParameterRef: FirTypeParameterRef) { + visitElement(typeParameterRef) + } + final override fun visitTypeParameter(typeParameter: FirTypeParameter, data: Nothing?) { visitTypeParameter(typeParameter) } + open fun visitTypeParameter(typeParameter: FirTypeParameter) { + visitElement(typeParameter) + } + final override fun visitConstructedClassTypeParameterRef(constructedClassTypeParameterRef: FirConstructedClassTypeParameterRef, data: Nothing?) { visitConstructedClassTypeParameterRef(constructedClassTypeParameterRef) } + open fun visitConstructedClassTypeParameterRef(constructedClassTypeParameterRef: FirConstructedClassTypeParameterRef) { + visitElement(constructedClassTypeParameterRef) + } + final override fun visitOuterClassTypeParameterRef(outerClassTypeParameterRef: FirOuterClassTypeParameterRef, data: Nothing?) { visitOuterClassTypeParameterRef(outerClassTypeParameterRef) } + open fun visitOuterClassTypeParameterRef(outerClassTypeParameterRef: FirOuterClassTypeParameterRef) { + visitElement(outerClassTypeParameterRef) + } + final override fun visitVariable(variable: FirVariable, data: Nothing?) { visitVariable(variable) } + open fun visitVariable(variable: FirVariable) { + visitElement(variable) + } + final override fun visitValueParameter(valueParameter: FirValueParameter, data: Nothing?) { visitValueParameter(valueParameter) } + open fun visitValueParameter(valueParameter: FirValueParameter) { + visitElement(valueParameter) + } + final override fun visitReceiverParameter(receiverParameter: FirReceiverParameter, data: Nothing?) { visitReceiverParameter(receiverParameter) } + open fun visitReceiverParameter(receiverParameter: FirReceiverParameter) { + visitElement(receiverParameter) + } + final override fun visitProperty(property: FirProperty, data: Nothing?) { visitProperty(property) } + open fun visitProperty(property: FirProperty) { + visitElement(property) + } + final override fun visitField(field: FirField, data: Nothing?) { visitField(field) } + open fun visitField(field: FirField) { + visitElement(field) + } + final override fun visitEnumEntry(enumEntry: FirEnumEntry, data: Nothing?) { visitEnumEntry(enumEntry) } + open fun visitEnumEntry(enumEntry: FirEnumEntry) { + visitElement(enumEntry) + } + final override fun visitFunctionTypeParameter(functionTypeParameter: FirFunctionTypeParameter, data: Nothing?) { visitFunctionTypeParameter(functionTypeParameter) } + open fun visitFunctionTypeParameter(functionTypeParameter: FirFunctionTypeParameter) { + visitElement(functionTypeParameter) + } + final override fun visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, data: Nothing?) { visitClassLikeDeclaration(classLikeDeclaration) } + open fun visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration) { + visitElement(classLikeDeclaration) + } + final override fun visitClass(klass: FirClass, data: Nothing?) { visitClass(klass) } + open fun visitClass(klass: FirClass) { + visitElement(klass) + } + final override fun visitRegularClass(regularClass: FirRegularClass, data: Nothing?) { visitRegularClass(regularClass) } + open fun visitRegularClass(regularClass: FirRegularClass) { + visitElement(regularClass) + } + final override fun visitTypeAlias(typeAlias: FirTypeAlias, data: Nothing?) { visitTypeAlias(typeAlias) } + open fun visitTypeAlias(typeAlias: FirTypeAlias) { + visitElement(typeAlias) + } + final override fun visitFunction(function: FirFunction, data: Nothing?) { visitFunction(function) } + open fun visitFunction(function: FirFunction) { + visitElement(function) + } + final override fun visitContractDescriptionOwner(contractDescriptionOwner: FirContractDescriptionOwner, data: Nothing?) { visitContractDescriptionOwner(contractDescriptionOwner) } + open fun visitContractDescriptionOwner(contractDescriptionOwner: FirContractDescriptionOwner) { + visitElement(contractDescriptionOwner) + } + final override fun visitSimpleFunction(simpleFunction: FirSimpleFunction, data: Nothing?) { visitSimpleFunction(simpleFunction) } + open fun visitSimpleFunction(simpleFunction: FirSimpleFunction) { + visitElement(simpleFunction) + } + final override fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: Nothing?) { visitPropertyAccessor(propertyAccessor) } + open fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor) { + visitElement(propertyAccessor) + } + final override fun visitBackingField(backingField: FirBackingField, data: Nothing?) { visitBackingField(backingField) } + open fun visitBackingField(backingField: FirBackingField) { + visitElement(backingField) + } + final override fun visitConstructor(constructor: FirConstructor, data: Nothing?) { visitConstructor(constructor) } + open fun visitConstructor(constructor: FirConstructor) { + visitElement(constructor) + } + final override fun visitFile(file: FirFile, data: Nothing?) { visitFile(file) } + open fun visitFile(file: FirFile) { + visitElement(file) + } + final override fun visitScript(script: FirScript, data: Nothing?) { visitScript(script) } + open fun visitScript(script: FirScript) { + visitElement(script) + } + final override fun visitCodeFragment(codeFragment: FirCodeFragment, data: Nothing?) { visitCodeFragment(codeFragment) } + open fun visitCodeFragment(codeFragment: FirCodeFragment) { + visitElement(codeFragment) + } + final override fun visitPackageDirective(packageDirective: FirPackageDirective, data: Nothing?) { visitPackageDirective(packageDirective) } + open fun visitPackageDirective(packageDirective: FirPackageDirective) { + visitElement(packageDirective) + } + final override fun visitAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: Nothing?) { visitAnonymousFunction(anonymousFunction) } + open fun visitAnonymousFunction(anonymousFunction: FirAnonymousFunction) { + visitElement(anonymousFunction) + } + final override fun visitAnonymousFunctionExpression(anonymousFunctionExpression: FirAnonymousFunctionExpression, data: Nothing?) { visitAnonymousFunctionExpression(anonymousFunctionExpression) } + open fun visitAnonymousFunctionExpression(anonymousFunctionExpression: FirAnonymousFunctionExpression) { + visitElement(anonymousFunctionExpression) + } + final override fun visitAnonymousObject(anonymousObject: FirAnonymousObject, data: Nothing?) { visitAnonymousObject(anonymousObject) } + open fun visitAnonymousObject(anonymousObject: FirAnonymousObject) { + visitElement(anonymousObject) + } + final override fun visitAnonymousObjectExpression(anonymousObjectExpression: FirAnonymousObjectExpression, data: Nothing?) { visitAnonymousObjectExpression(anonymousObjectExpression) } + open fun visitAnonymousObjectExpression(anonymousObjectExpression: FirAnonymousObjectExpression) { + visitElement(anonymousObjectExpression) + } + final override fun visitDiagnosticHolder(diagnosticHolder: FirDiagnosticHolder, data: Nothing?) { visitDiagnosticHolder(diagnosticHolder) } + open fun visitDiagnosticHolder(diagnosticHolder: FirDiagnosticHolder) { + visitElement(diagnosticHolder) + } + final override fun visitImport(import: FirImport, data: Nothing?) { visitImport(import) } + open fun visitImport(import: FirImport) { + visitElement(import) + } + final override fun visitResolvedImport(resolvedImport: FirResolvedImport, data: Nothing?) { visitResolvedImport(resolvedImport) } + open fun visitResolvedImport(resolvedImport: FirResolvedImport) { + visitElement(resolvedImport) + } + final override fun visitErrorImport(errorImport: FirErrorImport, data: Nothing?) { visitErrorImport(errorImport) } + open fun visitErrorImport(errorImport: FirErrorImport) { + visitElement(errorImport) + } + final override fun visitLoop(loop: FirLoop, data: Nothing?) { visitLoop(loop) } + open fun visitLoop(loop: FirLoop) { + visitElement(loop) + } + final override fun visitErrorLoop(errorLoop: FirErrorLoop, data: Nothing?) { visitErrorLoop(errorLoop) } + open fun visitErrorLoop(errorLoop: FirErrorLoop) { + visitElement(errorLoop) + } + final override fun visitDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: Nothing?) { visitDoWhileLoop(doWhileLoop) } + open fun visitDoWhileLoop(doWhileLoop: FirDoWhileLoop) { + visitElement(doWhileLoop) + } + final override fun visitWhileLoop(whileLoop: FirWhileLoop, data: Nothing?) { visitWhileLoop(whileLoop) } + open fun visitWhileLoop(whileLoop: FirWhileLoop) { + visitElement(whileLoop) + } + final override fun visitBlock(block: FirBlock, data: Nothing?) { visitBlock(block) } + open fun visitBlock(block: FirBlock) { + visitElement(block) + } + final override fun visitLazyBlock(lazyBlock: FirLazyBlock, data: Nothing?) { visitLazyBlock(lazyBlock) } + open fun visitLazyBlock(lazyBlock: FirLazyBlock) { + visitElement(lazyBlock) + } + final override fun visitBinaryLogicExpression(binaryLogicExpression: FirBinaryLogicExpression, data: Nothing?) { visitBinaryLogicExpression(binaryLogicExpression) } + open fun visitBinaryLogicExpression(binaryLogicExpression: FirBinaryLogicExpression) { + visitElement(binaryLogicExpression) + } + final override fun visitJump(jump: FirJump, data: Nothing?) { visitJump(jump) } + open fun visitJump(jump: FirJump) { + visitElement(jump) + } + final override fun visitLoopJump(loopJump: FirLoopJump, data: Nothing?) { visitLoopJump(loopJump) } + open fun visitLoopJump(loopJump: FirLoopJump) { + visitElement(loopJump) + } + final override fun visitBreakExpression(breakExpression: FirBreakExpression, data: Nothing?) { visitBreakExpression(breakExpression) } + open fun visitBreakExpression(breakExpression: FirBreakExpression) { + visitElement(breakExpression) + } + final override fun visitContinueExpression(continueExpression: FirContinueExpression, data: Nothing?) { visitContinueExpression(continueExpression) } + open fun visitContinueExpression(continueExpression: FirContinueExpression) { + visitElement(continueExpression) + } + final override fun visitCatch(catch: FirCatch, data: Nothing?) { visitCatch(catch) } + open fun visitCatch(catch: FirCatch) { + visitElement(catch) + } + final override fun visitTryExpression(tryExpression: FirTryExpression, data: Nothing?) { visitTryExpression(tryExpression) } + open fun visitTryExpression(tryExpression: FirTryExpression) { + visitElement(tryExpression) + } + final override fun visitConstExpression(constExpression: FirConstExpression, data: Nothing?) { visitConstExpression(constExpression) } + open fun visitConstExpression(constExpression: FirConstExpression) { + visitElement(constExpression) + } + final override fun visitTypeProjection(typeProjection: FirTypeProjection, data: Nothing?) { visitTypeProjection(typeProjection) } + open fun visitTypeProjection(typeProjection: FirTypeProjection) { + visitElement(typeProjection) + } + final override fun visitStarProjection(starProjection: FirStarProjection, data: Nothing?) { visitStarProjection(starProjection) } + open fun visitStarProjection(starProjection: FirStarProjection) { + visitElement(starProjection) + } + final override fun visitPlaceholderProjection(placeholderProjection: FirPlaceholderProjection, data: Nothing?) { visitPlaceholderProjection(placeholderProjection) } + open fun visitPlaceholderProjection(placeholderProjection: FirPlaceholderProjection) { + visitElement(placeholderProjection) + } + final override fun visitTypeProjectionWithVariance(typeProjectionWithVariance: FirTypeProjectionWithVariance, data: Nothing?) { visitTypeProjectionWithVariance(typeProjectionWithVariance) } + open fun visitTypeProjectionWithVariance(typeProjectionWithVariance: FirTypeProjectionWithVariance) { + visitElement(typeProjectionWithVariance) + } + final override fun visitArgumentList(argumentList: FirArgumentList, data: Nothing?) { visitArgumentList(argumentList) } + open fun visitArgumentList(argumentList: FirArgumentList) { + visitElement(argumentList) + } + final override fun visitCall(call: FirCall, data: Nothing?) { visitCall(call) } + open fun visitCall(call: FirCall) { + visitElement(call) + } + final override fun visitAnnotation(annotation: FirAnnotation, data: Nothing?) { visitAnnotation(annotation) } + open fun visitAnnotation(annotation: FirAnnotation) { + visitElement(annotation) + } + final override fun visitAnnotationCall(annotationCall: FirAnnotationCall, data: Nothing?) { visitAnnotationCall(annotationCall) } + open fun visitAnnotationCall(annotationCall: FirAnnotationCall) { + visitElement(annotationCall) + } + final override fun visitAnnotationArgumentMapping(annotationArgumentMapping: FirAnnotationArgumentMapping, data: Nothing?) { visitAnnotationArgumentMapping(annotationArgumentMapping) } + open fun visitAnnotationArgumentMapping(annotationArgumentMapping: FirAnnotationArgumentMapping) { + visitElement(annotationArgumentMapping) + } + final override fun visitErrorAnnotationCall(errorAnnotationCall: FirErrorAnnotationCall, data: Nothing?) { visitErrorAnnotationCall(errorAnnotationCall) } + open fun visitErrorAnnotationCall(errorAnnotationCall: FirErrorAnnotationCall) { + visitElement(errorAnnotationCall) + } + final override fun visitComparisonExpression(comparisonExpression: FirComparisonExpression, data: Nothing?) { visitComparisonExpression(comparisonExpression) } + open fun visitComparisonExpression(comparisonExpression: FirComparisonExpression) { + visitElement(comparisonExpression) + } + final override fun visitTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: Nothing?) { visitTypeOperatorCall(typeOperatorCall) } + open fun visitTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall) { + visitElement(typeOperatorCall) + } + final override fun visitAssignmentOperatorStatement(assignmentOperatorStatement: FirAssignmentOperatorStatement, data: Nothing?) { visitAssignmentOperatorStatement(assignmentOperatorStatement) } + open fun visitAssignmentOperatorStatement(assignmentOperatorStatement: FirAssignmentOperatorStatement) { + visitElement(assignmentOperatorStatement) + } + final override fun visitIncrementDecrementExpression(incrementDecrementExpression: FirIncrementDecrementExpression, data: Nothing?) { visitIncrementDecrementExpression(incrementDecrementExpression) } + open fun visitIncrementDecrementExpression(incrementDecrementExpression: FirIncrementDecrementExpression) { + visitElement(incrementDecrementExpression) + } + final override fun visitEqualityOperatorCall(equalityOperatorCall: FirEqualityOperatorCall, data: Nothing?) { visitEqualityOperatorCall(equalityOperatorCall) } + open fun visitEqualityOperatorCall(equalityOperatorCall: FirEqualityOperatorCall) { + visitElement(equalityOperatorCall) + } + final override fun visitWhenExpression(whenExpression: FirWhenExpression, data: Nothing?) { visitWhenExpression(whenExpression) } + open fun visitWhenExpression(whenExpression: FirWhenExpression) { + visitElement(whenExpression) + } + final override fun visitWhenBranch(whenBranch: FirWhenBranch, data: Nothing?) { visitWhenBranch(whenBranch) } + open fun visitWhenBranch(whenBranch: FirWhenBranch) { + visitElement(whenBranch) + } + final override fun visitContextReceiverArgumentListOwner(contextReceiverArgumentListOwner: FirContextReceiverArgumentListOwner, data: Nothing?) { visitContextReceiverArgumentListOwner(contextReceiverArgumentListOwner) } + open fun visitContextReceiverArgumentListOwner(contextReceiverArgumentListOwner: FirContextReceiverArgumentListOwner) { + visitElement(contextReceiverArgumentListOwner) + } + final override fun visitCheckNotNullCall(checkNotNullCall: FirCheckNotNullCall, data: Nothing?) { visitCheckNotNullCall(checkNotNullCall) } + open fun visitCheckNotNullCall(checkNotNullCall: FirCheckNotNullCall) { + visitElement(checkNotNullCall) + } + final override fun visitElvisExpression(elvisExpression: FirElvisExpression, data: Nothing?) { visitElvisExpression(elvisExpression) } + open fun visitElvisExpression(elvisExpression: FirElvisExpression) { + visitElement(elvisExpression) + } + final override fun visitArrayLiteral(arrayLiteral: FirArrayLiteral, data: Nothing?) { visitArrayLiteral(arrayLiteral) } + open fun visitArrayLiteral(arrayLiteral: FirArrayLiteral) { + visitElement(arrayLiteral) + } + final override fun visitAugmentedArraySetCall(augmentedArraySetCall: FirAugmentedArraySetCall, data: Nothing?) { visitAugmentedArraySetCall(augmentedArraySetCall) } + open fun visitAugmentedArraySetCall(augmentedArraySetCall: FirAugmentedArraySetCall) { + visitElement(augmentedArraySetCall) + } + final override fun visitClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression, data: Nothing?) { visitClassReferenceExpression(classReferenceExpression) } + open fun visitClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression) { + visitElement(classReferenceExpression) + } + final override fun visitErrorExpression(errorExpression: FirErrorExpression, data: Nothing?) { visitErrorExpression(errorExpression) } + open fun visitErrorExpression(errorExpression: FirErrorExpression) { + visitElement(errorExpression) + } + final override fun visitErrorFunction(errorFunction: FirErrorFunction, data: Nothing?) { visitErrorFunction(errorFunction) } + open fun visitErrorFunction(errorFunction: FirErrorFunction) { + visitElement(errorFunction) + } + final override fun visitErrorProperty(errorProperty: FirErrorProperty, data: Nothing?) { visitErrorProperty(errorProperty) } + open fun visitErrorProperty(errorProperty: FirErrorProperty) { + visitElement(errorProperty) + } + final override fun visitErrorPrimaryConstructor(errorPrimaryConstructor: FirErrorPrimaryConstructor, data: Nothing?) { visitErrorPrimaryConstructor(errorPrimaryConstructor) } + open fun visitErrorPrimaryConstructor(errorPrimaryConstructor: FirErrorPrimaryConstructor) { + visitElement(errorPrimaryConstructor) + } + final override fun visitDanglingModifierList(danglingModifierList: FirDanglingModifierList, data: Nothing?) { visitDanglingModifierList(danglingModifierList) } + open fun visitDanglingModifierList(danglingModifierList: FirDanglingModifierList) { + visitElement(danglingModifierList) + } + final override fun visitQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression, data: Nothing?) { visitQualifiedAccessExpression(qualifiedAccessExpression) } + open fun visitQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression) { + visitElement(qualifiedAccessExpression) + } + final override fun visitQualifiedErrorAccessExpression(qualifiedErrorAccessExpression: FirQualifiedErrorAccessExpression, data: Nothing?) { visitQualifiedErrorAccessExpression(qualifiedErrorAccessExpression) } + open fun visitQualifiedErrorAccessExpression(qualifiedErrorAccessExpression: FirQualifiedErrorAccessExpression) { + visitElement(qualifiedErrorAccessExpression) + } + final override fun visitPropertyAccessExpression(propertyAccessExpression: FirPropertyAccessExpression, data: Nothing?) { visitPropertyAccessExpression(propertyAccessExpression) } + open fun visitPropertyAccessExpression(propertyAccessExpression: FirPropertyAccessExpression) { + visitElement(propertyAccessExpression) + } + final override fun visitFunctionCall(functionCall: FirFunctionCall, data: Nothing?) { visitFunctionCall(functionCall) } + open fun visitFunctionCall(functionCall: FirFunctionCall) { + visitElement(functionCall) + } + final override fun visitIntegerLiteralOperatorCall(integerLiteralOperatorCall: FirIntegerLiteralOperatorCall, data: Nothing?) { visitIntegerLiteralOperatorCall(integerLiteralOperatorCall) } + open fun visitIntegerLiteralOperatorCall(integerLiteralOperatorCall: FirIntegerLiteralOperatorCall) { + visitElement(integerLiteralOperatorCall) + } + final override fun visitImplicitInvokeCall(implicitInvokeCall: FirImplicitInvokeCall, data: Nothing?) { visitImplicitInvokeCall(implicitInvokeCall) } + open fun visitImplicitInvokeCall(implicitInvokeCall: FirImplicitInvokeCall) { + visitElement(implicitInvokeCall) + } + final override fun visitDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall, data: Nothing?) { visitDelegatedConstructorCall(delegatedConstructorCall) } + open fun visitDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall) { + visitElement(delegatedConstructorCall) + } + final override fun visitMultiDelegatedConstructorCall(multiDelegatedConstructorCall: FirMultiDelegatedConstructorCall, data: Nothing?) { visitMultiDelegatedConstructorCall(multiDelegatedConstructorCall) } + open fun visitMultiDelegatedConstructorCall(multiDelegatedConstructorCall: FirMultiDelegatedConstructorCall) { + visitElement(multiDelegatedConstructorCall) + } + final override fun visitComponentCall(componentCall: FirComponentCall, data: Nothing?) { visitComponentCall(componentCall) } + open fun visitComponentCall(componentCall: FirComponentCall) { + visitElement(componentCall) + } + final override fun visitCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess, data: Nothing?) { visitCallableReferenceAccess(callableReferenceAccess) } + open fun visitCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess) { + visitElement(callableReferenceAccess) + } + final override fun visitThisReceiverExpression(thisReceiverExpression: FirThisReceiverExpression, data: Nothing?) { visitThisReceiverExpression(thisReceiverExpression) } + open fun visitThisReceiverExpression(thisReceiverExpression: FirThisReceiverExpression) { + visitElement(thisReceiverExpression) + } + final override fun visitInaccessibleReceiverExpression(inaccessibleReceiverExpression: FirInaccessibleReceiverExpression, data: Nothing?) { visitInaccessibleReceiverExpression(inaccessibleReceiverExpression) } + open fun visitInaccessibleReceiverExpression(inaccessibleReceiverExpression: FirInaccessibleReceiverExpression) { + visitElement(inaccessibleReceiverExpression) + } + final override fun visitSmartCastExpression(smartCastExpression: FirSmartCastExpression, data: Nothing?) { visitSmartCastExpression(smartCastExpression) } + open fun visitSmartCastExpression(smartCastExpression: FirSmartCastExpression) { + visitElement(smartCastExpression) + } + final override fun visitSafeCallExpression(safeCallExpression: FirSafeCallExpression, data: Nothing?) { visitSafeCallExpression(safeCallExpression) } + open fun visitSafeCallExpression(safeCallExpression: FirSafeCallExpression) { + visitElement(safeCallExpression) + } + final override fun visitCheckedSafeCallSubject(checkedSafeCallSubject: FirCheckedSafeCallSubject, data: Nothing?) { visitCheckedSafeCallSubject(checkedSafeCallSubject) } + open fun visitCheckedSafeCallSubject(checkedSafeCallSubject: FirCheckedSafeCallSubject) { + visitElement(checkedSafeCallSubject) + } + final override fun visitGetClassCall(getClassCall: FirGetClassCall, data: Nothing?) { visitGetClassCall(getClassCall) } + open fun visitGetClassCall(getClassCall: FirGetClassCall) { + visitElement(getClassCall) + } + final override fun visitWrappedExpression(wrappedExpression: FirWrappedExpression, data: Nothing?) { visitWrappedExpression(wrappedExpression) } + open fun visitWrappedExpression(wrappedExpression: FirWrappedExpression) { + visitElement(wrappedExpression) + } + final override fun visitWrappedArgumentExpression(wrappedArgumentExpression: FirWrappedArgumentExpression, data: Nothing?) { visitWrappedArgumentExpression(wrappedArgumentExpression) } + open fun visitWrappedArgumentExpression(wrappedArgumentExpression: FirWrappedArgumentExpression) { + visitElement(wrappedArgumentExpression) + } + final override fun visitLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression, data: Nothing?) { visitLambdaArgumentExpression(lambdaArgumentExpression) } + open fun visitLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression) { + visitElement(lambdaArgumentExpression) + } + final override fun visitSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression, data: Nothing?) { visitSpreadArgumentExpression(spreadArgumentExpression) } + open fun visitSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression) { + visitElement(spreadArgumentExpression) + } + final override fun visitNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression, data: Nothing?) { visitNamedArgumentExpression(namedArgumentExpression) } + open fun visitNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression) { + visitElement(namedArgumentExpression) + } + final override fun visitVarargArgumentsExpression(varargArgumentsExpression: FirVarargArgumentsExpression, data: Nothing?) { visitVarargArgumentsExpression(varargArgumentsExpression) } + open fun visitVarargArgumentsExpression(varargArgumentsExpression: FirVarargArgumentsExpression) { + visitElement(varargArgumentsExpression) + } + final override fun visitResolvedQualifier(resolvedQualifier: FirResolvedQualifier, data: Nothing?) { visitResolvedQualifier(resolvedQualifier) } + open fun visitResolvedQualifier(resolvedQualifier: FirResolvedQualifier) { + visitElement(resolvedQualifier) + } + final override fun visitErrorResolvedQualifier(errorResolvedQualifier: FirErrorResolvedQualifier, data: Nothing?) { visitErrorResolvedQualifier(errorResolvedQualifier) } + open fun visitErrorResolvedQualifier(errorResolvedQualifier: FirErrorResolvedQualifier) { + visitElement(errorResolvedQualifier) + } + final override fun visitResolvedReifiedParameterReference(resolvedReifiedParameterReference: FirResolvedReifiedParameterReference, data: Nothing?) { visitResolvedReifiedParameterReference(resolvedReifiedParameterReference) } + open fun visitResolvedReifiedParameterReference(resolvedReifiedParameterReference: FirResolvedReifiedParameterReference) { + visitElement(resolvedReifiedParameterReference) + } + final override fun visitReturnExpression(returnExpression: FirReturnExpression, data: Nothing?) { visitReturnExpression(returnExpression) } + open fun visitReturnExpression(returnExpression: FirReturnExpression) { + visitElement(returnExpression) + } + final override fun visitStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall, data: Nothing?) { visitStringConcatenationCall(stringConcatenationCall) } + open fun visitStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall) { + visitElement(stringConcatenationCall) + } + final override fun visitThrowExpression(throwExpression: FirThrowExpression, data: Nothing?) { visitThrowExpression(throwExpression) } + open fun visitThrowExpression(throwExpression: FirThrowExpression) { + visitElement(throwExpression) + } + final override fun visitVariableAssignment(variableAssignment: FirVariableAssignment, data: Nothing?) { visitVariableAssignment(variableAssignment) } + open fun visitVariableAssignment(variableAssignment: FirVariableAssignment) { + visitElement(variableAssignment) + } + final override fun visitWhenSubjectExpression(whenSubjectExpression: FirWhenSubjectExpression, data: Nothing?) { visitWhenSubjectExpression(whenSubjectExpression) } + open fun visitWhenSubjectExpression(whenSubjectExpression: FirWhenSubjectExpression) { + visitElement(whenSubjectExpression) + } + final override fun visitDesugaredAssignmentValueReferenceExpression(desugaredAssignmentValueReferenceExpression: FirDesugaredAssignmentValueReferenceExpression, data: Nothing?) { visitDesugaredAssignmentValueReferenceExpression(desugaredAssignmentValueReferenceExpression) } + open fun visitDesugaredAssignmentValueReferenceExpression(desugaredAssignmentValueReferenceExpression: FirDesugaredAssignmentValueReferenceExpression) { + visitElement(desugaredAssignmentValueReferenceExpression) + } + final override fun visitWrappedDelegateExpression(wrappedDelegateExpression: FirWrappedDelegateExpression, data: Nothing?) { visitWrappedDelegateExpression(wrappedDelegateExpression) } + open fun visitWrappedDelegateExpression(wrappedDelegateExpression: FirWrappedDelegateExpression) { + visitElement(wrappedDelegateExpression) + } + final override fun visitEnumEntryDeserializedAccessExpression(enumEntryDeserializedAccessExpression: FirEnumEntryDeserializedAccessExpression, data: Nothing?) { visitEnumEntryDeserializedAccessExpression(enumEntryDeserializedAccessExpression) } + open fun visitEnumEntryDeserializedAccessExpression(enumEntryDeserializedAccessExpression: FirEnumEntryDeserializedAccessExpression) { + visitElement(enumEntryDeserializedAccessExpression) + } + final override fun visitNamedReference(namedReference: FirNamedReference, data: Nothing?) { visitNamedReference(namedReference) } + open fun visitNamedReference(namedReference: FirNamedReference) { + visitElement(namedReference) + } + final override fun visitNamedReferenceWithCandidateBase(namedReferenceWithCandidateBase: FirNamedReferenceWithCandidateBase, data: Nothing?) { visitNamedReferenceWithCandidateBase(namedReferenceWithCandidateBase) } + open fun visitNamedReferenceWithCandidateBase(namedReferenceWithCandidateBase: FirNamedReferenceWithCandidateBase) { + visitElement(namedReferenceWithCandidateBase) + } + final override fun visitErrorNamedReference(errorNamedReference: FirErrorNamedReference, data: Nothing?) { visitErrorNamedReference(errorNamedReference) } + open fun visitErrorNamedReference(errorNamedReference: FirErrorNamedReference) { + visitElement(errorNamedReference) + } + final override fun visitFromMissingDependenciesNamedReference(fromMissingDependenciesNamedReference: FirFromMissingDependenciesNamedReference, data: Nothing?) { visitFromMissingDependenciesNamedReference(fromMissingDependenciesNamedReference) } + open fun visitFromMissingDependenciesNamedReference(fromMissingDependenciesNamedReference: FirFromMissingDependenciesNamedReference) { + visitElement(fromMissingDependenciesNamedReference) + } + final override fun visitSuperReference(superReference: FirSuperReference, data: Nothing?) { visitSuperReference(superReference) } + open fun visitSuperReference(superReference: FirSuperReference) { + visitElement(superReference) + } + final override fun visitThisReference(thisReference: FirThisReference, data: Nothing?) { visitThisReference(thisReference) } + open fun visitThisReference(thisReference: FirThisReference) { + visitElement(thisReference) + } + final override fun visitControlFlowGraphReference(controlFlowGraphReference: FirControlFlowGraphReference, data: Nothing?) { visitControlFlowGraphReference(controlFlowGraphReference) } + open fun visitControlFlowGraphReference(controlFlowGraphReference: FirControlFlowGraphReference) { + visitElement(controlFlowGraphReference) + } + final override fun visitResolvedNamedReference(resolvedNamedReference: FirResolvedNamedReference, data: Nothing?) { visitResolvedNamedReference(resolvedNamedReference) } + open fun visitResolvedNamedReference(resolvedNamedReference: FirResolvedNamedReference) { + visitElement(resolvedNamedReference) + } + final override fun visitResolvedErrorReference(resolvedErrorReference: FirResolvedErrorReference, data: Nothing?) { visitResolvedErrorReference(resolvedErrorReference) } + open fun visitResolvedErrorReference(resolvedErrorReference: FirResolvedErrorReference) { + visitElement(resolvedErrorReference) + } + final override fun visitDelegateFieldReference(delegateFieldReference: FirDelegateFieldReference, data: Nothing?) { visitDelegateFieldReference(delegateFieldReference) } + open fun visitDelegateFieldReference(delegateFieldReference: FirDelegateFieldReference) { + visitElement(delegateFieldReference) + } + final override fun visitBackingFieldReference(backingFieldReference: FirBackingFieldReference, data: Nothing?) { visitBackingFieldReference(backingFieldReference) } + open fun visitBackingFieldReference(backingFieldReference: FirBackingFieldReference) { + visitElement(backingFieldReference) + } + final override fun visitResolvedCallableReference(resolvedCallableReference: FirResolvedCallableReference, data: Nothing?) { visitResolvedCallableReference(resolvedCallableReference) } + open fun visitResolvedCallableReference(resolvedCallableReference: FirResolvedCallableReference) { + visitElement(resolvedCallableReference) + } + final override fun visitResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: Nothing?) { visitResolvedTypeRef(resolvedTypeRef) } + open fun visitResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef) { + visitElement(resolvedTypeRef) + } + final override fun visitErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: Nothing?) { visitErrorTypeRef(errorTypeRef) } + open fun visitErrorTypeRef(errorTypeRef: FirErrorTypeRef) { + visitElement(errorTypeRef) + } + final override fun visitTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability, data: Nothing?) { visitTypeRefWithNullability(typeRefWithNullability) } + open fun visitTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability) { + visitElement(typeRefWithNullability) + } + final override fun visitUserTypeRef(userTypeRef: FirUserTypeRef, data: Nothing?) { visitUserTypeRef(userTypeRef) } + open fun visitUserTypeRef(userTypeRef: FirUserTypeRef) { + visitElement(userTypeRef) + } + final override fun visitDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: Nothing?) { visitDynamicTypeRef(dynamicTypeRef) } + open fun visitDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef) { + visitElement(dynamicTypeRef) + } + final override fun visitFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: Nothing?) { visitFunctionTypeRef(functionTypeRef) } + open fun visitFunctionTypeRef(functionTypeRef: FirFunctionTypeRef) { + visitElement(functionTypeRef) + } + final override fun visitIntersectionTypeRef(intersectionTypeRef: FirIntersectionTypeRef, data: Nothing?) { visitIntersectionTypeRef(intersectionTypeRef) } + open fun visitIntersectionTypeRef(intersectionTypeRef: FirIntersectionTypeRef) { + visitElement(intersectionTypeRef) + } + final override fun visitImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: Nothing?) { visitImplicitTypeRef(implicitTypeRef) } + open fun visitImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef) { + visitElement(implicitTypeRef) + } + final override fun visitContractElementDeclaration(contractElementDeclaration: FirContractElementDeclaration, data: Nothing?) { visitContractElementDeclaration(contractElementDeclaration) } + open fun visitContractElementDeclaration(contractElementDeclaration: FirContractElementDeclaration) { + visitElement(contractElementDeclaration) + } + final override fun visitEffectDeclaration(effectDeclaration: FirEffectDeclaration, data: Nothing?) { visitEffectDeclaration(effectDeclaration) } + open fun visitEffectDeclaration(effectDeclaration: FirEffectDeclaration) { + visitElement(effectDeclaration) + } + final override fun visitContractDescription(contractDescription: FirContractDescription, data: Nothing?) { visitContractDescription(contractDescription) } + open fun visitContractDescription(contractDescription: FirContractDescription) { + visitElement(contractDescription) + } + final override fun visitLegacyRawContractDescription(legacyRawContractDescription: FirLegacyRawContractDescription, data: Nothing?) { visitLegacyRawContractDescription(legacyRawContractDescription) } + open fun visitLegacyRawContractDescription(legacyRawContractDescription: FirLegacyRawContractDescription) { + visitElement(legacyRawContractDescription) + } + final override fun visitRawContractDescription(rawContractDescription: FirRawContractDescription, data: Nothing?) { visitRawContractDescription(rawContractDescription) } + open fun visitRawContractDescription(rawContractDescription: FirRawContractDescription) { + visitElement(rawContractDescription) + } + final override fun visitResolvedContractDescription(resolvedContractDescription: FirResolvedContractDescription, data: Nothing?) { visitResolvedContractDescription(resolvedContractDescription) } + open fun visitResolvedContractDescription(resolvedContractDescription: FirResolvedContractDescription) { + visitElement(resolvedContractDescription) + } } diff --git a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt index 8eb653c41fe..631ce71bc9f 100644 --- a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt +++ b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt @@ -734,6 +734,10 @@ object NodeConfigurator : AbstractFieldConfigurator(FirTreeBuild +field("partiallyResolvedTypeRef", typeRef, nullable = true).withTransform() } + resolvedErrorReference.configure { + element.customParentInVisitor = resolvedNamedReference + } + intersectionTypeRef.configure { +field("leftType", typeRef) +field("rightType", typeRef) diff --git a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/Types.kt b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/Types.kt index 94e68cc426d..0a7c3738246 100644 --- a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/Types.kt +++ b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/Types.kt @@ -15,6 +15,7 @@ import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget import org.jetbrains.kotlin.fir.tree.generator.context.generatedType import org.jetbrains.kotlin.fir.tree.generator.context.type +import org.jetbrains.kotlin.fir.tree.generator.printer.VISITOR_PACKAGE import org.jetbrains.kotlin.fir.types.ConeClassLikeType import org.jetbrains.kotlin.fir.types.ConeErrorType import org.jetbrains.kotlin.fir.types.ConeKotlinType @@ -116,11 +117,11 @@ val annotationResolvePhaseType = generatedType("expressions", "FirAnnotationReso val typeRefMarkerType = type("mpp", "TypeRefMarker") -val firVisitorType = type("fir.visitors", "FirVisitor", kind = TypeKind.Class) -val firVisitorVoidType = type("fir.visitors", "FirVisitorVoid", kind = TypeKind.Class) -val firDefaultVisitorType = type("fir.visitors", "FirDefaultVisitor", kind = TypeKind.Class) -val firDefaultVisitorVoidType = type("fir.visitors", "FirDefaultVisitorVoid", kind = TypeKind.Class) -val firTransformerType = type("fir.visitors", "FirTransformer", kind = TypeKind.Class) +val firVisitorType = generatedType("visitors", "FirVisitor") +val firVisitorVoidType = generatedType("visitors", "FirVisitorVoid") +val firDefaultVisitorType = generatedType("visitors", "FirDefaultVisitor") +val firDefaultVisitorVoidType = generatedType("visitors", "FirDefaultVisitorVoid") +val firTransformerType = generatedType("visitors", "FirTransformer") val resolveStateAccessAnnotation = type("fir.declarations", "ResolveStateAccess", kind = TypeKind.Class) val unresolvedExpressionTypeAccessAnnotation = type("fir.expressions", "UnresolvedExpressionTypeAccess", kind = TypeKind.Class) diff --git a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/model/Element.kt b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/model/Element.kt index eda9e53dd69..1bb8b41b394 100644 --- a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/model/Element.kt +++ b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/model/Element.kt @@ -6,6 +6,7 @@ package org.jetbrains.kotlin.fir.tree.generator.model import org.jetbrains.kotlin.fir.tree.generator.printer.BASE_PACKAGE +import org.jetbrains.kotlin.fir.tree.generator.printer.safeDecapitalizedName import org.jetbrains.kotlin.fir.tree.generator.util.set import org.jetbrains.kotlin.generators.tree.* import org.jetbrains.kotlin.generators.tree.ElementOrRef as GenericElementOrRef @@ -78,6 +79,17 @@ class Element(override val name: String, override val propertyName: String, kind var baseTransformerType: Element? = null val transformerType: Element get() = baseTransformerType ?: this + override val visitFunctionName: String + get() = "visit$name" + + override val visitorParameterName: String + get() = safeDecapitalizedName + + var customParentInVisitor: Element? = null + + override val parentInVisitor: Element? + get() = customParentInVisitor ?: elementParents.singleOrNull()?.element?.takeIf { !it.isRootElement } + var doesNotNeedImplementation: Boolean = false val needTransformOtherChildren: Boolean get() = _needTransformOtherChildren || elementParents.any { it.element.needTransformOtherChildren } diff --git a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/element.kt b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/element.kt index b229e3c1eaf..e62ed105933 100644 --- a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/element.kt +++ b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/element.kt @@ -40,7 +40,7 @@ fun SmartPrinter.printElement(element: Element) { printKDoc(element.extendedKDoc()) print("${kind!!.title} $typeName") - print(typeParameters()) + print(params.typeParameters()) val parentRefs = element.parentRefs if (parentRefs.isNotEmpty()) { print( @@ -49,7 +49,7 @@ fun SmartPrinter.printElement(element: Element) { } ) } - print(multipleUpperBoundsList()) + print(params.multipleUpperBoundsList()) println(" {") withIndent { allFields.forEach { field -> diff --git a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/implementation.kt b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/implementation.kt index 624f8b86241..1bf8ac86c49 100644 --- a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/implementation.kt +++ b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/implementation.kt @@ -67,7 +67,7 @@ fun SmartPrinter.printImplementation(implementation: Implementation) { print("internal ") } print("${kind!!.title} ${this.typeName}") - print(element.typeParameters(end = " ")) + print(element.params.typeParameters(end = " ")) val isInterface = kind == ImplementationKind.Interface || kind == ImplementationKind.SealedInterface val isAbstract = kind == ImplementationKind.AbstractClass || kind == ImplementationKind.SealedClass diff --git a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/transformer.kt b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/transformer.kt index 430946a0020..0296d635277 100644 --- a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/transformer.kt +++ b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/transformer.kt @@ -5,71 +5,107 @@ package org.jetbrains.kotlin.fir.tree.generator.printer +import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.fir.tree.generator.context.AbstractFirTreeBuilder +import org.jetbrains.kotlin.fir.tree.generator.firTransformerType +import org.jetbrains.kotlin.fir.tree.generator.firVisitorType import org.jetbrains.kotlin.fir.tree.generator.model.Element +import org.jetbrains.kotlin.fir.tree.generator.model.Field +import org.jetbrains.kotlin.generators.tree.* +import org.jetbrains.kotlin.generators.tree.printer.FunctionParameter import org.jetbrains.kotlin.generators.tree.printer.GeneratedFile -import org.jetbrains.kotlin.generators.tree.printer.multipleUpperBoundsList +import org.jetbrains.kotlin.generators.tree.printer.printFunctionDeclaration import org.jetbrains.kotlin.generators.tree.printer.printGeneratedType -import org.jetbrains.kotlin.generators.tree.printer.typeParameters -import org.jetbrains.kotlin.generators.tree.render +import org.jetbrains.kotlin.types.Variance +import org.jetbrains.kotlin.utils.SmartPrinter import org.jetbrains.kotlin.utils.withIndent import java.io.File -fun printTransformer(elements: List, generationPath: File): GeneratedFile = - printGeneratedType(generationPath, TREE_GENERATOR_README, VISITOR_PACKAGE, "FirTransformer") { - println() - println("abstract class FirTransformer : FirVisitor() {") - println() - withIndent { - println("abstract fun transformElement(element: E, data: D): E") +private class TransformerPrinter( + printer: SmartPrinter, +) : AbstractVisitorPrinter(printer, visitSuperTypeByDefault = false) { + + override val visitorType: ClassRef<*> + get() = firTransformerType + + override val visitorSuperType: ClassRef + get() = firVisitorType.withArgs(AbstractFirTreeBuilder.baseFirElement, visitorDataType) + + override val visitorTypeParameters: List + get() = listOf(dataTypeVariable) + + override val visitorDataType: TypeRef + get() = dataTypeVariable + + override fun visitMethodReturnType(element: Element) = element.transformerType + + override val allowTypeParametersInVisitorMethods: Boolean + get() = true + + context(ImportCollector) + override fun printMethodsForElement(element: Element) { + printer.run { println() - for (element in elements) { - if (element == AbstractFirTreeBuilder.baseFirElement) continue - val varName = element.safeDecapitalizedName - print("open fun ") - element.typeParameters(end = " ").takeIf { it.isNotBlank() }?.let { print(it) } - println( - "transform", - element.name, - "(", - varName, - ": ", - element.render(), - ", data: D): ", - element.transformerType.render(), - element.multipleUpperBoundsList(), - " {", + val elementParameterName = element.safeDecapitalizedName + if (element.isRootElement) { + val elementTP = TypeVariable("E", listOf(element), variance = Variance.INVARIANT) + printFunctionDeclaration( + name = "transformElement", + parameters = listOf( + FunctionParameter(elementParameterName, elementTP), + FunctionParameter("data", dataTypeVariable) + ), + returnType = elementTP, + typeParameters = listOf(elementTP), + modality = Modality.ABSTRACT, ) + println() + } else { + printFunctionDeclaration( + name = "transform" + element.name, + parameters = listOf( + FunctionParameter(elementParameterName, element), + FunctionParameter("data", dataTypeVariable) + ), + returnType = visitMethodReturnType(element), + typeParameters = element.params, + modality = Modality.OPEN, + ) + println(" {") withIndent { - println("return transformElement($varName, data)") + println("return transformElement(", elementParameterName, ", data)") } println("}") - println() } - - for (element in elements) { - val varName = element.safeDecapitalizedName - print("final override fun ") - element.typeParameters(end = " ").takeIf { it.isNotBlank() }?.let { print(it) } - + println() + printVisitMethodDeclaration( + element = element, + modality = Modality.FINAL, + override = true, + ) + println(" {") + withIndent { println( - "visit", + "return transform", element.name, "(", - varName, - ": ", - element.render(), - ", data: D): ", - element.transformerType.render(), - element.multipleUpperBoundsList(), - " {" + element.safeDecapitalizedName, + ", ", + "data)" ) - withIndent { - println("return transform${element.name}($varName, data)") - } - println("}") - println() } + println("}") } - println("}") + } +} + +fun printTransformer(elements: List, generationPath: File): GeneratedFile = + printGeneratedType( + generationPath, + TREE_GENERATOR_README, + firTransformerType.packageName, + firTransformerType.simpleName, + ) { + println() + TransformerPrinter(this).printVisitor(elements) } diff --git a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/visitor.kt b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/visitor.kt index 90fa7887163..807aefcec06 100644 --- a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/visitor.kt +++ b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/visitor.kt @@ -5,176 +5,121 @@ package org.jetbrains.kotlin.fir.tree.generator.printer -import org.jetbrains.kotlin.fir.tree.generator.FirTreeBuilder import org.jetbrains.kotlin.fir.tree.generator.context.AbstractFirTreeBuilder +import org.jetbrains.kotlin.fir.tree.generator.firDefaultVisitorType +import org.jetbrains.kotlin.fir.tree.generator.firDefaultVisitorVoidType +import org.jetbrains.kotlin.fir.tree.generator.firVisitorType +import org.jetbrains.kotlin.fir.tree.generator.firVisitorVoidType import org.jetbrains.kotlin.fir.tree.generator.model.Element +import org.jetbrains.kotlin.fir.tree.generator.model.Field +import org.jetbrains.kotlin.generators.tree.* import org.jetbrains.kotlin.generators.tree.printer.GeneratedFile -import org.jetbrains.kotlin.generators.tree.printer.multipleUpperBoundsList import org.jetbrains.kotlin.generators.tree.printer.printGeneratedType -import org.jetbrains.kotlin.generators.tree.printer.typeParameters -import org.jetbrains.kotlin.generators.tree.render -import org.jetbrains.kotlin.utils.withIndent +import org.jetbrains.kotlin.utils.SmartPrinter import java.io.File -private val elementsWithMultipleSupertypesForDefaultVisitor = mapOf( - FirTreeBuilder.resolvedErrorReference to FirTreeBuilder.resolvedNamedReference -) +private class VisitorPrinter( + printer: SmartPrinter, + override val visitorType: ClassRef<*>, + visitSuperTypeByDefault: Boolean, +) : AbstractVisitorPrinter(printer, visitSuperTypeByDefault) { -private fun Element.isAcceptableForDefaultVisiting(): Boolean { - if (this == AbstractFirTreeBuilder.baseFirElement) return false - val hasSingleSupertype = elementParents.size == 1 && !elementParents[0].element.isRootElement - return hasSingleSupertype || this in elementsWithMultipleSupertypesForDefaultVisitor -} + override val visitorTypeParameters: List + get() = listOf(resultTypeVariable, dataTypeVariable) -private fun Element.getNameOfSupertypeForDefaultVisiting(): String { - val parentForDefaultVisiting = - elementParents.singleOrNull()?.element ?: elementsWithMultipleSupertypesForDefaultVisitor.getValue(this) - return parentForDefaultVisiting.name -} + override val visitorSuperType: ClassRef? = + firVisitorType.takeIf { visitSuperTypeByDefault }?.withArgs(resultTypeVariable, dataTypeVariable) -fun printVisitor(elements: List, generationPath: File, visitSuperTypeByDefault: Boolean): GeneratedFile { - val className = if (visitSuperTypeByDefault) "FirDefaultVisitor" else "FirVisitor" - return printGeneratedType(generationPath, TREE_GENERATOR_README, VISITOR_PACKAGE, className) { - println() + override val visitorDataType: TypeRef + get() = dataTypeVariable - print("abstract class $className ") - if (visitSuperTypeByDefault) { - print(": FirVisitor() ") - } - println("{") + override fun visitMethodReturnType(element: Element) = resultTypeVariable - pushIndent() - if (!visitSuperTypeByDefault) { - println("abstract fun visitElement(element: FirElement, data: D): R\n") - } - for (element in elements) { - if (element == AbstractFirTreeBuilder.baseFirElement) continue - if (visitSuperTypeByDefault && !element.isAcceptableForDefaultVisiting()) continue - with(element) { - val varName = safeDecapitalizedName - if (visitSuperTypeByDefault) { - print("override") - } else { - print("open") - } - print( - " fun ", - typeParameters(end = " "), - "visit", - name, - "(", - varName, - ": ", - render(), - ", data: D): R", - multipleUpperBoundsList(), - " = visit" - ) - if (visitSuperTypeByDefault) { - print(element.getNameOfSupertypeForDefaultVisiting()) - } else { - print("Element") - } - println("($varName, data)") - println() - } - } - popIndent() - println("}") + override val allowTypeParametersInVisitorMethods: Boolean + get() = true + + override fun parentInVisitor(element: Element): Element? = when { + element.isRootElement -> null + visitSuperTypeByDefault -> element.parentInVisitor + else -> AbstractFirTreeBuilder.baseFirElement } } +fun printVisitor(elements: List, generationPath: File, visitSuperTypeByDefault: Boolean) = + printVisitorCommon( + elements, + generationPath, + if (visitSuperTypeByDefault) firDefaultVisitorType else firVisitorType, + ) { printer, visitorType -> + VisitorPrinter(printer, visitorType, visitSuperTypeByDefault) + } -fun printVisitorVoid(elements: List, generationPath: File): GeneratedFile = - printGeneratedType(generationPath, TREE_GENERATOR_README, VISITOR_PACKAGE, "FirVisitorVoid") { - println() - println("abstract class FirVisitorVoid : FirVisitor() {") +private class VisitorVoidPrinter( + printer: SmartPrinter, + override val visitorType: ClassRef<*>, +) : AbstractVisitorVoidPrinter(printer, visitSuperTypeByDefault = false) { - withIndent { - println("abstract fun visitElement(element: FirElement)") + override val visitorSuperClass: ClassRef + get() = firVisitorType + + override val allowTypeParametersInVisitorMethods: Boolean + get() = true + + override val useAbstractMethodForRootElement: Boolean + get() = true + + override val overriddenVisitMethodsAreFinal: Boolean + get() = true + + override fun parentInVisitor(element: Element): Element = AbstractFirTreeBuilder.baseFirElement +} + +fun printVisitorVoid(elements: List, generationPath: File) = + printVisitorCommon(elements, generationPath, firVisitorVoidType, ::VisitorVoidPrinter) + +private class DefaultVisitorVoidPrinter( + printer: SmartPrinter, + override val visitorType: ClassRef<*>, +) : AbstractVisitorPrinter(printer, visitSuperTypeByDefault = true) { + + override val visitorTypeParameters: List + get() = emptyList() + + override val visitorDataType: TypeRef + get() = StandardTypes.nothing.copy(nullable = true) + + override fun visitMethodReturnType(element: Element) = StandardTypes.unit + + override val visitorSuperType: ClassRef + get() = firVisitorVoidType + + override val allowTypeParametersInVisitorMethods: Boolean + get() = true + + context(ImportCollector) + override fun printMethodsForElement(element: Element) { + printer.run { + printVisitMethodDeclaration( + element, + hasDataParameter = false, + override = true, + ) + println(" = ", element.parentInVisitor!!.visitFunctionName, "(", element.visitorParameterName, ")") println() - for (element in elements) { - if (element == AbstractFirTreeBuilder.baseFirElement) continue - with(element) { - val varName = safeDecapitalizedName - println( - "open fun ", - typeParameters(end = " "), - "visit", - name, - "(", - varName, - ": ", - render(), - ")", - multipleUpperBoundsList(), - " {" - ) - withIndent { - println("visitElement($varName)") - } - println("}") - println() - } - } - - for (element in elements) { - with(element) { - val varName = safeDecapitalizedName - println( - "final override fun ", - typeParameters(end = " "), - "visit", - name, - "(", - varName, - ": ", - render(), - ", data: Nothing?)", - multipleUpperBoundsList(), - " {" - ) - withIndent { - println("visit$name($varName)") - } - println("}") - println() - } - } } - println("}") } +} -fun printDefaultVisitorVoid(elements: List, generationPath: File): GeneratedFile = - printGeneratedType(generationPath, TREE_GENERATOR_README, VISITOR_PACKAGE, "FirDefaultVisitorVoid") { +fun printDefaultVisitorVoid(elements: List, generationPath: File) = + printVisitorCommon(elements, generationPath, firDefaultVisitorVoidType, ::DefaultVisitorVoidPrinter) + +private fun printVisitorCommon( + elements: List, + generationPath: File, + visitorType: ClassRef<*>, + makePrinter: (SmartPrinter, ClassRef<*>) -> AbstractVisitorPrinter, +): GeneratedFile = + printGeneratedType(generationPath, TREE_GENERATOR_README, visitorType.packageName, visitorType.simpleName) { println() - println("abstract class FirDefaultVisitorVoid : FirVisitorVoid() {") - - pushIndent() - for (element in elements) { - if (!element.isAcceptableForDefaultVisiting()) continue - with(element) { - val varName = safeDecapitalizedName - println( - "override fun ", - typeParameters(end = " "), - "visit", - name, - "(", - varName, - ": ", - render(), - ")", - multipleUpperBoundsList(), - " = visit", - getNameOfSupertypeForDefaultVisiting(), - "(", - varName, - ")" - ) - println() - } - } - popIndent() - println("}") - } + makePrinter(this, visitorType).printVisitor(elements) + } \ No newline at end of file diff --git a/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/visitors/IrElementTransformer.kt b/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/visitors/IrElementTransformer.kt index db49287eeb6..b8ee62653e2 100644 --- a/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/visitors/IrElementTransformer.kt +++ b/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/visitors/IrElementTransformer.kt @@ -10,90 +10,11 @@ package org.jetbrains.kotlin.ir.visitors import org.jetbrains.kotlin.ir.IrElement import org.jetbrains.kotlin.ir.IrStatement -import org.jetbrains.kotlin.ir.declarations.IrAnonymousInitializer -import org.jetbrains.kotlin.ir.declarations.IrClass -import org.jetbrains.kotlin.ir.declarations.IrConstructor -import org.jetbrains.kotlin.ir.declarations.IrDeclarationBase -import org.jetbrains.kotlin.ir.declarations.IrEnumEntry -import org.jetbrains.kotlin.ir.declarations.IrErrorDeclaration -import org.jetbrains.kotlin.ir.declarations.IrExternalPackageFragment -import org.jetbrains.kotlin.ir.declarations.IrField -import org.jetbrains.kotlin.ir.declarations.IrFile -import org.jetbrains.kotlin.ir.declarations.IrFunction -import org.jetbrains.kotlin.ir.declarations.IrLocalDelegatedProperty -import org.jetbrains.kotlin.ir.declarations.IrModuleFragment -import org.jetbrains.kotlin.ir.declarations.IrPackageFragment -import org.jetbrains.kotlin.ir.declarations.IrProperty -import org.jetbrains.kotlin.ir.declarations.IrScript -import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction -import org.jetbrains.kotlin.ir.declarations.IrTypeAlias -import org.jetbrains.kotlin.ir.declarations.IrTypeParameter -import org.jetbrains.kotlin.ir.declarations.IrValueParameter -import org.jetbrains.kotlin.ir.declarations.IrVariable -import org.jetbrains.kotlin.ir.expressions.IrBlock -import org.jetbrains.kotlin.ir.expressions.IrBlockBody -import org.jetbrains.kotlin.ir.expressions.IrBody -import org.jetbrains.kotlin.ir.expressions.IrBranch -import org.jetbrains.kotlin.ir.expressions.IrBreak -import org.jetbrains.kotlin.ir.expressions.IrBreakContinue -import org.jetbrains.kotlin.ir.expressions.IrCall -import org.jetbrains.kotlin.ir.expressions.IrCallableReference -import org.jetbrains.kotlin.ir.expressions.IrCatch -import org.jetbrains.kotlin.ir.expressions.IrClassReference -import org.jetbrains.kotlin.ir.expressions.IrComposite -import org.jetbrains.kotlin.ir.expressions.IrConst -import org.jetbrains.kotlin.ir.expressions.IrConstantArray -import org.jetbrains.kotlin.ir.expressions.IrConstantObject -import org.jetbrains.kotlin.ir.expressions.IrConstantPrimitive -import org.jetbrains.kotlin.ir.expressions.IrConstantValue -import org.jetbrains.kotlin.ir.expressions.IrConstructorCall -import org.jetbrains.kotlin.ir.expressions.IrContainerExpression -import org.jetbrains.kotlin.ir.expressions.IrContinue -import org.jetbrains.kotlin.ir.expressions.IrDeclarationReference -import org.jetbrains.kotlin.ir.expressions.IrDelegatingConstructorCall -import org.jetbrains.kotlin.ir.expressions.IrDoWhileLoop -import org.jetbrains.kotlin.ir.expressions.IrDynamicExpression -import org.jetbrains.kotlin.ir.expressions.IrDynamicMemberExpression -import org.jetbrains.kotlin.ir.expressions.IrDynamicOperatorExpression -import org.jetbrains.kotlin.ir.expressions.IrElseBranch -import org.jetbrains.kotlin.ir.expressions.IrEnumConstructorCall -import org.jetbrains.kotlin.ir.expressions.IrErrorCallExpression -import org.jetbrains.kotlin.ir.expressions.IrErrorExpression -import org.jetbrains.kotlin.ir.expressions.IrExpression -import org.jetbrains.kotlin.ir.expressions.IrExpressionBody -import org.jetbrains.kotlin.ir.expressions.IrFieldAccessExpression -import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression -import org.jetbrains.kotlin.ir.expressions.IrFunctionExpression -import org.jetbrains.kotlin.ir.expressions.IrFunctionReference -import org.jetbrains.kotlin.ir.expressions.IrGetClass -import org.jetbrains.kotlin.ir.expressions.IrGetEnumValue -import org.jetbrains.kotlin.ir.expressions.IrGetField -import org.jetbrains.kotlin.ir.expressions.IrGetObjectValue -import org.jetbrains.kotlin.ir.expressions.IrGetSingletonValue -import org.jetbrains.kotlin.ir.expressions.IrGetValue -import org.jetbrains.kotlin.ir.expressions.IrInstanceInitializerCall -import org.jetbrains.kotlin.ir.expressions.IrLocalDelegatedPropertyReference -import org.jetbrains.kotlin.ir.expressions.IrLoop -import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression -import org.jetbrains.kotlin.ir.expressions.IrPropertyReference -import org.jetbrains.kotlin.ir.expressions.IrRawFunctionReference -import org.jetbrains.kotlin.ir.expressions.IrReturn -import org.jetbrains.kotlin.ir.expressions.IrSetField -import org.jetbrains.kotlin.ir.expressions.IrSetValue -import org.jetbrains.kotlin.ir.expressions.IrSpreadElement -import org.jetbrains.kotlin.ir.expressions.IrStringConcatenation -import org.jetbrains.kotlin.ir.expressions.IrSuspendableExpression -import org.jetbrains.kotlin.ir.expressions.IrSuspensionPoint -import org.jetbrains.kotlin.ir.expressions.IrSyntheticBody -import org.jetbrains.kotlin.ir.expressions.IrThrow -import org.jetbrains.kotlin.ir.expressions.IrTry -import org.jetbrains.kotlin.ir.expressions.IrTypeOperatorCall -import org.jetbrains.kotlin.ir.expressions.IrValueAccessExpression -import org.jetbrains.kotlin.ir.expressions.IrVararg -import org.jetbrains.kotlin.ir.expressions.IrWhen -import org.jetbrains.kotlin.ir.expressions.IrWhileLoop +import org.jetbrains.kotlin.ir.declarations.* +import org.jetbrains.kotlin.ir.expressions.* interface IrElementTransformer : IrElementVisitor { + override fun visitElement(element: IrElement, data: D): IrElement { element.transformChildren(this, data) return element @@ -105,61 +26,59 @@ interface IrElementTransformer : IrElementVisitor { } override fun visitValueParameter(declaration: IrValueParameter, data: D): IrStatement = - visitDeclaration(declaration, data) + visitDeclaration(declaration, data) override fun visitClass(declaration: IrClass, data: D): IrStatement = - visitDeclaration(declaration, data) + visitDeclaration(declaration, data) - override fun visitAnonymousInitializer(declaration: IrAnonymousInitializer, data: D): - IrStatement = visitDeclaration(declaration, data) + override fun visitAnonymousInitializer(declaration: IrAnonymousInitializer, data: D): IrStatement = + visitDeclaration(declaration, data) override fun visitTypeParameter(declaration: IrTypeParameter, data: D): IrStatement = - visitDeclaration(declaration, data) + visitDeclaration(declaration, data) override fun visitFunction(declaration: IrFunction, data: D): IrStatement = - visitDeclaration(declaration, data) + visitDeclaration(declaration, data) override fun visitConstructor(declaration: IrConstructor, data: D): IrStatement = - visitFunction(declaration, data) + visitFunction(declaration, data) override fun visitEnumEntry(declaration: IrEnumEntry, data: D): IrStatement = - visitDeclaration(declaration, data) + visitDeclaration(declaration, data) - override fun visitErrorDeclaration(declaration: IrErrorDeclaration, data: D): - IrStatement = visitDeclaration(declaration, data) + override fun visitErrorDeclaration(declaration: IrErrorDeclaration, data: D): IrStatement = + visitDeclaration(declaration, data) override fun visitField(declaration: IrField, data: D): IrStatement = - visitDeclaration(declaration, data) + visitDeclaration(declaration, data) - override fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty, - data: D): IrStatement = visitDeclaration(declaration, data) + override fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty, data: D): IrStatement = + visitDeclaration(declaration, data) - override fun visitModuleFragment(declaration: IrModuleFragment, data: D): - IrModuleFragment { + override fun visitModuleFragment(declaration: IrModuleFragment, data: D): IrModuleFragment { declaration.transformChildren(this, data) return declaration } override fun visitProperty(declaration: IrProperty, data: D): IrStatement = - visitDeclaration(declaration, data) + visitDeclaration(declaration, data) override fun visitScript(declaration: IrScript, data: D): IrStatement = - visitDeclaration(declaration, data) + visitDeclaration(declaration, data) override fun visitSimpleFunction(declaration: IrSimpleFunction, data: D): IrStatement = - visitFunction(declaration, data) + visitFunction(declaration, data) override fun visitTypeAlias(declaration: IrTypeAlias, data: D): IrStatement = - visitDeclaration(declaration, data) + visitDeclaration(declaration, data) override fun visitVariable(declaration: IrVariable, data: D): IrStatement = - visitDeclaration(declaration, data) + visitDeclaration(declaration, data) override fun visitPackageFragment(declaration: IrPackageFragment, data: D): IrElement = - visitElement(declaration, data) + visitElement(declaration, data) - override fun visitExternalPackageFragment(declaration: IrExternalPackageFragment, - data: D): IrExternalPackageFragment { + override fun visitExternalPackageFragment(declaration: IrExternalPackageFragment, data: D): IrExternalPackageFragment { declaration.transformChildren(this, data) return declaration } @@ -180,156 +99,156 @@ interface IrElementTransformer : IrElementVisitor { } override fun visitExpressionBody(body: IrExpressionBody, data: D): IrBody = - visitBody(body, data) + visitBody(body, data) - override fun visitBlockBody(body: IrBlockBody, data: D): IrBody = visitBody(body, data) + override fun visitBlockBody(body: IrBlockBody, data: D): IrBody = + visitBody(body, data) - override fun visitDeclarationReference(expression: IrDeclarationReference, data: D): - IrExpression = visitExpression(expression, data) + override fun visitDeclarationReference(expression: IrDeclarationReference, data: D): IrExpression = + visitExpression(expression, data) - override fun visitMemberAccess(expression: IrMemberAccessExpression<*>, data: D): - IrElement = visitDeclarationReference(expression, data) + override fun visitMemberAccess(expression: IrMemberAccessExpression<*>, data: D): IrElement = + visitDeclarationReference(expression, data) - override fun visitFunctionAccess(expression: IrFunctionAccessExpression, data: D): - IrElement = visitMemberAccess(expression, data) + override fun visitFunctionAccess(expression: IrFunctionAccessExpression, data: D): IrElement = + visitMemberAccess(expression, data) override fun visitConstructorCall(expression: IrConstructorCall, data: D): IrElement = - visitFunctionAccess(expression, data) + visitFunctionAccess(expression, data) - override fun visitSingletonReference(expression: IrGetSingletonValue, data: D): - IrExpression = visitDeclarationReference(expression, data) + override fun visitSingletonReference(expression: IrGetSingletonValue, data: D): IrExpression = + visitDeclarationReference(expression, data) override fun visitGetObjectValue(expression: IrGetObjectValue, data: D): IrExpression = - visitSingletonReference(expression, data) + visitSingletonReference(expression, data) override fun visitGetEnumValue(expression: IrGetEnumValue, data: D): IrExpression = - visitSingletonReference(expression, data) + visitSingletonReference(expression, data) - override fun visitRawFunctionReference(expression: IrRawFunctionReference, data: D): - IrExpression = visitDeclarationReference(expression, data) + override fun visitRawFunctionReference(expression: IrRawFunctionReference, data: D): IrExpression = + visitDeclarationReference(expression, data) - override fun visitContainerExpression(expression: IrContainerExpression, data: D): - IrExpression = visitExpression(expression, data) + override fun visitContainerExpression(expression: IrContainerExpression, data: D): IrExpression = + visitExpression(expression, data) override fun visitBlock(expression: IrBlock, data: D): IrExpression = - visitContainerExpression(expression, data) + visitContainerExpression(expression, data) override fun visitComposite(expression: IrComposite, data: D): IrExpression = - visitContainerExpression(expression, data) + visitContainerExpression(expression, data) override fun visitSyntheticBody(body: IrSyntheticBody, data: D): IrBody = - visitBody(body, data) + visitBody(body, data) override fun visitBreakContinue(jump: IrBreakContinue, data: D): IrExpression = - visitExpression(jump, data) + visitExpression(jump, data) override fun visitBreak(jump: IrBreak, data: D): IrExpression = - visitBreakContinue(jump, data) + visitBreakContinue(jump, data) override fun visitContinue(jump: IrContinue, data: D): IrExpression = - visitBreakContinue(jump, data) + visitBreakContinue(jump, data) override fun visitCall(expression: IrCall, data: D): IrElement = - visitFunctionAccess(expression, data) + visitFunctionAccess(expression, data) - override fun visitCallableReference(expression: IrCallableReference<*>, data: D): - IrElement = visitMemberAccess(expression, data) + override fun visitCallableReference(expression: IrCallableReference<*>, data: D): IrElement = + visitMemberAccess(expression, data) - override fun visitFunctionReference(expression: IrFunctionReference, data: D): - IrElement = visitCallableReference(expression, data) + override fun visitFunctionReference(expression: IrFunctionReference, data: D): IrElement = + visitCallableReference(expression, data) - override fun visitPropertyReference(expression: IrPropertyReference, data: D): - IrElement = visitCallableReference(expression, data) + override fun visitPropertyReference(expression: IrPropertyReference, data: D): IrElement = + visitCallableReference(expression, data) - override - fun visitLocalDelegatedPropertyReference(expression: IrLocalDelegatedPropertyReference, - data: D): IrElement = visitCallableReference(expression, data) + override fun visitLocalDelegatedPropertyReference(expression: IrLocalDelegatedPropertyReference, data: D): IrElement = + visitCallableReference(expression, data) override fun visitClassReference(expression: IrClassReference, data: D): IrExpression = - visitDeclarationReference(expression, data) + visitDeclarationReference(expression, data) override fun visitConst(expression: IrConst<*>, data: D): IrExpression = - visitExpression(expression, data) + visitExpression(expression, data) - override fun visitConstantValue(expression: IrConstantValue, data: D): - IrConstantValue { + override fun visitConstantValue(expression: IrConstantValue, data: D): IrConstantValue { expression.transformChildren(this, data) return expression } - override fun visitConstantPrimitive(expression: IrConstantPrimitive, data: D): - IrConstantValue = visitConstantValue(expression, data) + override fun visitConstantPrimitive(expression: IrConstantPrimitive, data: D): IrConstantValue = + visitConstantValue(expression, data) - override fun visitConstantObject(expression: IrConstantObject, data: D): - IrConstantValue = visitConstantValue(expression, data) + override fun visitConstantObject(expression: IrConstantObject, data: D): IrConstantValue = + visitConstantValue(expression, data) - override fun visitConstantArray(expression: IrConstantArray, data: D): IrConstantValue - = visitConstantValue(expression, data) + override fun visitConstantArray(expression: IrConstantArray, data: D): IrConstantValue = + visitConstantValue(expression, data) - override fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall, - data: D): IrElement = visitFunctionAccess(expression, data) + override fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall, data: D): IrElement = + visitFunctionAccess(expression, data) - override fun visitDynamicExpression(expression: IrDynamicExpression, data: D): - IrExpression = visitExpression(expression, data) + override fun visitDynamicExpression(expression: IrDynamicExpression, data: D): IrExpression = + visitExpression(expression, data) - override fun visitDynamicOperatorExpression(expression: IrDynamicOperatorExpression, - data: D): IrExpression = visitDynamicExpression(expression, data) + override fun visitDynamicOperatorExpression(expression: IrDynamicOperatorExpression, data: D): IrExpression = + visitDynamicExpression(expression, data) - override fun visitDynamicMemberExpression(expression: IrDynamicMemberExpression, - data: D): IrExpression = visitDynamicExpression(expression, data) + override fun visitDynamicMemberExpression(expression: IrDynamicMemberExpression, data: D): IrExpression = + visitDynamicExpression(expression, data) - override fun visitEnumConstructorCall(expression: IrEnumConstructorCall, data: D): - IrElement = visitFunctionAccess(expression, data) + override fun visitEnumConstructorCall(expression: IrEnumConstructorCall, data: D): IrElement = + visitFunctionAccess(expression, data) - override fun visitErrorExpression(expression: IrErrorExpression, data: D): IrExpression - = visitExpression(expression, data) + override fun visitErrorExpression(expression: IrErrorExpression, data: D): IrExpression = + visitExpression(expression, data) - override fun visitErrorCallExpression(expression: IrErrorCallExpression, data: D): - IrExpression = visitErrorExpression(expression, data) + override fun visitErrorCallExpression(expression: IrErrorCallExpression, data: D): IrExpression = + visitErrorExpression(expression, data) - override fun visitFieldAccess(expression: IrFieldAccessExpression, data: D): - IrExpression = visitDeclarationReference(expression, data) + override fun visitFieldAccess(expression: IrFieldAccessExpression, data: D): IrExpression = + visitDeclarationReference(expression, data) override fun visitGetField(expression: IrGetField, data: D): IrExpression = - visitFieldAccess(expression, data) + visitFieldAccess(expression, data) override fun visitSetField(expression: IrSetField, data: D): IrExpression = - visitFieldAccess(expression, data) + visitFieldAccess(expression, data) - override fun visitFunctionExpression(expression: IrFunctionExpression, data: D): - IrElement = visitExpression(expression, data) + override fun visitFunctionExpression(expression: IrFunctionExpression, data: D): IrElement = + visitExpression(expression, data) override fun visitGetClass(expression: IrGetClass, data: D): IrExpression = - visitExpression(expression, data) + visitExpression(expression, data) - override fun visitInstanceInitializerCall(expression: IrInstanceInitializerCall, - data: D): IrExpression = visitExpression(expression, data) + override fun visitInstanceInitializerCall(expression: IrInstanceInitializerCall, data: D): IrExpression = + visitExpression(expression, data) - override fun visitLoop(loop: IrLoop, data: D): IrExpression = visitExpression(loop, - data) + override fun visitLoop(loop: IrLoop, data: D): IrExpression = + visitExpression(loop, data) - override fun visitWhileLoop(loop: IrWhileLoop, data: D): IrExpression = visitLoop(loop, - data) + override fun visitWhileLoop(loop: IrWhileLoop, data: D): IrExpression = + visitLoop(loop, data) override fun visitDoWhileLoop(loop: IrDoWhileLoop, data: D): IrExpression = - visitLoop(loop, data) + visitLoop(loop, data) override fun visitReturn(expression: IrReturn, data: D): IrExpression = - visitExpression(expression, data) + visitExpression(expression, data) - override fun visitStringConcatenation(expression: IrStringConcatenation, data: D): - IrExpression = visitExpression(expression, data) + override fun visitStringConcatenation(expression: IrStringConcatenation, data: D): IrExpression = + visitExpression(expression, data) - override fun visitSuspensionPoint(expression: IrSuspensionPoint, data: D): IrExpression - = visitExpression(expression, data) + override fun visitSuspensionPoint(expression: IrSuspensionPoint, data: D): IrExpression = + visitExpression(expression, data) - override fun visitSuspendableExpression(expression: IrSuspendableExpression, data: D): - IrExpression = visitExpression(expression, data) + override fun visitSuspendableExpression(expression: IrSuspendableExpression, data: D): IrExpression = + visitExpression(expression, data) override fun visitThrow(expression: IrThrow, data: D): IrExpression = - visitExpression(expression, data) + visitExpression(expression, data) - override fun visitTry(aTry: IrTry, data: D): IrExpression = visitExpression(aTry, data) + override fun visitTry(aTry: IrTry, data: D): IrExpression = + visitExpression(aTry, data) override fun visitCatch(aCatch: IrCatch, data: D): IrCatch { aCatch.transformChildren(this, data) @@ -337,19 +256,19 @@ interface IrElementTransformer : IrElementVisitor { } override fun visitTypeOperator(expression: IrTypeOperatorCall, data: D): IrExpression = - visitExpression(expression, data) + visitExpression(expression, data) - override fun visitValueAccess(expression: IrValueAccessExpression, data: D): - IrExpression = visitDeclarationReference(expression, data) + override fun visitValueAccess(expression: IrValueAccessExpression, data: D): IrExpression = + visitDeclarationReference(expression, data) override fun visitGetValue(expression: IrGetValue, data: D): IrExpression = - visitValueAccess(expression, data) + visitValueAccess(expression, data) override fun visitSetValue(expression: IrSetValue, data: D): IrExpression = - visitValueAccess(expression, data) + visitValueAccess(expression, data) override fun visitVararg(expression: IrVararg, data: D): IrExpression = - visitExpression(expression, data) + visitExpression(expression, data) override fun visitSpreadElement(spread: IrSpreadElement, data: D): IrSpreadElement { spread.transformChildren(this, data) @@ -357,7 +276,7 @@ interface IrElementTransformer : IrElementVisitor { } override fun visitWhen(expression: IrWhen, data: D): IrExpression = - visitExpression(expression, data) + visitExpression(expression, data) override fun visitBranch(branch: IrBranch, data: D): IrBranch { branch.transformChildren(this, data) diff --git a/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/visitors/IrElementVisitor.kt b/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/visitors/IrElementVisitor.kt index ee4804abb57..a1f4b8736f3 100644 --- a/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/visitors/IrElementVisitor.kt +++ b/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/visitors/IrElementVisitor.kt @@ -9,152 +9,54 @@ package org.jetbrains.kotlin.ir.visitors import org.jetbrains.kotlin.ir.IrElement -import org.jetbrains.kotlin.ir.declarations.IrAnonymousInitializer -import org.jetbrains.kotlin.ir.declarations.IrClass -import org.jetbrains.kotlin.ir.declarations.IrConstructor -import org.jetbrains.kotlin.ir.declarations.IrDeclarationBase -import org.jetbrains.kotlin.ir.declarations.IrEnumEntry -import org.jetbrains.kotlin.ir.declarations.IrErrorDeclaration -import org.jetbrains.kotlin.ir.declarations.IrExternalPackageFragment -import org.jetbrains.kotlin.ir.declarations.IrField -import org.jetbrains.kotlin.ir.declarations.IrFile -import org.jetbrains.kotlin.ir.declarations.IrFunction -import org.jetbrains.kotlin.ir.declarations.IrLocalDelegatedProperty -import org.jetbrains.kotlin.ir.declarations.IrModuleFragment -import org.jetbrains.kotlin.ir.declarations.IrPackageFragment -import org.jetbrains.kotlin.ir.declarations.IrProperty -import org.jetbrains.kotlin.ir.declarations.IrScript -import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction -import org.jetbrains.kotlin.ir.declarations.IrTypeAlias -import org.jetbrains.kotlin.ir.declarations.IrTypeParameter -import org.jetbrains.kotlin.ir.declarations.IrValueParameter -import org.jetbrains.kotlin.ir.declarations.IrVariable -import org.jetbrains.kotlin.ir.expressions.IrBlock -import org.jetbrains.kotlin.ir.expressions.IrBlockBody -import org.jetbrains.kotlin.ir.expressions.IrBody -import org.jetbrains.kotlin.ir.expressions.IrBranch -import org.jetbrains.kotlin.ir.expressions.IrBreak -import org.jetbrains.kotlin.ir.expressions.IrBreakContinue -import org.jetbrains.kotlin.ir.expressions.IrCall -import org.jetbrains.kotlin.ir.expressions.IrCallableReference -import org.jetbrains.kotlin.ir.expressions.IrCatch -import org.jetbrains.kotlin.ir.expressions.IrClassReference -import org.jetbrains.kotlin.ir.expressions.IrComposite -import org.jetbrains.kotlin.ir.expressions.IrConst -import org.jetbrains.kotlin.ir.expressions.IrConstantArray -import org.jetbrains.kotlin.ir.expressions.IrConstantObject -import org.jetbrains.kotlin.ir.expressions.IrConstantPrimitive -import org.jetbrains.kotlin.ir.expressions.IrConstantValue -import org.jetbrains.kotlin.ir.expressions.IrConstructorCall -import org.jetbrains.kotlin.ir.expressions.IrContainerExpression -import org.jetbrains.kotlin.ir.expressions.IrContinue -import org.jetbrains.kotlin.ir.expressions.IrDeclarationReference -import org.jetbrains.kotlin.ir.expressions.IrDelegatingConstructorCall -import org.jetbrains.kotlin.ir.expressions.IrDoWhileLoop -import org.jetbrains.kotlin.ir.expressions.IrDynamicExpression -import org.jetbrains.kotlin.ir.expressions.IrDynamicMemberExpression -import org.jetbrains.kotlin.ir.expressions.IrDynamicOperatorExpression -import org.jetbrains.kotlin.ir.expressions.IrElseBranch -import org.jetbrains.kotlin.ir.expressions.IrEnumConstructorCall -import org.jetbrains.kotlin.ir.expressions.IrErrorCallExpression -import org.jetbrains.kotlin.ir.expressions.IrErrorExpression -import org.jetbrains.kotlin.ir.expressions.IrExpression -import org.jetbrains.kotlin.ir.expressions.IrExpressionBody -import org.jetbrains.kotlin.ir.expressions.IrFieldAccessExpression -import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression -import org.jetbrains.kotlin.ir.expressions.IrFunctionExpression -import org.jetbrains.kotlin.ir.expressions.IrFunctionReference -import org.jetbrains.kotlin.ir.expressions.IrGetClass -import org.jetbrains.kotlin.ir.expressions.IrGetEnumValue -import org.jetbrains.kotlin.ir.expressions.IrGetField -import org.jetbrains.kotlin.ir.expressions.IrGetObjectValue -import org.jetbrains.kotlin.ir.expressions.IrGetSingletonValue -import org.jetbrains.kotlin.ir.expressions.IrGetValue -import org.jetbrains.kotlin.ir.expressions.IrInstanceInitializerCall -import org.jetbrains.kotlin.ir.expressions.IrLocalDelegatedPropertyReference -import org.jetbrains.kotlin.ir.expressions.IrLoop -import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression -import org.jetbrains.kotlin.ir.expressions.IrPropertyReference -import org.jetbrains.kotlin.ir.expressions.IrRawFunctionReference -import org.jetbrains.kotlin.ir.expressions.IrReturn -import org.jetbrains.kotlin.ir.expressions.IrSetField -import org.jetbrains.kotlin.ir.expressions.IrSetValue -import org.jetbrains.kotlin.ir.expressions.IrSpreadElement -import org.jetbrains.kotlin.ir.expressions.IrStringConcatenation -import org.jetbrains.kotlin.ir.expressions.IrSuspendableExpression -import org.jetbrains.kotlin.ir.expressions.IrSuspensionPoint -import org.jetbrains.kotlin.ir.expressions.IrSyntheticBody -import org.jetbrains.kotlin.ir.expressions.IrThrow -import org.jetbrains.kotlin.ir.expressions.IrTry -import org.jetbrains.kotlin.ir.expressions.IrTypeOperatorCall -import org.jetbrains.kotlin.ir.expressions.IrValueAccessExpression -import org.jetbrains.kotlin.ir.expressions.IrVararg -import org.jetbrains.kotlin.ir.expressions.IrWhen -import org.jetbrains.kotlin.ir.expressions.IrWhileLoop +import org.jetbrains.kotlin.ir.declarations.* +import org.jetbrains.kotlin.ir.expressions.* interface IrElementVisitor { + fun visitElement(element: IrElement, data: D): R - fun visitDeclaration(declaration: IrDeclarationBase, data: D): R = - visitElement(declaration, data) + fun visitDeclaration(declaration: IrDeclarationBase, data: D): R = visitElement(declaration, data) - fun visitValueParameter(declaration: IrValueParameter, data: D): R = - visitDeclaration(declaration, data) + fun visitValueParameter(declaration: IrValueParameter, data: D): R = visitDeclaration(declaration, data) fun visitClass(declaration: IrClass, data: D): R = visitDeclaration(declaration, data) - fun visitAnonymousInitializer(declaration: IrAnonymousInitializer, data: D): R = - visitDeclaration(declaration, data) + fun visitAnonymousInitializer(declaration: IrAnonymousInitializer, data: D): R = visitDeclaration(declaration, data) - fun visitTypeParameter(declaration: IrTypeParameter, data: D): R = - visitDeclaration(declaration, data) + fun visitTypeParameter(declaration: IrTypeParameter, data: D): R = visitDeclaration(declaration, data) - fun visitFunction(declaration: IrFunction, data: D): R = visitDeclaration(declaration, - data) + fun visitFunction(declaration: IrFunction, data: D): R = visitDeclaration(declaration, data) - fun visitConstructor(declaration: IrConstructor, data: D): R = - visitFunction(declaration, data) + fun visitConstructor(declaration: IrConstructor, data: D): R = visitFunction(declaration, data) - fun visitEnumEntry(declaration: IrEnumEntry, data: D): R = - visitDeclaration(declaration, data) + fun visitEnumEntry(declaration: IrEnumEntry, data: D): R = visitDeclaration(declaration, data) - fun visitErrorDeclaration(declaration: IrErrorDeclaration, data: D): R = - visitDeclaration(declaration, data) + fun visitErrorDeclaration(declaration: IrErrorDeclaration, data: D): R = visitDeclaration(declaration, data) fun visitField(declaration: IrField, data: D): R = visitDeclaration(declaration, data) - fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty, data: D): R = - visitDeclaration(declaration, data) + fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty, data: D): R = visitDeclaration(declaration, data) - fun visitModuleFragment(declaration: IrModuleFragment, data: D): R = - visitElement(declaration, data) + fun visitModuleFragment(declaration: IrModuleFragment, data: D): R = visitElement(declaration, data) - fun visitProperty(declaration: IrProperty, data: D): R = visitDeclaration(declaration, - data) + fun visitProperty(declaration: IrProperty, data: D): R = visitDeclaration(declaration, data) - fun visitScript(declaration: IrScript, data: D): R = visitDeclaration(declaration, - data) + fun visitScript(declaration: IrScript, data: D): R = visitDeclaration(declaration, data) - fun visitSimpleFunction(declaration: IrSimpleFunction, data: D): R = - visitFunction(declaration, data) + fun visitSimpleFunction(declaration: IrSimpleFunction, data: D): R = visitFunction(declaration, data) - fun visitTypeAlias(declaration: IrTypeAlias, data: D): R = - visitDeclaration(declaration, data) + fun visitTypeAlias(declaration: IrTypeAlias, data: D): R = visitDeclaration(declaration, data) - fun visitVariable(declaration: IrVariable, data: D): R = visitDeclaration(declaration, - data) + fun visitVariable(declaration: IrVariable, data: D): R = visitDeclaration(declaration, data) - fun visitPackageFragment(declaration: IrPackageFragment, data: D): R = - visitElement(declaration, data) + fun visitPackageFragment(declaration: IrPackageFragment, data: D): R = visitElement(declaration, data) - fun visitExternalPackageFragment(declaration: IrExternalPackageFragment, data: D): R = - visitPackageFragment(declaration, data) + fun visitExternalPackageFragment(declaration: IrExternalPackageFragment, data: D): R = visitPackageFragment(declaration, data) - fun visitFile(declaration: IrFile, data: D): R = visitPackageFragment(declaration, - data) + fun visitFile(declaration: IrFile, data: D): R = visitPackageFragment(declaration, data) - fun visitExpression(expression: IrExpression, data: D): R = visitElement(expression, - data) + fun visitExpression(expression: IrExpression, data: D): R = visitElement(expression, data) fun visitBody(body: IrBody, data: D): R = visitElement(body, data) @@ -162,38 +64,27 @@ interface IrElementVisitor { fun visitBlockBody(body: IrBlockBody, data: D): R = visitBody(body, data) - fun visitDeclarationReference(expression: IrDeclarationReference, data: D): R = - visitExpression(expression, data) + fun visitDeclarationReference(expression: IrDeclarationReference, data: D): R = visitExpression(expression, data) - fun visitMemberAccess(expression: IrMemberAccessExpression<*>, data: D): R = - visitDeclarationReference(expression, data) + fun visitMemberAccess(expression: IrMemberAccessExpression<*>, data: D): R = visitDeclarationReference(expression, data) - fun visitFunctionAccess(expression: IrFunctionAccessExpression, data: D): R = - visitMemberAccess(expression, data) + fun visitFunctionAccess(expression: IrFunctionAccessExpression, data: D): R = visitMemberAccess(expression, data) - fun visitConstructorCall(expression: IrConstructorCall, data: D): R = - visitFunctionAccess(expression, data) + fun visitConstructorCall(expression: IrConstructorCall, data: D): R = visitFunctionAccess(expression, data) - fun visitSingletonReference(expression: IrGetSingletonValue, data: D): R = - visitDeclarationReference(expression, data) + fun visitSingletonReference(expression: IrGetSingletonValue, data: D): R = visitDeclarationReference(expression, data) - fun visitGetObjectValue(expression: IrGetObjectValue, data: D): R = - visitSingletonReference(expression, data) + fun visitGetObjectValue(expression: IrGetObjectValue, data: D): R = visitSingletonReference(expression, data) - fun visitGetEnumValue(expression: IrGetEnumValue, data: D): R = - visitSingletonReference(expression, data) + fun visitGetEnumValue(expression: IrGetEnumValue, data: D): R = visitSingletonReference(expression, data) - fun visitRawFunctionReference(expression: IrRawFunctionReference, data: D): R = - visitDeclarationReference(expression, data) + fun visitRawFunctionReference(expression: IrRawFunctionReference, data: D): R = visitDeclarationReference(expression, data) - fun visitContainerExpression(expression: IrContainerExpression, data: D): R = - visitExpression(expression, data) + fun visitContainerExpression(expression: IrContainerExpression, data: D): R = visitExpression(expression, data) - fun visitBlock(expression: IrBlock, data: D): R = visitContainerExpression(expression, - data) + fun visitBlock(expression: IrBlock, data: D): R = visitContainerExpression(expression, data) - fun visitComposite(expression: IrComposite, data: D): R = - visitContainerExpression(expression, data) + fun visitComposite(expression: IrComposite, data: D): R = visitContainerExpression(expression, data) fun visitSyntheticBody(body: IrSyntheticBody, data: D): R = visitBody(body, data) @@ -205,73 +96,51 @@ interface IrElementVisitor { fun visitCall(expression: IrCall, data: D): R = visitFunctionAccess(expression, data) - fun visitCallableReference(expression: IrCallableReference<*>, data: D): R = - visitMemberAccess(expression, data) + fun visitCallableReference(expression: IrCallableReference<*>, data: D): R = visitMemberAccess(expression, data) - fun visitFunctionReference(expression: IrFunctionReference, data: D): R = - visitCallableReference(expression, data) + fun visitFunctionReference(expression: IrFunctionReference, data: D): R = visitCallableReference(expression, data) - fun visitPropertyReference(expression: IrPropertyReference, data: D): R = - visitCallableReference(expression, data) + fun visitPropertyReference(expression: IrPropertyReference, data: D): R = visitCallableReference(expression, data) - fun visitLocalDelegatedPropertyReference(expression: IrLocalDelegatedPropertyReference, - data: D): R = visitCallableReference(expression, data) + fun visitLocalDelegatedPropertyReference(expression: IrLocalDelegatedPropertyReference, data: D): R = visitCallableReference(expression, data) - fun visitClassReference(expression: IrClassReference, data: D): R = - visitDeclarationReference(expression, data) + fun visitClassReference(expression: IrClassReference, data: D): R = visitDeclarationReference(expression, data) fun visitConst(expression: IrConst<*>, data: D): R = visitExpression(expression, data) - fun visitConstantValue(expression: IrConstantValue, data: D): R = - visitExpression(expression, data) + fun visitConstantValue(expression: IrConstantValue, data: D): R = visitExpression(expression, data) - fun visitConstantPrimitive(expression: IrConstantPrimitive, data: D): R = - visitConstantValue(expression, data) + fun visitConstantPrimitive(expression: IrConstantPrimitive, data: D): R = visitConstantValue(expression, data) - fun visitConstantObject(expression: IrConstantObject, data: D): R = - visitConstantValue(expression, data) + fun visitConstantObject(expression: IrConstantObject, data: D): R = visitConstantValue(expression, data) - fun visitConstantArray(expression: IrConstantArray, data: D): R = - visitConstantValue(expression, data) + fun visitConstantArray(expression: IrConstantArray, data: D): R = visitConstantValue(expression, data) - fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall, data: D): R - = visitFunctionAccess(expression, data) + fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall, data: D): R = visitFunctionAccess(expression, data) - fun visitDynamicExpression(expression: IrDynamicExpression, data: D): R = - visitExpression(expression, data) + fun visitDynamicExpression(expression: IrDynamicExpression, data: D): R = visitExpression(expression, data) - fun visitDynamicOperatorExpression(expression: IrDynamicOperatorExpression, data: D): R - = visitDynamicExpression(expression, data) + fun visitDynamicOperatorExpression(expression: IrDynamicOperatorExpression, data: D): R = visitDynamicExpression(expression, data) - fun visitDynamicMemberExpression(expression: IrDynamicMemberExpression, data: D): R = - visitDynamicExpression(expression, data) + fun visitDynamicMemberExpression(expression: IrDynamicMemberExpression, data: D): R = visitDynamicExpression(expression, data) - fun visitEnumConstructorCall(expression: IrEnumConstructorCall, data: D): R = - visitFunctionAccess(expression, data) + fun visitEnumConstructorCall(expression: IrEnumConstructorCall, data: D): R = visitFunctionAccess(expression, data) - fun visitErrorExpression(expression: IrErrorExpression, data: D): R = - visitExpression(expression, data) + fun visitErrorExpression(expression: IrErrorExpression, data: D): R = visitExpression(expression, data) - fun visitErrorCallExpression(expression: IrErrorCallExpression, data: D): R = - visitErrorExpression(expression, data) + fun visitErrorCallExpression(expression: IrErrorCallExpression, data: D): R = visitErrorExpression(expression, data) - fun visitFieldAccess(expression: IrFieldAccessExpression, data: D): R = - visitDeclarationReference(expression, data) + fun visitFieldAccess(expression: IrFieldAccessExpression, data: D): R = visitDeclarationReference(expression, data) - fun visitGetField(expression: IrGetField, data: D): R = visitFieldAccess(expression, - data) + fun visitGetField(expression: IrGetField, data: D): R = visitFieldAccess(expression, data) - fun visitSetField(expression: IrSetField, data: D): R = visitFieldAccess(expression, - data) + fun visitSetField(expression: IrSetField, data: D): R = visitFieldAccess(expression, data) - fun visitFunctionExpression(expression: IrFunctionExpression, data: D): R = - visitExpression(expression, data) + fun visitFunctionExpression(expression: IrFunctionExpression, data: D): R = visitExpression(expression, data) - fun visitGetClass(expression: IrGetClass, data: D): R = visitExpression(expression, - data) + fun visitGetClass(expression: IrGetClass, data: D): R = visitExpression(expression, data) - fun visitInstanceInitializerCall(expression: IrInstanceInitializerCall, data: D): R = - visitExpression(expression, data) + fun visitInstanceInitializerCall(expression: IrInstanceInitializerCall, data: D): R = visitExpression(expression, data) fun visitLoop(loop: IrLoop, data: D): R = visitExpression(loop, data) @@ -281,14 +150,11 @@ interface IrElementVisitor { fun visitReturn(expression: IrReturn, data: D): R = visitExpression(expression, data) - fun visitStringConcatenation(expression: IrStringConcatenation, data: D): R = - visitExpression(expression, data) + fun visitStringConcatenation(expression: IrStringConcatenation, data: D): R = visitExpression(expression, data) - fun visitSuspensionPoint(expression: IrSuspensionPoint, data: D): R = - visitExpression(expression, data) + fun visitSuspensionPoint(expression: IrSuspensionPoint, data: D): R = visitExpression(expression, data) - fun visitSuspendableExpression(expression: IrSuspendableExpression, data: D): R = - visitExpression(expression, data) + fun visitSuspendableExpression(expression: IrSuspendableExpression, data: D): R = visitExpression(expression, data) fun visitThrow(expression: IrThrow, data: D): R = visitExpression(expression, data) @@ -296,22 +162,17 @@ interface IrElementVisitor { fun visitCatch(aCatch: IrCatch, data: D): R = visitElement(aCatch, data) - fun visitTypeOperator(expression: IrTypeOperatorCall, data: D): R = - visitExpression(expression, data) + fun visitTypeOperator(expression: IrTypeOperatorCall, data: D): R = visitExpression(expression, data) - fun visitValueAccess(expression: IrValueAccessExpression, data: D): R = - visitDeclarationReference(expression, data) + fun visitValueAccess(expression: IrValueAccessExpression, data: D): R = visitDeclarationReference(expression, data) - fun visitGetValue(expression: IrGetValue, data: D): R = visitValueAccess(expression, - data) + fun visitGetValue(expression: IrGetValue, data: D): R = visitValueAccess(expression, data) - fun visitSetValue(expression: IrSetValue, data: D): R = visitValueAccess(expression, - data) + fun visitSetValue(expression: IrSetValue, data: D): R = visitValueAccess(expression, data) fun visitVararg(expression: IrVararg, data: D): R = visitExpression(expression, data) - fun visitSpreadElement(spread: IrSpreadElement, data: D): R = visitElement(spread, - data) + fun visitSpreadElement(spread: IrSpreadElement, data: D): R = visitElement(spread, data) fun visitWhen(expression: IrWhen, data: D): R = visitExpression(expression, data) diff --git a/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/visitors/IrElementVisitorVoid.kt b/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/visitors/IrElementVisitorVoid.kt index 264f3a49344..9f48615b8f0 100644 --- a/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/visitors/IrElementVisitorVoid.kt +++ b/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/visitors/IrElementVisitorVoid.kt @@ -9,515 +9,671 @@ package org.jetbrains.kotlin.ir.visitors import org.jetbrains.kotlin.ir.IrElement -import org.jetbrains.kotlin.ir.declarations.IrAnonymousInitializer -import org.jetbrains.kotlin.ir.declarations.IrClass -import org.jetbrains.kotlin.ir.declarations.IrConstructor -import org.jetbrains.kotlin.ir.declarations.IrDeclarationBase -import org.jetbrains.kotlin.ir.declarations.IrEnumEntry -import org.jetbrains.kotlin.ir.declarations.IrErrorDeclaration -import org.jetbrains.kotlin.ir.declarations.IrExternalPackageFragment -import org.jetbrains.kotlin.ir.declarations.IrField -import org.jetbrains.kotlin.ir.declarations.IrFile -import org.jetbrains.kotlin.ir.declarations.IrFunction -import org.jetbrains.kotlin.ir.declarations.IrLocalDelegatedProperty -import org.jetbrains.kotlin.ir.declarations.IrModuleFragment -import org.jetbrains.kotlin.ir.declarations.IrPackageFragment -import org.jetbrains.kotlin.ir.declarations.IrProperty -import org.jetbrains.kotlin.ir.declarations.IrScript -import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction -import org.jetbrains.kotlin.ir.declarations.IrTypeAlias -import org.jetbrains.kotlin.ir.declarations.IrTypeParameter -import org.jetbrains.kotlin.ir.declarations.IrValueParameter -import org.jetbrains.kotlin.ir.declarations.IrVariable -import org.jetbrains.kotlin.ir.expressions.IrBlock -import org.jetbrains.kotlin.ir.expressions.IrBlockBody -import org.jetbrains.kotlin.ir.expressions.IrBody -import org.jetbrains.kotlin.ir.expressions.IrBranch -import org.jetbrains.kotlin.ir.expressions.IrBreak -import org.jetbrains.kotlin.ir.expressions.IrBreakContinue -import org.jetbrains.kotlin.ir.expressions.IrCall -import org.jetbrains.kotlin.ir.expressions.IrCallableReference -import org.jetbrains.kotlin.ir.expressions.IrCatch -import org.jetbrains.kotlin.ir.expressions.IrClassReference -import org.jetbrains.kotlin.ir.expressions.IrComposite -import org.jetbrains.kotlin.ir.expressions.IrConst -import org.jetbrains.kotlin.ir.expressions.IrConstantArray -import org.jetbrains.kotlin.ir.expressions.IrConstantObject -import org.jetbrains.kotlin.ir.expressions.IrConstantPrimitive -import org.jetbrains.kotlin.ir.expressions.IrConstantValue -import org.jetbrains.kotlin.ir.expressions.IrConstructorCall -import org.jetbrains.kotlin.ir.expressions.IrContainerExpression -import org.jetbrains.kotlin.ir.expressions.IrContinue -import org.jetbrains.kotlin.ir.expressions.IrDeclarationReference -import org.jetbrains.kotlin.ir.expressions.IrDelegatingConstructorCall -import org.jetbrains.kotlin.ir.expressions.IrDoWhileLoop -import org.jetbrains.kotlin.ir.expressions.IrDynamicExpression -import org.jetbrains.kotlin.ir.expressions.IrDynamicMemberExpression -import org.jetbrains.kotlin.ir.expressions.IrDynamicOperatorExpression -import org.jetbrains.kotlin.ir.expressions.IrElseBranch -import org.jetbrains.kotlin.ir.expressions.IrEnumConstructorCall -import org.jetbrains.kotlin.ir.expressions.IrErrorCallExpression -import org.jetbrains.kotlin.ir.expressions.IrErrorExpression -import org.jetbrains.kotlin.ir.expressions.IrExpression -import org.jetbrains.kotlin.ir.expressions.IrExpressionBody -import org.jetbrains.kotlin.ir.expressions.IrFieldAccessExpression -import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression -import org.jetbrains.kotlin.ir.expressions.IrFunctionExpression -import org.jetbrains.kotlin.ir.expressions.IrFunctionReference -import org.jetbrains.kotlin.ir.expressions.IrGetClass -import org.jetbrains.kotlin.ir.expressions.IrGetEnumValue -import org.jetbrains.kotlin.ir.expressions.IrGetField -import org.jetbrains.kotlin.ir.expressions.IrGetObjectValue -import org.jetbrains.kotlin.ir.expressions.IrGetSingletonValue -import org.jetbrains.kotlin.ir.expressions.IrGetValue -import org.jetbrains.kotlin.ir.expressions.IrInstanceInitializerCall -import org.jetbrains.kotlin.ir.expressions.IrLocalDelegatedPropertyReference -import org.jetbrains.kotlin.ir.expressions.IrLoop -import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression -import org.jetbrains.kotlin.ir.expressions.IrPropertyReference -import org.jetbrains.kotlin.ir.expressions.IrRawFunctionReference -import org.jetbrains.kotlin.ir.expressions.IrReturn -import org.jetbrains.kotlin.ir.expressions.IrSetField -import org.jetbrains.kotlin.ir.expressions.IrSetValue -import org.jetbrains.kotlin.ir.expressions.IrSpreadElement -import org.jetbrains.kotlin.ir.expressions.IrStringConcatenation -import org.jetbrains.kotlin.ir.expressions.IrSuspendableExpression -import org.jetbrains.kotlin.ir.expressions.IrSuspensionPoint -import org.jetbrains.kotlin.ir.expressions.IrSyntheticBody -import org.jetbrains.kotlin.ir.expressions.IrThrow -import org.jetbrains.kotlin.ir.expressions.IrTry -import org.jetbrains.kotlin.ir.expressions.IrTypeOperatorCall -import org.jetbrains.kotlin.ir.expressions.IrValueAccessExpression -import org.jetbrains.kotlin.ir.expressions.IrVararg -import org.jetbrains.kotlin.ir.expressions.IrWhen -import org.jetbrains.kotlin.ir.expressions.IrWhileLoop +import org.jetbrains.kotlin.ir.declarations.* +import org.jetbrains.kotlin.ir.expressions.* interface IrElementVisitorVoid : IrElementVisitor { - override fun visitElement(element: IrElement, data: Nothing?) = visitElement(element) + + override fun visitElement(element: IrElement, data: Nothing?) { + visitElement(element) + } fun visitElement(element: IrElement) { } - override fun visitDeclaration(declaration: IrDeclarationBase, data: Nothing?) = - visitDeclaration(declaration) + override fun visitDeclaration(declaration: IrDeclarationBase, data: Nothing?) { + visitDeclaration(declaration) + } - fun visitDeclaration(declaration: IrDeclarationBase) = visitElement(declaration) + fun visitDeclaration(declaration: IrDeclarationBase) { + visitElement(declaration) + } - override fun visitValueParameter(declaration: IrValueParameter, data: Nothing?) = - visitValueParameter(declaration) + override fun visitValueParameter(declaration: IrValueParameter, data: Nothing?) { + visitValueParameter(declaration) + } - fun visitValueParameter(declaration: IrValueParameter) = visitDeclaration(declaration) + fun visitValueParameter(declaration: IrValueParameter) { + visitDeclaration(declaration) + } - override fun visitClass(declaration: IrClass, data: Nothing?) = visitClass(declaration) + override fun visitClass(declaration: IrClass, data: Nothing?) { + visitClass(declaration) + } - fun visitClass(declaration: IrClass) = visitDeclaration(declaration) + fun visitClass(declaration: IrClass) { + visitDeclaration(declaration) + } - override fun visitAnonymousInitializer(declaration: IrAnonymousInitializer, - data: Nothing?) = visitAnonymousInitializer(declaration) + override fun visitAnonymousInitializer(declaration: IrAnonymousInitializer, data: Nothing?) { + visitAnonymousInitializer(declaration) + } - fun visitAnonymousInitializer(declaration: IrAnonymousInitializer) = - visitDeclaration(declaration) + fun visitAnonymousInitializer(declaration: IrAnonymousInitializer) { + visitDeclaration(declaration) + } - override fun visitTypeParameter(declaration: IrTypeParameter, data: Nothing?) = - visitTypeParameter(declaration) + override fun visitTypeParameter(declaration: IrTypeParameter, data: Nothing?) { + visitTypeParameter(declaration) + } - fun visitTypeParameter(declaration: IrTypeParameter) = visitDeclaration(declaration) + fun visitTypeParameter(declaration: IrTypeParameter) { + visitDeclaration(declaration) + } - override fun visitFunction(declaration: IrFunction, data: Nothing?) = - visitFunction(declaration) + override fun visitFunction(declaration: IrFunction, data: Nothing?) { + visitFunction(declaration) + } - fun visitFunction(declaration: IrFunction) = visitDeclaration(declaration) + fun visitFunction(declaration: IrFunction) { + visitDeclaration(declaration) + } - override fun visitConstructor(declaration: IrConstructor, data: Nothing?) = - visitConstructor(declaration) + override fun visitConstructor(declaration: IrConstructor, data: Nothing?) { + visitConstructor(declaration) + } - fun visitConstructor(declaration: IrConstructor) = visitFunction(declaration) + fun visitConstructor(declaration: IrConstructor) { + visitFunction(declaration) + } - override fun visitEnumEntry(declaration: IrEnumEntry, data: Nothing?) = - visitEnumEntry(declaration) + override fun visitEnumEntry(declaration: IrEnumEntry, data: Nothing?) { + visitEnumEntry(declaration) + } - fun visitEnumEntry(declaration: IrEnumEntry) = visitDeclaration(declaration) + fun visitEnumEntry(declaration: IrEnumEntry) { + visitDeclaration(declaration) + } - override fun visitErrorDeclaration(declaration: IrErrorDeclaration, data: Nothing?) = - visitErrorDeclaration(declaration) + override fun visitErrorDeclaration(declaration: IrErrorDeclaration, data: Nothing?) { + visitErrorDeclaration(declaration) + } - fun visitErrorDeclaration(declaration: IrErrorDeclaration) = - visitDeclaration(declaration) + fun visitErrorDeclaration(declaration: IrErrorDeclaration) { + visitDeclaration(declaration) + } - override fun visitField(declaration: IrField, data: Nothing?) = visitField(declaration) + override fun visitField(declaration: IrField, data: Nothing?) { + visitField(declaration) + } - fun visitField(declaration: IrField) = visitDeclaration(declaration) + fun visitField(declaration: IrField) { + visitDeclaration(declaration) + } - override fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty, - data: Nothing?) = visitLocalDelegatedProperty(declaration) + override fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty, data: Nothing?) { + visitLocalDelegatedProperty(declaration) + } - fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty) = - visitDeclaration(declaration) + fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty) { + visitDeclaration(declaration) + } - override fun visitModuleFragment(declaration: IrModuleFragment, data: Nothing?) = - visitModuleFragment(declaration) + override fun visitModuleFragment(declaration: IrModuleFragment, data: Nothing?) { + visitModuleFragment(declaration) + } - fun visitModuleFragment(declaration: IrModuleFragment) = visitElement(declaration) + fun visitModuleFragment(declaration: IrModuleFragment) { + visitElement(declaration) + } - override fun visitProperty(declaration: IrProperty, data: Nothing?) = - visitProperty(declaration) + override fun visitProperty(declaration: IrProperty, data: Nothing?) { + visitProperty(declaration) + } - fun visitProperty(declaration: IrProperty) = visitDeclaration(declaration) + fun visitProperty(declaration: IrProperty) { + visitDeclaration(declaration) + } - override fun visitScript(declaration: IrScript, data: Nothing?) = - visitScript(declaration) + override fun visitScript(declaration: IrScript, data: Nothing?) { + visitScript(declaration) + } - fun visitScript(declaration: IrScript) = visitDeclaration(declaration) + fun visitScript(declaration: IrScript) { + visitDeclaration(declaration) + } - override fun visitSimpleFunction(declaration: IrSimpleFunction, data: Nothing?) = - visitSimpleFunction(declaration) + override fun visitSimpleFunction(declaration: IrSimpleFunction, data: Nothing?) { + visitSimpleFunction(declaration) + } - fun visitSimpleFunction(declaration: IrSimpleFunction) = visitFunction(declaration) + fun visitSimpleFunction(declaration: IrSimpleFunction) { + visitFunction(declaration) + } - override fun visitTypeAlias(declaration: IrTypeAlias, data: Nothing?) = - visitTypeAlias(declaration) + override fun visitTypeAlias(declaration: IrTypeAlias, data: Nothing?) { + visitTypeAlias(declaration) + } - fun visitTypeAlias(declaration: IrTypeAlias) = visitDeclaration(declaration) + fun visitTypeAlias(declaration: IrTypeAlias) { + visitDeclaration(declaration) + } - override fun visitVariable(declaration: IrVariable, data: Nothing?) = - visitVariable(declaration) + override fun visitVariable(declaration: IrVariable, data: Nothing?) { + visitVariable(declaration) + } - fun visitVariable(declaration: IrVariable) = visitDeclaration(declaration) + fun visitVariable(declaration: IrVariable) { + visitDeclaration(declaration) + } - override fun visitPackageFragment(declaration: IrPackageFragment, data: Nothing?) = - visitPackageFragment(declaration) + override fun visitPackageFragment(declaration: IrPackageFragment, data: Nothing?) { + visitPackageFragment(declaration) + } - fun visitPackageFragment(declaration: IrPackageFragment) = visitElement(declaration) + fun visitPackageFragment(declaration: IrPackageFragment) { + visitElement(declaration) + } - override fun visitExternalPackageFragment(declaration: IrExternalPackageFragment, - data: Nothing?) = visitExternalPackageFragment(declaration) + override fun visitExternalPackageFragment(declaration: IrExternalPackageFragment, data: Nothing?) { + visitExternalPackageFragment(declaration) + } - fun visitExternalPackageFragment(declaration: IrExternalPackageFragment) = - visitPackageFragment(declaration) + fun visitExternalPackageFragment(declaration: IrExternalPackageFragment) { + visitPackageFragment(declaration) + } - override fun visitFile(declaration: IrFile, data: Nothing?) = visitFile(declaration) + override fun visitFile(declaration: IrFile, data: Nothing?) { + visitFile(declaration) + } - fun visitFile(declaration: IrFile) = visitPackageFragment(declaration) + fun visitFile(declaration: IrFile) { + visitPackageFragment(declaration) + } - override fun visitExpression(expression: IrExpression, data: Nothing?) = - visitExpression(expression) + override fun visitExpression(expression: IrExpression, data: Nothing?) { + visitExpression(expression) + } - fun visitExpression(expression: IrExpression) = visitElement(expression) + fun visitExpression(expression: IrExpression) { + visitElement(expression) + } - override fun visitBody(body: IrBody, data: Nothing?) = visitBody(body) + override fun visitBody(body: IrBody, data: Nothing?) { + visitBody(body) + } - fun visitBody(body: IrBody) = visitElement(body) + fun visitBody(body: IrBody) { + visitElement(body) + } - override fun visitExpressionBody(body: IrExpressionBody, data: Nothing?) = - visitExpressionBody(body) + override fun visitExpressionBody(body: IrExpressionBody, data: Nothing?) { + visitExpressionBody(body) + } - fun visitExpressionBody(body: IrExpressionBody) = visitBody(body) + fun visitExpressionBody(body: IrExpressionBody) { + visitBody(body) + } - override fun visitBlockBody(body: IrBlockBody, data: Nothing?) = visitBlockBody(body) + override fun visitBlockBody(body: IrBlockBody, data: Nothing?) { + visitBlockBody(body) + } - fun visitBlockBody(body: IrBlockBody) = visitBody(body) + fun visitBlockBody(body: IrBlockBody) { + visitBody(body) + } - override fun visitDeclarationReference(expression: IrDeclarationReference, - data: Nothing?) = visitDeclarationReference(expression) + override fun visitDeclarationReference(expression: IrDeclarationReference, data: Nothing?) { + visitDeclarationReference(expression) + } - fun visitDeclarationReference(expression: IrDeclarationReference) = - visitExpression(expression) + fun visitDeclarationReference(expression: IrDeclarationReference) { + visitExpression(expression) + } - override fun visitMemberAccess(expression: IrMemberAccessExpression<*>, data: Nothing?) - = visitMemberAccess(expression) + override fun visitMemberAccess(expression: IrMemberAccessExpression<*>, data: Nothing?) { + visitMemberAccess(expression) + } - fun visitMemberAccess(expression: IrMemberAccessExpression<*>) = - visitDeclarationReference(expression) + fun visitMemberAccess(expression: IrMemberAccessExpression<*>) { + visitDeclarationReference(expression) + } - override fun visitFunctionAccess(expression: IrFunctionAccessExpression, - data: Nothing?) = visitFunctionAccess(expression) + override fun visitFunctionAccess(expression: IrFunctionAccessExpression, data: Nothing?) { + visitFunctionAccess(expression) + } - fun visitFunctionAccess(expression: IrFunctionAccessExpression) = - visitMemberAccess(expression) + fun visitFunctionAccess(expression: IrFunctionAccessExpression) { + visitMemberAccess(expression) + } - override fun visitConstructorCall(expression: IrConstructorCall, data: Nothing?) = - visitConstructorCall(expression) + override fun visitConstructorCall(expression: IrConstructorCall, data: Nothing?) { + visitConstructorCall(expression) + } - fun visitConstructorCall(expression: IrConstructorCall) = visitFunctionAccess(expression) + fun visitConstructorCall(expression: IrConstructorCall) { + visitFunctionAccess(expression) + } - override fun visitSingletonReference(expression: IrGetSingletonValue, data: Nothing?) = - visitSingletonReference(expression) + override fun visitSingletonReference(expression: IrGetSingletonValue, data: Nothing?) { + visitSingletonReference(expression) + } - fun visitSingletonReference(expression: IrGetSingletonValue) = - visitDeclarationReference(expression) + fun visitSingletonReference(expression: IrGetSingletonValue) { + visitDeclarationReference(expression) + } - override fun visitGetObjectValue(expression: IrGetObjectValue, data: Nothing?) = - visitGetObjectValue(expression) + override fun visitGetObjectValue(expression: IrGetObjectValue, data: Nothing?) { + visitGetObjectValue(expression) + } - fun visitGetObjectValue(expression: IrGetObjectValue) = - visitSingletonReference(expression) + fun visitGetObjectValue(expression: IrGetObjectValue) { + visitSingletonReference(expression) + } - override fun visitGetEnumValue(expression: IrGetEnumValue, data: Nothing?) = - visitGetEnumValue(expression) + override fun visitGetEnumValue(expression: IrGetEnumValue, data: Nothing?) { + visitGetEnumValue(expression) + } - fun visitGetEnumValue(expression: IrGetEnumValue) = visitSingletonReference(expression) + fun visitGetEnumValue(expression: IrGetEnumValue) { + visitSingletonReference(expression) + } - override fun visitRawFunctionReference(expression: IrRawFunctionReference, - data: Nothing?) = visitRawFunctionReference(expression) + override fun visitRawFunctionReference(expression: IrRawFunctionReference, data: Nothing?) { + visitRawFunctionReference(expression) + } - fun visitRawFunctionReference(expression: IrRawFunctionReference) = - visitDeclarationReference(expression) + fun visitRawFunctionReference(expression: IrRawFunctionReference) { + visitDeclarationReference(expression) + } - override fun visitContainerExpression(expression: IrContainerExpression, - data: Nothing?) = visitContainerExpression(expression) + override fun visitContainerExpression(expression: IrContainerExpression, data: Nothing?) { + visitContainerExpression(expression) + } - fun visitContainerExpression(expression: IrContainerExpression) = - visitExpression(expression) + fun visitContainerExpression(expression: IrContainerExpression) { + visitExpression(expression) + } - override fun visitBlock(expression: IrBlock, data: Nothing?) = visitBlock(expression) + override fun visitBlock(expression: IrBlock, data: Nothing?) { + visitBlock(expression) + } - fun visitBlock(expression: IrBlock) = visitContainerExpression(expression) + fun visitBlock(expression: IrBlock) { + visitContainerExpression(expression) + } - override fun visitComposite(expression: IrComposite, data: Nothing?) = - visitComposite(expression) + override fun visitComposite(expression: IrComposite, data: Nothing?) { + visitComposite(expression) + } - fun visitComposite(expression: IrComposite) = visitContainerExpression(expression) + fun visitComposite(expression: IrComposite) { + visitContainerExpression(expression) + } - override fun visitSyntheticBody(body: IrSyntheticBody, data: Nothing?) = - visitSyntheticBody(body) + override fun visitSyntheticBody(body: IrSyntheticBody, data: Nothing?) { + visitSyntheticBody(body) + } - fun visitSyntheticBody(body: IrSyntheticBody) = visitBody(body) + fun visitSyntheticBody(body: IrSyntheticBody) { + visitBody(body) + } - override fun visitBreakContinue(jump: IrBreakContinue, data: Nothing?) = - visitBreakContinue(jump) + override fun visitBreakContinue(jump: IrBreakContinue, data: Nothing?) { + visitBreakContinue(jump) + } - fun visitBreakContinue(jump: IrBreakContinue) = visitExpression(jump) + fun visitBreakContinue(jump: IrBreakContinue) { + visitExpression(jump) + } - override fun visitBreak(jump: IrBreak, data: Nothing?) = visitBreak(jump) + override fun visitBreak(jump: IrBreak, data: Nothing?) { + visitBreak(jump) + } - fun visitBreak(jump: IrBreak) = visitBreakContinue(jump) + fun visitBreak(jump: IrBreak) { + visitBreakContinue(jump) + } - override fun visitContinue(jump: IrContinue, data: Nothing?) = visitContinue(jump) + override fun visitContinue(jump: IrContinue, data: Nothing?) { + visitContinue(jump) + } - fun visitContinue(jump: IrContinue) = visitBreakContinue(jump) + fun visitContinue(jump: IrContinue) { + visitBreakContinue(jump) + } - override fun visitCall(expression: IrCall, data: Nothing?) = visitCall(expression) + override fun visitCall(expression: IrCall, data: Nothing?) { + visitCall(expression) + } - fun visitCall(expression: IrCall) = visitFunctionAccess(expression) + fun visitCall(expression: IrCall) { + visitFunctionAccess(expression) + } - override fun visitCallableReference(expression: IrCallableReference<*>, data: Nothing?) - = visitCallableReference(expression) + override fun visitCallableReference(expression: IrCallableReference<*>, data: Nothing?) { + visitCallableReference(expression) + } - fun visitCallableReference(expression: IrCallableReference<*>) = - visitMemberAccess(expression) + fun visitCallableReference(expression: IrCallableReference<*>) { + visitMemberAccess(expression) + } - override fun visitFunctionReference(expression: IrFunctionReference, data: Nothing?) = - visitFunctionReference(expression) + override fun visitFunctionReference(expression: IrFunctionReference, data: Nothing?) { + visitFunctionReference(expression) + } - fun visitFunctionReference(expression: IrFunctionReference) = - visitCallableReference(expression) + fun visitFunctionReference(expression: IrFunctionReference) { + visitCallableReference(expression) + } - override fun visitPropertyReference(expression: IrPropertyReference, data: Nothing?) = - visitPropertyReference(expression) + override fun visitPropertyReference(expression: IrPropertyReference, data: Nothing?) { + visitPropertyReference(expression) + } - fun visitPropertyReference(expression: IrPropertyReference) = - visitCallableReference(expression) + fun visitPropertyReference(expression: IrPropertyReference) { + visitCallableReference(expression) + } - override - fun visitLocalDelegatedPropertyReference(expression: IrLocalDelegatedPropertyReference, - data: Nothing?) = visitLocalDelegatedPropertyReference(expression) + override fun visitLocalDelegatedPropertyReference(expression: IrLocalDelegatedPropertyReference, data: Nothing?) { + visitLocalDelegatedPropertyReference(expression) + } - fun visitLocalDelegatedPropertyReference(expression: IrLocalDelegatedPropertyReference) = - visitCallableReference(expression) + fun visitLocalDelegatedPropertyReference(expression: IrLocalDelegatedPropertyReference) { + visitCallableReference(expression) + } - override fun visitClassReference(expression: IrClassReference, data: Nothing?) = - visitClassReference(expression) + override fun visitClassReference(expression: IrClassReference, data: Nothing?) { + visitClassReference(expression) + } - fun visitClassReference(expression: IrClassReference) = - visitDeclarationReference(expression) + fun visitClassReference(expression: IrClassReference) { + visitDeclarationReference(expression) + } - override fun visitConst(expression: IrConst<*>, data: Nothing?) = - visitConst(expression) + override fun visitConst(expression: IrConst<*>, data: Nothing?) { + visitConst(expression) + } - fun visitConst(expression: IrConst<*>) = visitExpression(expression) + fun visitConst(expression: IrConst<*>) { + visitExpression(expression) + } - override fun visitConstantValue(expression: IrConstantValue, data: Nothing?) = - visitConstantValue(expression) + override fun visitConstantValue(expression: IrConstantValue, data: Nothing?) { + visitConstantValue(expression) + } - fun visitConstantValue(expression: IrConstantValue) = visitExpression(expression) + fun visitConstantValue(expression: IrConstantValue) { + visitExpression(expression) + } - override fun visitConstantPrimitive(expression: IrConstantPrimitive, data: Nothing?) = - visitConstantPrimitive(expression) + override fun visitConstantPrimitive(expression: IrConstantPrimitive, data: Nothing?) { + visitConstantPrimitive(expression) + } - fun visitConstantPrimitive(expression: IrConstantPrimitive) = - visitConstantValue(expression) + fun visitConstantPrimitive(expression: IrConstantPrimitive) { + visitConstantValue(expression) + } - override fun visitConstantObject(expression: IrConstantObject, data: Nothing?) = - visitConstantObject(expression) + override fun visitConstantObject(expression: IrConstantObject, data: Nothing?) { + visitConstantObject(expression) + } - fun visitConstantObject(expression: IrConstantObject) = visitConstantValue(expression) + fun visitConstantObject(expression: IrConstantObject) { + visitConstantValue(expression) + } - override fun visitConstantArray(expression: IrConstantArray, data: Nothing?) = - visitConstantArray(expression) + override fun visitConstantArray(expression: IrConstantArray, data: Nothing?) { + visitConstantArray(expression) + } - fun visitConstantArray(expression: IrConstantArray) = visitConstantValue(expression) + fun visitConstantArray(expression: IrConstantArray) { + visitConstantValue(expression) + } - override fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall, - data: Nothing?) = visitDelegatingConstructorCall(expression) + override fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall, data: Nothing?) { + visitDelegatingConstructorCall(expression) + } - fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall) = - visitFunctionAccess(expression) + fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall) { + visitFunctionAccess(expression) + } - override fun visitDynamicExpression(expression: IrDynamicExpression, data: Nothing?) = - visitDynamicExpression(expression) + override fun visitDynamicExpression(expression: IrDynamicExpression, data: Nothing?) { + visitDynamicExpression(expression) + } - fun visitDynamicExpression(expression: IrDynamicExpression) = visitExpression(expression) + fun visitDynamicExpression(expression: IrDynamicExpression) { + visitExpression(expression) + } - override fun visitDynamicOperatorExpression(expression: IrDynamicOperatorExpression, - data: Nothing?) = visitDynamicOperatorExpression(expression) + override fun visitDynamicOperatorExpression(expression: IrDynamicOperatorExpression, data: Nothing?) { + visitDynamicOperatorExpression(expression) + } - fun visitDynamicOperatorExpression(expression: IrDynamicOperatorExpression) = - visitDynamicExpression(expression) + fun visitDynamicOperatorExpression(expression: IrDynamicOperatorExpression) { + visitDynamicExpression(expression) + } - override fun visitDynamicMemberExpression(expression: IrDynamicMemberExpression, - data: Nothing?) = visitDynamicMemberExpression(expression) + override fun visitDynamicMemberExpression(expression: IrDynamicMemberExpression, data: Nothing?) { + visitDynamicMemberExpression(expression) + } - fun visitDynamicMemberExpression(expression: IrDynamicMemberExpression) = - visitDynamicExpression(expression) + fun visitDynamicMemberExpression(expression: IrDynamicMemberExpression) { + visitDynamicExpression(expression) + } - override fun visitEnumConstructorCall(expression: IrEnumConstructorCall, - data: Nothing?) = visitEnumConstructorCall(expression) + override fun visitEnumConstructorCall(expression: IrEnumConstructorCall, data: Nothing?) { + visitEnumConstructorCall(expression) + } - fun visitEnumConstructorCall(expression: IrEnumConstructorCall) = - visitFunctionAccess(expression) + fun visitEnumConstructorCall(expression: IrEnumConstructorCall) { + visitFunctionAccess(expression) + } - override fun visitErrorExpression(expression: IrErrorExpression, data: Nothing?) = - visitErrorExpression(expression) + override fun visitErrorExpression(expression: IrErrorExpression, data: Nothing?) { + visitErrorExpression(expression) + } - fun visitErrorExpression(expression: IrErrorExpression) = visitExpression(expression) + fun visitErrorExpression(expression: IrErrorExpression) { + visitExpression(expression) + } - override fun visitErrorCallExpression(expression: IrErrorCallExpression, - data: Nothing?) = visitErrorCallExpression(expression) + override fun visitErrorCallExpression(expression: IrErrorCallExpression, data: Nothing?) { + visitErrorCallExpression(expression) + } - fun visitErrorCallExpression(expression: IrErrorCallExpression) = - visitErrorExpression(expression) + fun visitErrorCallExpression(expression: IrErrorCallExpression) { + visitErrorExpression(expression) + } - override fun visitFieldAccess(expression: IrFieldAccessExpression, data: Nothing?) = - visitFieldAccess(expression) + override fun visitFieldAccess(expression: IrFieldAccessExpression, data: Nothing?) { + visitFieldAccess(expression) + } - fun visitFieldAccess(expression: IrFieldAccessExpression) = - visitDeclarationReference(expression) + fun visitFieldAccess(expression: IrFieldAccessExpression) { + visitDeclarationReference(expression) + } - override fun visitGetField(expression: IrGetField, data: Nothing?) = - visitGetField(expression) + override fun visitGetField(expression: IrGetField, data: Nothing?) { + visitGetField(expression) + } - fun visitGetField(expression: IrGetField) = visitFieldAccess(expression) + fun visitGetField(expression: IrGetField) { + visitFieldAccess(expression) + } - override fun visitSetField(expression: IrSetField, data: Nothing?) = - visitSetField(expression) + override fun visitSetField(expression: IrSetField, data: Nothing?) { + visitSetField(expression) + } - fun visitSetField(expression: IrSetField) = visitFieldAccess(expression) + fun visitSetField(expression: IrSetField) { + visitFieldAccess(expression) + } - override fun visitFunctionExpression(expression: IrFunctionExpression, data: Nothing?) - = visitFunctionExpression(expression) + override fun visitFunctionExpression(expression: IrFunctionExpression, data: Nothing?) { + visitFunctionExpression(expression) + } - fun visitFunctionExpression(expression: IrFunctionExpression) = - visitExpression(expression) + fun visitFunctionExpression(expression: IrFunctionExpression) { + visitExpression(expression) + } - override fun visitGetClass(expression: IrGetClass, data: Nothing?) = - visitGetClass(expression) + override fun visitGetClass(expression: IrGetClass, data: Nothing?) { + visitGetClass(expression) + } - fun visitGetClass(expression: IrGetClass) = visitExpression(expression) + fun visitGetClass(expression: IrGetClass) { + visitExpression(expression) + } - override fun visitInstanceInitializerCall(expression: IrInstanceInitializerCall, - data: Nothing?) = visitInstanceInitializerCall(expression) + override fun visitInstanceInitializerCall(expression: IrInstanceInitializerCall, data: Nothing?) { + visitInstanceInitializerCall(expression) + } - fun visitInstanceInitializerCall(expression: IrInstanceInitializerCall) = - visitExpression(expression) + fun visitInstanceInitializerCall(expression: IrInstanceInitializerCall) { + visitExpression(expression) + } - override fun visitLoop(loop: IrLoop, data: Nothing?) = visitLoop(loop) + override fun visitLoop(loop: IrLoop, data: Nothing?) { + visitLoop(loop) + } - fun visitLoop(loop: IrLoop) = visitExpression(loop) + fun visitLoop(loop: IrLoop) { + visitExpression(loop) + } - override fun visitWhileLoop(loop: IrWhileLoop, data: Nothing?) = visitWhileLoop(loop) + override fun visitWhileLoop(loop: IrWhileLoop, data: Nothing?) { + visitWhileLoop(loop) + } - fun visitWhileLoop(loop: IrWhileLoop) = visitLoop(loop) + fun visitWhileLoop(loop: IrWhileLoop) { + visitLoop(loop) + } - override fun visitDoWhileLoop(loop: IrDoWhileLoop, data: Nothing?) = - visitDoWhileLoop(loop) + override fun visitDoWhileLoop(loop: IrDoWhileLoop, data: Nothing?) { + visitDoWhileLoop(loop) + } - fun visitDoWhileLoop(loop: IrDoWhileLoop) = visitLoop(loop) + fun visitDoWhileLoop(loop: IrDoWhileLoop) { + visitLoop(loop) + } - override fun visitReturn(expression: IrReturn, data: Nothing?) = - visitReturn(expression) + override fun visitReturn(expression: IrReturn, data: Nothing?) { + visitReturn(expression) + } - fun visitReturn(expression: IrReturn) = visitExpression(expression) + fun visitReturn(expression: IrReturn) { + visitExpression(expression) + } - override fun visitStringConcatenation(expression: IrStringConcatenation, - data: Nothing?) = visitStringConcatenation(expression) + override fun visitStringConcatenation(expression: IrStringConcatenation, data: Nothing?) { + visitStringConcatenation(expression) + } - fun visitStringConcatenation(expression: IrStringConcatenation) = - visitExpression(expression) + fun visitStringConcatenation(expression: IrStringConcatenation) { + visitExpression(expression) + } - override fun visitSuspensionPoint(expression: IrSuspensionPoint, data: Nothing?) = - visitSuspensionPoint(expression) + override fun visitSuspensionPoint(expression: IrSuspensionPoint, data: Nothing?) { + visitSuspensionPoint(expression) + } - fun visitSuspensionPoint(expression: IrSuspensionPoint) = visitExpression(expression) + fun visitSuspensionPoint(expression: IrSuspensionPoint) { + visitExpression(expression) + } - override fun visitSuspendableExpression(expression: IrSuspendableExpression, - data: Nothing?) = visitSuspendableExpression(expression) + override fun visitSuspendableExpression(expression: IrSuspendableExpression, data: Nothing?) { + visitSuspendableExpression(expression) + } - fun visitSuspendableExpression(expression: IrSuspendableExpression) = - visitExpression(expression) + fun visitSuspendableExpression(expression: IrSuspendableExpression) { + visitExpression(expression) + } - override fun visitThrow(expression: IrThrow, data: Nothing?) = visitThrow(expression) + override fun visitThrow(expression: IrThrow, data: Nothing?) { + visitThrow(expression) + } - fun visitThrow(expression: IrThrow) = visitExpression(expression) + fun visitThrow(expression: IrThrow) { + visitExpression(expression) + } - override fun visitTry(aTry: IrTry, data: Nothing?) = visitTry(aTry) + override fun visitTry(aTry: IrTry, data: Nothing?) { + visitTry(aTry) + } - fun visitTry(aTry: IrTry) = visitExpression(aTry) + fun visitTry(aTry: IrTry) { + visitExpression(aTry) + } - override fun visitCatch(aCatch: IrCatch, data: Nothing?) = visitCatch(aCatch) + override fun visitCatch(aCatch: IrCatch, data: Nothing?) { + visitCatch(aCatch) + } - fun visitCatch(aCatch: IrCatch) = visitElement(aCatch) + fun visitCatch(aCatch: IrCatch) { + visitElement(aCatch) + } - override fun visitTypeOperator(expression: IrTypeOperatorCall, data: Nothing?) = - visitTypeOperator(expression) + override fun visitTypeOperator(expression: IrTypeOperatorCall, data: Nothing?) { + visitTypeOperator(expression) + } - fun visitTypeOperator(expression: IrTypeOperatorCall) = visitExpression(expression) + fun visitTypeOperator(expression: IrTypeOperatorCall) { + visitExpression(expression) + } - override fun visitValueAccess(expression: IrValueAccessExpression, data: Nothing?) = - visitValueAccess(expression) + override fun visitValueAccess(expression: IrValueAccessExpression, data: Nothing?) { + visitValueAccess(expression) + } - fun visitValueAccess(expression: IrValueAccessExpression) = - visitDeclarationReference(expression) + fun visitValueAccess(expression: IrValueAccessExpression) { + visitDeclarationReference(expression) + } - override fun visitGetValue(expression: IrGetValue, data: Nothing?) = - visitGetValue(expression) + override fun visitGetValue(expression: IrGetValue, data: Nothing?) { + visitGetValue(expression) + } - fun visitGetValue(expression: IrGetValue) = visitValueAccess(expression) + fun visitGetValue(expression: IrGetValue) { + visitValueAccess(expression) + } - override fun visitSetValue(expression: IrSetValue, data: Nothing?) = - visitSetValue(expression) + override fun visitSetValue(expression: IrSetValue, data: Nothing?) { + visitSetValue(expression) + } - fun visitSetValue(expression: IrSetValue) = visitValueAccess(expression) + fun visitSetValue(expression: IrSetValue) { + visitValueAccess(expression) + } - override fun visitVararg(expression: IrVararg, data: Nothing?) = - visitVararg(expression) + override fun visitVararg(expression: IrVararg, data: Nothing?) { + visitVararg(expression) + } - fun visitVararg(expression: IrVararg) = visitExpression(expression) + fun visitVararg(expression: IrVararg) { + visitExpression(expression) + } - override fun visitSpreadElement(spread: IrSpreadElement, data: Nothing?) = - visitSpreadElement(spread) + override fun visitSpreadElement(spread: IrSpreadElement, data: Nothing?) { + visitSpreadElement(spread) + } - fun visitSpreadElement(spread: IrSpreadElement) = visitElement(spread) + fun visitSpreadElement(spread: IrSpreadElement) { + visitElement(spread) + } - override fun visitWhen(expression: IrWhen, data: Nothing?) = visitWhen(expression) + override fun visitWhen(expression: IrWhen, data: Nothing?) { + visitWhen(expression) + } - fun visitWhen(expression: IrWhen) = visitExpression(expression) + fun visitWhen(expression: IrWhen) { + visitExpression(expression) + } - override fun visitBranch(branch: IrBranch, data: Nothing?) = visitBranch(branch) + override fun visitBranch(branch: IrBranch, data: Nothing?) { + visitBranch(branch) + } - fun visitBranch(branch: IrBranch) = visitElement(branch) + fun visitBranch(branch: IrBranch) { + visitElement(branch) + } - override fun visitElseBranch(branch: IrElseBranch, data: Nothing?) = - visitElseBranch(branch) + override fun visitElseBranch(branch: IrElseBranch, data: Nothing?) { + visitElseBranch(branch) + } - fun visitElseBranch(branch: IrElseBranch) = visitBranch(branch) + fun visitElseBranch(branch: IrElseBranch) { + visitBranch(branch) + } } diff --git a/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/visitors/IrTypeTransformer.kt b/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/visitors/IrTypeTransformer.kt index 226d8233f0a..69de3fdc344 100644 --- a/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/visitors/IrTypeTransformer.kt +++ b/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/visitors/IrTypeTransformer.kt @@ -10,34 +10,15 @@ package org.jetbrains.kotlin.ir.visitors import org.jetbrains.kotlin.ir.IrElement import org.jetbrains.kotlin.ir.IrStatement -import org.jetbrains.kotlin.ir.declarations.IrClass -import org.jetbrains.kotlin.ir.declarations.IrField -import org.jetbrains.kotlin.ir.declarations.IrFunction -import org.jetbrains.kotlin.ir.declarations.IrLocalDelegatedProperty -import org.jetbrains.kotlin.ir.declarations.IrScript -import org.jetbrains.kotlin.ir.declarations.IrTypeAlias -import org.jetbrains.kotlin.ir.declarations.IrTypeParameter -import org.jetbrains.kotlin.ir.declarations.IrValueParameter -import org.jetbrains.kotlin.ir.declarations.IrVariable -import org.jetbrains.kotlin.ir.expressions.IrClassReference -import org.jetbrains.kotlin.ir.expressions.IrConstantObject -import org.jetbrains.kotlin.ir.expressions.IrConstantValue -import org.jetbrains.kotlin.ir.expressions.IrExpression -import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression -import org.jetbrains.kotlin.ir.expressions.IrTypeOperatorCall -import org.jetbrains.kotlin.ir.expressions.IrVararg +import org.jetbrains.kotlin.ir.declarations.* +import org.jetbrains.kotlin.ir.expressions.* import org.jetbrains.kotlin.ir.types.IrType interface IrTypeTransformer : IrElementTransformer { - fun transformType( - container: IrElement, - type: Type, - data: D, - ): Type + fun transformType(container: IrElement, type: Type, data: D): Type override fun visitValueParameter(declaration: IrValueParameter, data: D): IrStatement { - declaration.varargElementType = transformType(declaration, declaration.varargElementType, - data) + declaration.varargElementType = transformType(declaration, declaration.varargElementType, data) declaration.type = transformType(declaration, declaration.type, data) return super.visitValueParameter(declaration, data) } @@ -65,8 +46,7 @@ interface IrTypeTransformer : IrElementTransformer { return super.visitField(declaration, data) } - override fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty, - data: D): IrStatement { + override fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty, data: D): IrStatement { declaration.type = transformType(declaration, declaration.type, data) return super.visitLocalDelegatedProperty(declaration, data) } @@ -91,8 +71,7 @@ interface IrTypeTransformer : IrElementTransformer { return super.visitExpression(expression, data) } - override fun visitMemberAccess(expression: IrMemberAccessExpression<*>, data: D): - IrElement { + override fun visitMemberAccess(expression: IrMemberAccessExpression<*>, data: D): IrElement { (0 until expression.typeArgumentsCount).forEach { expression.getTypeArgument(it)?.let { type -> expression.putTypeArgument(it, transformType(expression, type, data)) @@ -106,11 +85,9 @@ interface IrTypeTransformer : IrElementTransformer { return super.visitClassReference(expression, data) } - override fun visitConstantObject(expression: IrConstantObject, data: D): - IrConstantValue { + override fun visitConstantObject(expression: IrConstantObject, data: D): IrConstantValue { for (i in 0 until expression.typeArguments.size) { - expression.typeArguments[i] = transformType(expression, expression.typeArguments[i], - data) + expression.typeArguments[i] = transformType(expression, expression.typeArguments[i], data) } return super.visitConstantObject(expression, data) } diff --git a/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/CommonTypes.kt b/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/CommonTypes.kt index 65949c4df26..b569d2b7335 100644 --- a/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/CommonTypes.kt +++ b/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/CommonTypes.kt @@ -27,7 +27,9 @@ object Packages { val elementBaseType = type(tree, "IrElementBase", TypeKind.Class) val statementOriginType = type(exprs, "IrStatementOrigin") val elementVisitorType = type(visitors, "IrElementVisitor") +val elementVisitorVoidType = type(visitors, "IrElementVisitorVoid") val elementTransformerType = type(visitors, "IrElementTransformer") +val typeTransformerType = type(visitors, "IrTypeTransformer") val mutableAnnotationContainerType = type(declarations, "IrMutableAnnotationContainer") val irTypeType = type(types, "IrType") diff --git a/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/model/Model.kt b/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/model/Model.kt index 719bc0ddf53..c9e0c077157 100644 --- a/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/model/Model.kt +++ b/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/model/Model.kt @@ -37,7 +37,7 @@ class Element( override val args: Map get() = emptyMap() - var visitorParent: ElementRef? = null + override var parentInVisitor: Element? = null var transformerReturnType: Element? = null override var kind: ImplementationKind? = when (config.typeKind) { @@ -54,8 +54,8 @@ class Element( override var walkableChildren: List = emptyList() override val transformableChildren get() = walkableChildren.filter { it.transformable } - val visitFunName = "visit" + (config.visitorName ?: name).replaceFirstChar(Char::uppercaseChar) - val visitorParam = config.visitorParam ?: config.category.defaultVisitorParam + override val visitFunctionName = "visit" + (config.visitorName ?: name).replaceFirstChar(Char::uppercaseChar) + override val visitorParameterName = config.visitorParam ?: config.category.defaultVisitorParam override var hasAcceptMethod = config.accept diff --git a/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/model/Transformations.kt b/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/model/Transformations.kt index 7bc9f25cb02..46008288d00 100644 --- a/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/model/Transformations.kt +++ b/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/model/Transformations.kt @@ -123,7 +123,7 @@ private fun replaceElementRefs(config: Config, mapping: Map() el.elementParents = elParents.takeIf { it.isNotEmpty() || el == rootEl.element } ?: listOf(rootEl) el.otherParents = otherParents.castAll>().toMutableList() - el.visitorParent = ec.visitorParent?.let(::transform) as GenericElementRef? + el.parentInVisitor = (ec.visitorParent?.let(::transform) as GenericElementRef?)?.element el.transformerReturnType = (ec.transformerReturnType?.let(::transform) as GenericElementRef?)?.element for (field in el.fields) { @@ -154,7 +154,7 @@ private fun markLeaves(elements: List) { for (el in leaves) { el.isLeaf = true - if (el.visitorParent != null) { + if (el.parentInVisitor != null) { el.hasAcceptMethod = true } } diff --git a/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/print/Elements.kt b/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/print/Elements.kt index dab957acc9e..4cfff120f6a 100644 --- a/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/print/Elements.kt +++ b/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/print/Elements.kt @@ -97,7 +97,7 @@ fun printElements(generationPath: File, model: Model) = sequence { .also(::addParameter) returns(r) if (!isRootElement) { - addStatement("return %N.%N(this, %N)", visitorParam, element.visitFunName, dataParam) + addStatement("return %N.%N(this, %N)", visitorParam, element.visitFunctionName, dataParam) } if (isRootElement) { addKdoc( diff --git a/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/print/VisitorsAndTransformers.kt b/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/print/VisitorsAndTransformers.kt index e8a21a36727..4cf89b5776a 100644 --- a/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/print/VisitorsAndTransformers.kt +++ b/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/print/VisitorsAndTransformers.kt @@ -5,139 +5,144 @@ package org.jetbrains.kotlin.ir.generator.print -import com.squareup.kotlinpoet.* -import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy -import org.jetbrains.kotlin.generators.tree.printer.GeneratedFile -import org.jetbrains.kotlin.ir.generator.IrTree -import org.jetbrains.kotlin.ir.generator.VISITOR_PACKAGE -import org.jetbrains.kotlin.ir.generator.irTypeType +import org.jetbrains.kotlin.generators.tree.* +import org.jetbrains.kotlin.generators.tree.printer.* +import org.jetbrains.kotlin.ir.generator.* import org.jetbrains.kotlin.ir.generator.model.* +import org.jetbrains.kotlin.types.Variance import org.jetbrains.kotlin.util.capitalizeDecapitalize.capitalizeAsciiOnly +import org.jetbrains.kotlin.utils.SmartPrinter +import org.jetbrains.kotlin.utils.withIndent import java.io.File -private val visitorTypeName = ClassName(VISITOR_PACKAGE, "IrElementVisitor") -private val visitorVoidTypeName = ClassName(VISITOR_PACKAGE, "IrElementVisitorVoid") -private val transformerTypeName = ClassName(VISITOR_PACKAGE, "IrElementTransformer") -private val typeTransformerTypeName = ClassName(VISITOR_PACKAGE, "IrTypeTransformer") +private fun printVisitorCommon( + generationPath: File, + model: Model, + visitorType: ClassRef<*>, + makePrinter: (SmartPrinter, ClassRef<*>) -> AbstractVisitorPrinter, +): GeneratedFile = + printGeneratedType(generationPath, TREE_GENERATOR_README, visitorType.packageName, visitorType.simpleName) { + println() + makePrinter(this, visitorType).printVisitor(model.elements) + } -fun printVisitor(generationPath: File, model: Model): GeneratedFile { - val visitorType = TypeSpec.interfaceBuilder(visitorTypeName).apply { - val r = TypeVariableName("R", KModifier.OUT) - val d = TypeVariableName("D", KModifier.IN) - addTypeVariable(r) - addTypeVariable(d) +private open class VisitorPrinter(printer: SmartPrinter, override val visitorType: ClassRef<*>) : + AbstractVisitorPrinter(printer, visitSuperTypeByDefault = false) { - fun buildVisitFun(element: Element) = FunSpec.builder(element.visitFunName).apply { - addParameter(element.visitorParam, element.toPoetStarParameterized()) - addParameter("data", d) - returns(r) - } + override val visitorTypeParameters: List + get() = listOf(resultTypeVariable, dataTypeVariable) - addFunction(buildVisitFun(model.rootElement).addModifiers(KModifier.ABSTRACT).build()) + override val visitorDataType: TypeRef + get() = dataTypeVariable - for (element in model.elements) { - element.visitorParent?.let { parent -> - addFunction(buildVisitFun(element).apply { - addStatement("return ${parent.element.visitFunName}(${element.visitorParam}, data)") - }.build()) - } - } - }.build() + override fun visitMethodReturnType(element: Element) = resultTypeVariable - return printTypeCommon(generationPath, visitorTypeName.packageName, visitorType) + override val visitorSuperType: ClassRef? + get() = null + + override val allowTypeParametersInVisitorMethods: Boolean + get() = false } -fun printVisitorVoid(generationPath: File, model: Model): GeneratedFile { - val dataType = NOTHING.copy(nullable = true) +fun printVisitor(generationPath: File, model: Model) = printVisitorCommon(generationPath, model, elementVisitorType, ::VisitorPrinter) - val visitorType = TypeSpec.interfaceBuilder(visitorVoidTypeName).apply { - addSuperinterface(visitorTypeName.parameterizedBy(UNIT, dataType)) +private class VisitorVoidPrinter( + printer: SmartPrinter, + override val visitorType: ClassRef<*>, +) : AbstractVisitorVoidPrinter(printer, visitSuperTypeByDefault = false) { - fun buildVisitFun(element: Element) = FunSpec.builder(element.visitFunName).apply { - addModifiers(KModifier.OVERRIDE) - addParameter(element.visitorParam, element.toPoetStarParameterized()) - addParameter("data", dataType) - addStatement("return ${element.visitFunName}(${element.visitorParam})") - } + override val visitorSuperClass: ClassRef + get() = elementVisitorType - fun buildVisitVoidFun(element: Element) = FunSpec.builder(element.visitFunName).apply { - addParameter(element.visitorParam, element.toPoetStarParameterized()) - } + override val allowTypeParametersInVisitorMethods: Boolean + get() = false - addFunction(buildVisitFun(model.rootElement).build()) - addFunction(buildVisitVoidFun(model.rootElement).build()) + override val useAbstractMethodForRootElement: Boolean + get() = false - for (element in model.elements) { - element.visitorParent?.let { parent -> - addFunction(buildVisitFun(element).build()) - addFunction(buildVisitVoidFun(element).apply { - addStatement("return ${parent.element.visitFunName}(${element.visitorParam})") - }.build()) - } - } - }.build() - - return printTypeCommon(generationPath, visitorVoidTypeName.packageName, visitorType) + override val overriddenVisitMethodsAreFinal: Boolean + get() = false } -fun printTransformer(generationPath: File, model: Model): GeneratedFile { - val visitorType = TypeSpec.interfaceBuilder(transformerTypeName).apply { - val d = TypeVariableName("D", KModifier.IN) - addTypeVariable(d) +fun printVisitorVoid(generationPath: File, model: Model) = + printVisitorCommon(generationPath, model, elementVisitorVoidType, ::VisitorVoidPrinter) - addSuperinterface(visitorTypeName.parameterizedBy(model.rootElement.toPoetStarParameterized(), d)) +private class TransformerPrinter( + printer: SmartPrinter, + override val visitorType: ClassRef<*>, + val rootElement: Element, +) : AbstractVisitorPrinter(printer, visitSuperTypeByDefault = false) { - fun buildVisitFun(element: Element) = FunSpec.builder(element.visitFunName).apply { - addModifiers(KModifier.OVERRIDE) - addParameter(element.visitorParam, element.toPoetStarParameterized()) - addParameter("data", d) - } + override val visitorSuperType: ClassRef + get() = elementVisitorType.withArgs(rootElement, dataTypeVariable) - for (element in model.elements) { - val returnType = element.getTransformExplicitType() - if (element.transformByChildren) { - addFunction(buildVisitFun(element).apply { - addStatement("${element.visitorParam}.transformChildren(this, data)") - addStatement("return ${element.visitorParam}") - returns(returnType.toPoetStarParameterized()) - }.build()) - } else { - element.visitorParent?.let { parent -> - addFunction(buildVisitFun(element).apply { - addStatement("return ${parent.element.visitFunName}(${element.visitorParam}, data)") - returns(returnType.toPoetStarParameterized()) - }.build()) - } - } - } - }.build() + override val visitorTypeParameters: List + get() = listOf(dataTypeVariable) - return printTypeCommon(generationPath, transformerTypeName.packageName, visitorType) -} + override val visitorDataType: TypeRef + get() = dataTypeVariable -fun printTypeVisitor(generationPath: File, model: Model): GeneratedFile { - val transformTypeFunName = "transformType" + override fun visitMethodReturnType(element: Element) = element.getTransformExplicitType() - fun FunSpec.Builder.addVisitTypeStatement(element: Element, field: Field) { - val visitorParam = element.visitorParam - val access = "$visitorParam.${field.name}" - when (field) { - is SingleField -> addStatement("$access = $transformTypeFunName($visitorParam, $access, data)") - is ListField -> { - if (field.isMutable) { - addStatement("$access = $access.map { $transformTypeFunName($visitorParam, it, data) }") + override val allowTypeParametersInVisitorMethods: Boolean + get() = false + + context(ImportCollector) + override fun printMethodsForElement(element: Element) { + printer.run { + val parent = element.parentInVisitor + if (element.transformByChildren || parent != null) { + println() + printVisitMethodDeclaration( + element = element, + override = true, + ) + if (element.transformByChildren) { + println(" {") + withIndent { + println(element.visitorParameterName, ".transformChildren(this, data)") + println("return ", element.visitorParameterName) + } + println("}") } else { - beginControlFlow("for (i in 0 until $access.size)") - addStatement("$access[i] = $transformTypeFunName($visitorParam, $access[i], data)") - endControlFlow() + println(" =") + withIndent { + println(parent!!.visitFunctionName, "(", element.visitorParameterName, ", data)") + } } } } } +} - fun Element.getFieldsWithIrTypeType(insideParent: Boolean = false): List { +fun printTransformer(generationPath: File, model: Model): GeneratedFile = + printVisitorCommon(generationPath, model, elementTransformerType) { printer, visitorType -> + TransformerPrinter(printer, visitorType, model.rootElement) + } + +private class TypeTransformerPrinter( + printer: SmartPrinter, + override val visitorType: ClassRef<*>, + val rootElement: Element, +) : AbstractVisitorPrinter(printer, visitSuperTypeByDefault = false) { + + override val visitorSuperType: ClassRef + get() = elementTransformerType.withArgs(dataTypeVariable) + + override val visitorTypeParameters: List + get() = listOf(dataTypeVariable) + + override val visitorDataType: TypeRef + get() = dataTypeVariable + + override fun visitMethodReturnType(element: Element) = element.getTransformExplicitType() + + override val allowTypeParametersInVisitorMethods: Boolean + get() = false + + private fun Element.getFieldsWithIrTypeType(insideParent: Boolean = false): List { val parentsFields = elementParents.flatMap { it.element.getFieldsWithIrTypeType(insideParent = true) } - if (insideParent && this.visitorParent != null) { + if (insideParent && this.parentInVisitor != null) { return parentsFields } @@ -153,71 +158,110 @@ fun printTypeVisitor(generationPath: File, model: Model): GeneratedFile { return irTypeFields + parentsFields } - val visitorType = TypeSpec.interfaceBuilder(typeTransformerTypeName).apply { - val d = TypeVariableName("D", KModifier.IN) - addTypeVariable(d) - addSuperinterface(transformerTypeName.parameterizedBy(d)) + context(ImportCollector) + override fun SmartPrinter.printAdditionalMethods() { + val typeTP = TypeVariable("Type", listOf(irTypeType.copy(nullable = true)), Variance.INVARIANT) + printFunctionDeclaration( + name = "transformType", + parameters = listOf( + FunctionParameter("container", rootElement), + FunctionParameter("type", typeTP), + FunctionParameter("data", visitorDataType) + ), + returnType = typeTP, + typeParameters = listOf(typeTP), + ) + println() + } - val abstractVisitFun = FunSpec.builder(transformTypeFunName).apply { - val poetNullableIrType = irTypeType.toPoet().copy(nullable = true) - val typeVariable = TypeVariableName("Type", poetNullableIrType) - addTypeVariable(typeVariable) - addParameter("container", model.rootElement.toPoet()) - addParameter("type", typeVariable) - addParameter("data", d) - returns(typeVariable) - } - addFunction(abstractVisitFun.addModifiers(KModifier.ABSTRACT).build()) + context(ImportCollector) + override fun printMethodsForElement(element: Element) { + val irTypeFields = element.getFieldsWithIrTypeType() + if (irTypeFields.isEmpty()) return + if (element.parentInVisitor == null) return + printer.run { + println() + val visitorParam = element.visitorParameterName + printVisitMethodDeclaration( + element = element, + override = true, + ) - fun buildVisitFun(element: Element) = FunSpec.builder(element.visitFunName).apply { - addModifiers(KModifier.OVERRIDE) - addParameter(element.visitorParam, element.toPoetStarParameterized()) - addParameter("data", d) - } + fun addVisitTypeStatement(field: Field) { + val access = "$visitorParam.${field.name}" + when (field) { + is SingleField -> println(access, " = ", "transformType(", visitorParam, ", ", access, ", data)") + is ListField -> { + if (field.isMutable) { + println(access, " = ", access, ".map { transformType(", visitorParam, ", it, data) }") + } else { + println("for (i in 0 until ", access, ".size) {") + withIndent { + println(access, "[i] = transformType(", visitorParam, ", ", access, "[i], data)") + } + println("}") + } + } + } + } - for (element in model.elements) { - val irTypeFields = element.getFieldsWithIrTypeType() - if (irTypeFields.isEmpty()) continue - - val returnType = element.getTransformExplicitType() - element.visitorParent?.let { _ -> - addFunction(buildVisitFun(element).apply { - returns(returnType.toPoetStarParameterized()) - - val visitorParam = element.visitorParam - when (element.name) { - IrTree.memberAccessExpression.name -> { - if (irTypeFields.singleOrNull()?.name != "typeArguments") { - error( - """`Ir${IrTree.memberAccessExpression.name.capitalizeAsciiOnly()}` has unexpected fields with `IrType` type. - |Please adjust logic of `${typeTransformerTypeName.simpleName}`'s generation.""".trimMargin() + println(" {") + withIndent { + when (element.name) { + IrTree.memberAccessExpression.name -> { + if (irTypeFields.singleOrNull()?.name != "typeArguments") { + error( + """`Ir${IrTree.memberAccessExpression.name.capitalizeAsciiOnly()}` has unexpected fields with `IrType` type. + |Please adjust logic of `${visitorType.simpleName}`'s generation.""".trimMargin() + ) + } + println("(0 until ", visitorParam, ".typeArgumentsCount).forEach {") + withIndent { + println(visitorParam, ".getTypeArgument(it)?.let { type ->") + withIndent { + println( + visitorParam, + ".putTypeArgument(it, transformType(", + visitorParam, + ", type, data))" ) } - beginControlFlow("(0 until $visitorParam.typeArgumentsCount).forEach {") - beginControlFlow("$visitorParam.getTypeArgument(it)?.let { type ->") - addStatement("expression.putTypeArgument(it, $transformTypeFunName($visitorParam, type, data))") - endControlFlow() - endControlFlow() + println("}") } - IrTree.`class`.name -> { - beginControlFlow("$visitorParam.valueClassRepresentation?.mapUnderlyingType {") - addStatement("$transformTypeFunName($visitorParam, it, data)") - endControlFlow() - irTypeFields.forEach { addVisitTypeStatement(element, it) } - } - else -> irTypeFields.forEach { addVisitTypeStatement(element, it) } + println("}") } - addStatement("return super.${element.visitFunName}($visitorParam, data)") - }.build()) + IrTree.`class`.name -> { + println(visitorParam, ".valueClassRepresentation?.mapUnderlyingType {") + withIndent { + println("transformType(", visitorParam, ", it, data)") + } + println("}") + irTypeFields.forEach(::addVisitTypeStatement) + } + else -> { + irTypeFields.forEach(::addVisitTypeStatement) + } + } + println( + "return super.", + element.visitFunctionName, + "(", + visitorParam, + ", data)" + ) } + println("}") } - }.build() - - return printTypeCommon(generationPath, typeTransformerTypeName.packageName, visitorType) + } } +fun printTypeVisitor(generationPath: File, model: Model): GeneratedFile = + printVisitorCommon(generationPath, model, typeTransformerType) { printer, visitorType -> + TypeTransformerPrinter(printer, visitorType, model.rootElement) + } + private fun Element.getTransformExplicitType(): Element { - return generateSequence(this) { it.visitorParent?.element } + return generateSequence(this) { it.parentInVisitor?.element } .firstNotNullOfOrNull { when { it.transformByChildren -> it.transformerReturnType ?: it diff --git a/core/util.runtime/src/org/jetbrains/kotlin/utils/addToStdlib.kt b/core/util.runtime/src/org/jetbrains/kotlin/utils/addToStdlib.kt index aed5b835743..7b54f7be493 100644 --- a/core/util.runtime/src/org/jetbrains/kotlin/utils/addToStdlib.kt +++ b/core/util.runtime/src/org/jetbrains/kotlin/utils/addToStdlib.kt @@ -349,3 +349,33 @@ fun Iterable.zipWithNulls(other: Iterable): List> { fun unreachableBranch(argument: Any?): Nothing { error("This argument should've been processed by previous when branches but it wasn't: $argument") } + +/** + * Calls [appendElement] on [buffer] for all the elements, also appending [separator] between them and using the given [prefix] + * and [postfix] if supplied. + * + * If the collection could be huge, you can specify a non-negative value of [limit], in which case only the first [limit] + * elements will be appended, followed by the [truncated] string (which defaults to "..."). + */ +fun Iterable.joinToWithBuffer( + buffer: A, + separator: CharSequence = ", ", + prefix: CharSequence = "", + postfix: CharSequence = "", + limit: Int = -1, + truncated: CharSequence = "...", + appendElement: A.(T) -> Unit, +): A { + buffer.append(prefix) + var count = 0 + for (element in this) { + if (++count > 1) buffer.append(separator) + if (limit < 0 || count <= limit) { + buffer.appendElement(element) + } else break + } + if (limit in 0.. : ElementOrRef, F open val isSealed: Boolean get() = false + /** + * The name of the method in visitors used to visit this element. + */ + abstract val visitFunctionName: String + + /** + * The name of the parameter representing this element in the visitor method used to visit this element. + */ + abstract val visitorParameterName: String + + /** + * The default element to visit if the method for visiting this element is not overridden. + */ + abstract val parentInVisitor: Element? + override val allParents: List get() = elementParents.map { it.element } diff --git a/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/AbstractVisitorPrinter.kt b/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/AbstractVisitorPrinter.kt new file mode 100644 index 00000000000..ed7d171f2c5 --- /dev/null +++ b/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/AbstractVisitorPrinter.kt @@ -0,0 +1,159 @@ +/* + * Copyright 2010-2023 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.generators.tree + +import org.jetbrains.kotlin.descriptors.Modality +import org.jetbrains.kotlin.generators.tree.printer.FunctionParameter +import org.jetbrains.kotlin.generators.tree.printer.multipleUpperBoundsList +import org.jetbrains.kotlin.generators.tree.printer.printFunctionDeclaration +import org.jetbrains.kotlin.generators.tree.printer.typeParameters +import org.jetbrains.kotlin.types.Variance +import org.jetbrains.kotlin.utils.SmartPrinter +import org.jetbrains.kotlin.utils.withIndent + +abstract class AbstractVisitorPrinter, Field : AbstractField>( + val printer: SmartPrinter, + val visitSuperTypeByDefault: Boolean, +) { + + /** + * The visitor type to print. + */ + abstract val visitorType: ClassRef<*> + + /** + * The result type parameter of the visitor. All visitor methods return result of this type. + */ + protected val resultTypeVariable = TypeVariable("R", emptyList(), Variance.OUT_VARIANCE) + + /** + * The data type parameter of the visitor. ALl visitor methods accept a parameter of this type. + */ + protected val dataTypeVariable = TypeVariable("D", emptyList(), Variance.IN_VARIANCE) + + /** + * The type parameters of the visitor class. Void visitors have no type parameters, + * regular visitors usually have [resultTypeVariable] and [dataTypeVariable] here. + */ + abstract val visitorTypeParameters: List + + abstract val visitorDataType: TypeRef + + abstract fun visitMethodReturnType(element: Element): TypeRef + + /** + * The superclass for this visitor class. + */ + abstract val visitorSuperType: ClassRef? + + /** + * If `true`, visitor methods for generic tree elements will be parameterized correspondingly. + * Otherwise, type arguments of generic tree elements will be replaced with `*`. + */ + abstract val allowTypeParametersInVisitorMethods: Boolean + + /** + * Allows to customize the default element to visit if the method for visiting this [element] is not overridden. + * + * If returns `null`, methods for this element will not be overridden in this visitor class (except the root element). + */ + open fun parentInVisitor(element: Element): Element? = element.parentInVisitor + + /** + * Prints a single visitor method declaration, without body. + */ + context(ImportCollector) + protected fun SmartPrinter.printVisitMethodDeclaration( + element: Element, + hasDataParameter: Boolean = true, + modality: Modality? = null, + override: Boolean = false, + ) { + val visitorParameterType = ElementRef( + element, + element.params.associateWith { if (allowTypeParametersInVisitorMethods) it else TypeRef.Star } + ) + val parameters = buildList { + add(FunctionParameter(element.visitorParameterName, visitorParameterType)) + if (hasDataParameter) add(FunctionParameter("data", visitorDataType)) + } + printFunctionDeclaration( + name = element.visitFunctionName, + parameters = parameters, + returnType = visitMethodReturnType(element), + typeParameters = if (allowTypeParametersInVisitorMethods) { + element.params + } else { + emptyList() + }, + modality = modality, + override = override, + ) + } + + context(ImportCollector) + protected fun printMethodDeclarationForElement(element: Element, modality: Modality? = null, override: Boolean) { + printer.run { + println() + printVisitMethodDeclaration( + element, + modality = modality, + override = override + ) + } + } + + context(ImportCollector) + protected open fun printMethodsForElement(element: Element) { + printer.run { + val parentInVisitor = parentInVisitor(element) + if (parentInVisitor == null && !element.isRootElement) return + printMethodDeclarationForElement( + element, + modality = when { + visitorSuperType == null && parentInVisitor == null && visitorType.kind == TypeKind.Class -> Modality.ABSTRACT + visitorSuperType == null && parentInVisitor != null && visitorType.kind == TypeKind.Class -> Modality.OPEN + else -> null + }, + override = parentInVisitor != null && visitorSuperType != null, + ) + if (parentInVisitor != null) { + print(" = ", parentInVisitor.visitFunctionName, "(", element.visitorParameterName, ", data)") + } + println() + } + } + + context(ImportCollector) + protected open fun SmartPrinter.printAdditionalMethods() { + } + + context(ImportCollector) + fun printVisitor(elements: List) { + val visitorType = this.visitorType + printer.run { + when (visitorType.kind) { + TypeKind.Interface -> print("interface ") + TypeKind.Class -> print("abstract class ") + } + print(visitorType.simpleName, visitorTypeParameters.typeParameters()) + visitorSuperType?.let { + print(" : ", it.render(), it.inheritanceClauseParenthesis()) + } + print(visitorTypeParameters.multipleUpperBoundsList()) + println(" {") + withIndent { + printAdditionalMethods() + for (element in elements) { + if (element.isRootElement && visitSuperTypeByDefault) continue + if (visitSuperTypeByDefault && parentInVisitor(element) == null) continue + printMethodsForElement(element) + } + } + println("}") + } + } +} \ No newline at end of file diff --git a/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/AbstractVisitorVoidPrinter.kt b/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/AbstractVisitorVoidPrinter.kt new file mode 100644 index 00000000000..09672ff4171 --- /dev/null +++ b/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/AbstractVisitorVoidPrinter.kt @@ -0,0 +1,81 @@ +/* + * Copyright 2010-2023 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.generators.tree + +import org.jetbrains.kotlin.descriptors.Modality +import org.jetbrains.kotlin.utils.SmartPrinter +import org.jetbrains.kotlin.utils.withIndent + +abstract class AbstractVisitorVoidPrinter( + printer: SmartPrinter, + visitSuperTypeByDefault: Boolean, +) : AbstractVisitorPrinter(printer, visitSuperTypeByDefault) + where Element : AbstractElement, + Field : AbstractField { + + final override val visitorTypeParameters: List + get() = emptyList() + + final override val visitorDataType: TypeRef + get() = StandardTypes.nothing.copy(nullable = true) + + override fun visitMethodReturnType(element: Element) = StandardTypes.unit + + abstract val visitorSuperClass: ClassRef + + override val visitorSuperType: ClassRef + get() = if (visitSuperTypeByDefault) + visitorSuperClass + else + visitorSuperClass.withArgs(StandardTypes.unit, visitorDataType) + + abstract val useAbstractMethodForRootElement: Boolean + + abstract val overriddenVisitMethodsAreFinal: Boolean + + context(ImportCollector) + final override fun printMethodsForElement(element: Element) { + val parentInVisitor = parentInVisitor(element) + if (!element.isRootElement && parentInVisitor == null) return + + val isAbstractVisitRootElementMethod = element.isRootElement && useAbstractMethodForRootElement + + printMethodDeclarationForElement( + element, + modality = Modality.FINAL.takeIf { overriddenVisitMethodsAreFinal }, + override = true, + ) + + fun SmartPrinter.printBody(parentInVisitor: Element?) { + println(" {") + if (parentInVisitor != null) { + withIndent { + println(parentInVisitor.visitFunctionName, "(", element.visitorParameterName, ")") + } + } + println("}") + } + + printer.run { + printBody(element) + println() + printVisitMethodDeclaration( + element, + hasDataParameter = false, + modality = when { + element.isRootElement && visitorType.kind == TypeKind.Class -> Modality.ABSTRACT + !element.isRootElement && visitorType.kind == TypeKind.Class -> Modality.OPEN + else -> null + } + ) + if (isAbstractVisitRootElementMethod) { + println() + } else { + printBody(parentInVisitor) + } + } + } +} \ No newline at end of file diff --git a/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/StandardTypes.kt b/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/StandardTypes.kt index 870a6ef7dcb..7a3ba47ac08 100644 --- a/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/StandardTypes.kt +++ b/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/StandardTypes.kt @@ -6,6 +6,8 @@ package org.jetbrains.kotlin.generators.tree object StandardTypes { + val unit = type() + val nothing = type("kotlin", "Nothing") val boolean = type() val string = type() val int = type() diff --git a/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/printer/printUtils.kt b/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/printer/printUtils.kt index 16579d157fb..82f5ad02ceb 100644 --- a/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/printer/printUtils.kt +++ b/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/printer/printUtils.kt @@ -5,14 +5,17 @@ package org.jetbrains.kotlin.generators.tree.printer -import org.jetbrains.kotlin.generators.tree.AbstractElement -import org.jetbrains.kotlin.generators.tree.ImplementationKind +import org.jetbrains.kotlin.descriptors.Modality +import org.jetbrains.kotlin.generators.tree.* +import org.jetbrains.kotlin.utils.SmartPrinter import org.jetbrains.kotlin.generators.tree.ImportCollector import org.jetbrains.kotlin.generators.tree.render -import org.jetbrains.kotlin.utils.SmartPrinter +import org.jetbrains.kotlin.types.Variance +import org.jetbrains.kotlin.utils.addToStdlib.joinToWithBuffer +import org.jetbrains.kotlin.utils.withIndent /** - * The angle bracket-delimited list of type parameters to print, or empty string if the element has no type parameters. + * The angle bracket-delimited list of type parameters to print, or empty string if the list is empty. * * For type parameters that have a single upper bound, also prints that upper bound. If at least one type parameter has multiple upper * bounds, doesn't print any upper bounds at all. They are expected to be printed in the `where` clause (see [multipleUpperBoundsList]). @@ -20,10 +23,21 @@ import org.jetbrains.kotlin.utils.SmartPrinter * @param end The string to add after the closing angle bracket of the type parameter list */ context(ImportCollector) -fun AbstractElement<*, *>.typeParameters(end: String = ""): String = params.takeIf { it.isNotEmpty() } - ?.joinToString(", ", "<", ">$end") { param -> - param.name + (param.bounds.singleOrNull()?.let { " : ${it.render()}" } ?: "") - } ?: "" +fun List.typeParameters(end: String = ""): String = buildString { + if (this@typeParameters.isEmpty()) return@buildString + joinToWithBuffer(this, prefix = "<", postfix = ">") { param -> + if (param.variance != Variance.INVARIANT) { + append(param.variance.label) + append(" ") + } + append(param.name) + param.bounds.singleOrNull()?.let { + append(" : ") + it.renderTo(this) + } + } + append(end) +} /** * The `where` clause to print after the class or function declaration if at least one of the element's tye parameters has multiple upper @@ -32,14 +46,17 @@ fun AbstractElement<*, *>.typeParameters(end: String = ""): String = params.take * Otherwise, an empty string. */ context(ImportCollector) -fun AbstractElement<*, *>.multipleUpperBoundsList(): String { - val paramsWithMultipleUpperBounds = params.filter { it.bounds.size > 1 }.takeIf { it.isNotEmpty() } ?: return "" +fun List.multipleUpperBoundsList(): String { + val paramsWithMultipleUpperBounds = filter { it.bounds.size > 1 }.takeIf { it.isNotEmpty() } ?: return "" return buildString { append(" where ") - paramsWithMultipleUpperBounds.joinTo(this, separator = ", ") { param -> - param.bounds.joinToString(", ") { bound -> "$param : ${bound.render()}" } + paramsWithMultipleUpperBounds.joinToWithBuffer(this, separator = ", ") { param -> + param.bounds.joinToWithBuffer(this) { bound -> + append(param.name) + append(" : ") + bound.renderTo(this) + } } - append("") } } @@ -75,3 +92,58 @@ fun AbstractElement<*, *>.extendedKDoc(defaultKDoc: String? = null): String = bu } append("Generated from: [${element.propertyName}]") } + +data class FunctionParameter(val name: String, val type: TypeRef, val defaultValue: String? = null) { + + context(ImportCollector) + fun render(): String = buildString { + append(name, ": ", type.render()) + defaultValue?.let { + append(" = ", it) + } + } +} + +context(ImportCollector) +fun SmartPrinter.printFunctionDeclaration( + name: String, + parameters: List, + returnType: TypeRef, + typeParameters: List = emptyList(), + modality: Modality? = null, + override: Boolean = false, + allParametersOnSeparateLines: Boolean = false, +) { + when (modality) { + null -> {} + Modality.FINAL -> print("final ") + Modality.OPEN -> print("open ") + Modality.ABSTRACT -> print("abstract ") + Modality.SEALED -> error("Function cannot be sealed") + } + if (override) { + print("override ") + } + print("fun ") + print(typeParameters.typeParameters(end = " ")) + print(name, "(") + + if (allParametersOnSeparateLines) { + if (parameters.isNotEmpty()) { + println() + withIndent { + for (parameter in parameters) { + print(parameter.render()) + println(",") + } + } + } + } else { + print(parameters.joinToString { it.render() }) + } + print(")") + if (returnType != StandardTypes.unit) { + print(": ", returnType.render()) + } + print(typeParameters.multipleUpperBoundsList()) +} \ No newline at end of file