Please wait. This can take some minutes ...
Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
org.jetbrains.kotlin.fir.visitors.FirTransformer.kt Maven / Gradle / Ivy
/*
* Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
* Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
*/
package org.jetbrains.kotlin.fir.visitors
import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirAnnotationContainer
import org.jetbrains.kotlin.fir.types.FirTypeRef
import org.jetbrains.kotlin.fir.references.FirReference
import org.jetbrains.kotlin.fir.FirLabel
import org.jetbrains.kotlin.fir.declarations.FirImport
import org.jetbrains.kotlin.fir.declarations.FirResolvedImport
import org.jetbrains.kotlin.fir.FirSymbolOwner
import org.jetbrains.kotlin.fir.expressions.FirResolvable
import org.jetbrains.kotlin.fir.FirTargetElement
import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus
import org.jetbrains.kotlin.fir.declarations.FirResolvedDeclarationStatus
import org.jetbrains.kotlin.fir.declarations.FirControlFlowGraphOwner
import org.jetbrains.kotlin.fir.expressions.FirStatement
import org.jetbrains.kotlin.fir.expressions.FirExpression
import org.jetbrains.kotlin.fir.declarations.FirDeclaration
import org.jetbrains.kotlin.fir.declarations.FirAnnotatedDeclaration
import org.jetbrains.kotlin.fir.declarations.FirAnonymousInitializer
import org.jetbrains.kotlin.fir.declarations.FirTypedDeclaration
import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRef
import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRefsOwner
import org.jetbrains.kotlin.fir.declarations.FirTypeParametersOwner
import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
import org.jetbrains.kotlin.fir.declarations.FirCallableMemberDeclaration
import org.jetbrains.kotlin.fir.declarations.FirVariable
import org.jetbrains.kotlin.fir.declarations.FirValueParameter
import org.jetbrains.kotlin.fir.declarations.FirProperty
import org.jetbrains.kotlin.fir.declarations.FirField
import org.jetbrains.kotlin.fir.declarations.FirEnumEntry
import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration
import org.jetbrains.kotlin.fir.declarations.FirClass
import org.jetbrains.kotlin.fir.declarations.FirRegularClass
import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
import org.jetbrains.kotlin.fir.declarations.FirFunction
import org.jetbrains.kotlin.fir.declarations.FirContractDescriptionOwner
import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
import org.jetbrains.kotlin.fir.declarations.FirPropertyAccessor
import org.jetbrains.kotlin.fir.declarations.FirConstructor
import org.jetbrains.kotlin.fir.declarations.FirFile
import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction
import org.jetbrains.kotlin.fir.declarations.FirAnonymousObject
import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder
import org.jetbrains.kotlin.fir.expressions.FirLoop
import org.jetbrains.kotlin.fir.expressions.FirErrorLoop
import org.jetbrains.kotlin.fir.expressions.FirDoWhileLoop
import org.jetbrains.kotlin.fir.expressions.FirWhileLoop
import org.jetbrains.kotlin.fir.expressions.FirBlock
import org.jetbrains.kotlin.fir.expressions.FirBinaryLogicExpression
import org.jetbrains.kotlin.fir.expressions.FirJump
import org.jetbrains.kotlin.fir.expressions.FirLoopJump
import org.jetbrains.kotlin.fir.expressions.FirBreakExpression
import org.jetbrains.kotlin.fir.expressions.FirContinueExpression
import org.jetbrains.kotlin.fir.expressions.FirCatch
import org.jetbrains.kotlin.fir.expressions.FirTryExpression
import org.jetbrains.kotlin.fir.expressions.FirConstExpression
import org.jetbrains.kotlin.fir.types.FirTypeProjection
import org.jetbrains.kotlin.fir.types.FirStarProjection
import org.jetbrains.kotlin.fir.types.FirTypeProjectionWithVariance
import org.jetbrains.kotlin.fir.expressions.FirArgumentList
import org.jetbrains.kotlin.fir.expressions.FirCall
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
import org.jetbrains.kotlin.fir.expressions.FirComparisonExpression
import org.jetbrains.kotlin.fir.expressions.FirTypeOperatorCall
import org.jetbrains.kotlin.fir.expressions.FirAssignmentOperatorStatement
import org.jetbrains.kotlin.fir.expressions.FirEqualityOperatorCall
import org.jetbrains.kotlin.fir.expressions.FirWhenExpression
import org.jetbrains.kotlin.fir.expressions.FirWhenBranch
import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess
import org.jetbrains.kotlin.fir.expressions.FirCheckNotNullCall
import org.jetbrains.kotlin.fir.expressions.FirElvisExpression
import org.jetbrains.kotlin.fir.expressions.FirArrayOfCall
import org.jetbrains.kotlin.fir.expressions.FirAugmentedArraySetCall
import org.jetbrains.kotlin.fir.expressions.FirClassReferenceExpression
import org.jetbrains.kotlin.fir.expressions.FirErrorExpression
import org.jetbrains.kotlin.fir.declarations.FirErrorFunction
import org.jetbrains.kotlin.fir.declarations.FirErrorProperty
import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall
import org.jetbrains.kotlin.fir.expressions.FirComponentCall
import org.jetbrains.kotlin.fir.expressions.FirCallableReferenceAccess
import org.jetbrains.kotlin.fir.expressions.FirThisReceiverExpression
import org.jetbrains.kotlin.fir.expressions.FirExpressionWithSmartcast
import org.jetbrains.kotlin.fir.expressions.FirSafeCallExpression
import org.jetbrains.kotlin.fir.expressions.FirCheckedSafeCallSubject
import org.jetbrains.kotlin.fir.expressions.FirGetClassCall
import org.jetbrains.kotlin.fir.expressions.FirWrappedExpression
import org.jetbrains.kotlin.fir.expressions.FirWrappedArgumentExpression
import org.jetbrains.kotlin.fir.expressions.FirLambdaArgumentExpression
import org.jetbrains.kotlin.fir.expressions.FirSpreadArgumentExpression
import org.jetbrains.kotlin.fir.expressions.FirNamedArgumentExpression
import org.jetbrains.kotlin.fir.expressions.FirVarargArgumentsExpression
import org.jetbrains.kotlin.fir.expressions.FirResolvedQualifier
import org.jetbrains.kotlin.fir.expressions.FirErrorResolvedQualifier
import org.jetbrains.kotlin.fir.expressions.FirResolvedReifiedParameterReference
import org.jetbrains.kotlin.fir.expressions.FirReturnExpression
import org.jetbrains.kotlin.fir.expressions.FirStringConcatenationCall
import org.jetbrains.kotlin.fir.expressions.FirThrowExpression
import org.jetbrains.kotlin.fir.expressions.FirVariableAssignment
import org.jetbrains.kotlin.fir.expressions.FirWhenSubjectExpression
import org.jetbrains.kotlin.fir.expressions.FirWrappedDelegateExpression
import org.jetbrains.kotlin.fir.references.FirNamedReference
import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
import org.jetbrains.kotlin.fir.references.FirSuperReference
import org.jetbrains.kotlin.fir.references.FirThisReference
import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
import org.jetbrains.kotlin.fir.references.FirDelegateFieldReference
import org.jetbrains.kotlin.fir.references.FirBackingFieldReference
import org.jetbrains.kotlin.fir.references.FirResolvedCallableReference
import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
import org.jetbrains.kotlin.fir.types.FirErrorTypeRef
import org.jetbrains.kotlin.fir.types.FirTypeRefWithNullability
import org.jetbrains.kotlin.fir.types.FirUserTypeRef
import org.jetbrains.kotlin.fir.types.FirDynamicTypeRef
import org.jetbrains.kotlin.fir.types.FirFunctionTypeRef
import org.jetbrains.kotlin.fir.types.FirResolvedFunctionTypeRef
import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
import org.jetbrains.kotlin.fir.types.FirComposedSuperTypeRef
import org.jetbrains.kotlin.fir.contracts.FirEffectDeclaration
import org.jetbrains.kotlin.fir.contracts.FirContractDescription
import org.jetbrains.kotlin.fir.contracts.FirLegacyRawContractDescription
import org.jetbrains.kotlin.fir.contracts.FirRawContractDescription
import org.jetbrains.kotlin.fir.contracts.FirResolvedContractDescription
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
/*
* This file was generated automatically
* DO NOT MODIFY IT MANUALLY
*/
abstract class FirTransformer : FirVisitor, D>() {
abstract fun transformElement(element: E, data: D): CompositeTransformResult
open fun transformAnnotationContainer(annotationContainer: FirAnnotationContainer, data: D): CompositeTransformResult {
return transformElement(annotationContainer, data)
}
open fun transformTypeRef(typeRef: FirTypeRef, data: D): CompositeTransformResult {
return transformElement(typeRef, data)
}
open fun transformReference(reference: FirReference, data: D): CompositeTransformResult {
return transformElement(reference, data)
}
open fun transformLabel(label: FirLabel, data: D): CompositeTransformResult {
return transformElement(label, data)
}
open fun transformImport(import: FirImport, data: D): CompositeTransformResult {
return transformElement(import, data)
}
open fun transformResolvedImport(resolvedImport: FirResolvedImport, data: D): CompositeTransformResult {
return transformElement(resolvedImport, data)
}
open fun transformSymbolOwner(symbolOwner: FirSymbolOwner, data: D): CompositeTransformResult> where E : FirSymbolOwner, E : FirDeclaration {
return transformElement(symbolOwner, data)
}
open fun transformResolvable(resolvable: FirResolvable, data: D): CompositeTransformResult {
return transformElement(resolvable, data)
}
open fun transformTargetElement(targetElement: FirTargetElement, data: D): CompositeTransformResult {
return transformElement(targetElement, data)
}
open fun transformDeclarationStatus(declarationStatus: FirDeclarationStatus, data: D): CompositeTransformResult {
return transformElement(declarationStatus, data)
}
open fun transformResolvedDeclarationStatus(resolvedDeclarationStatus: FirResolvedDeclarationStatus, data: D): CompositeTransformResult {
return transformElement(resolvedDeclarationStatus, data)
}
open fun transformControlFlowGraphOwner(controlFlowGraphOwner: FirControlFlowGraphOwner, data: D): CompositeTransformResult {
return transformElement(controlFlowGraphOwner, data)
}
open fun transformStatement(statement: FirStatement, data: D): CompositeTransformResult {
return transformElement(statement, data)
}
open fun transformExpression(expression: FirExpression, data: D): CompositeTransformResult {
return transformElement(expression, data)
}
open fun transformDeclaration(declaration: FirDeclaration, data: D): CompositeTransformResult {
return transformElement(declaration, data)
}
open fun transformAnnotatedDeclaration(annotatedDeclaration: FirAnnotatedDeclaration, data: D): CompositeTransformResult {
return transformElement(annotatedDeclaration, data)
}
open fun transformAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, data: D): CompositeTransformResult {
return transformElement(anonymousInitializer, data)
}
open fun transformTypedDeclaration(typedDeclaration: FirTypedDeclaration, data: D): CompositeTransformResult {
return transformElement(typedDeclaration, data)
}
open fun > transformCallableDeclaration(callableDeclaration: FirCallableDeclaration, data: D): CompositeTransformResult {
return transformElement(callableDeclaration, data)
}
open fun transformTypeParameterRef(typeParameterRef: FirTypeParameterRef, data: D): CompositeTransformResult {
return transformElement(typeParameterRef, data)
}
open fun transformTypeParameter(typeParameter: FirTypeParameter, data: D): CompositeTransformResult {
return transformElement(typeParameter, data)
}
open fun transformTypeParameterRefsOwner(typeParameterRefsOwner: FirTypeParameterRefsOwner, data: D): CompositeTransformResult {
return transformElement(typeParameterRefsOwner, data)
}
open fun transformTypeParametersOwner(typeParametersOwner: FirTypeParametersOwner, data: D): CompositeTransformResult {
return transformElement(typeParametersOwner, data)
}
open fun transformMemberDeclaration(memberDeclaration: FirMemberDeclaration, data: D): CompositeTransformResult {
return transformElement(memberDeclaration, data)
}
open fun > transformCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration, data: D): CompositeTransformResult {
return transformElement(callableMemberDeclaration, data)
}
open fun > transformVariable(variable: FirVariable, data: D): CompositeTransformResult {
return transformElement(variable, data)
}
open fun transformValueParameter(valueParameter: FirValueParameter, data: D): CompositeTransformResult {
return transformElement(valueParameter, data)
}
open fun transformProperty(property: FirProperty, data: D): CompositeTransformResult {
return transformElement(property, data)
}
open fun transformField(field: FirField, data: D): CompositeTransformResult {
return transformElement(field, data)
}
open fun transformEnumEntry(enumEntry: FirEnumEntry, data: D): CompositeTransformResult {
return transformElement(enumEntry, data)
}
open fun > transformClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, data: D): CompositeTransformResult {
return transformElement(classLikeDeclaration, data)
}
open fun > transformClass(klass: FirClass, data: D): CompositeTransformResult {
return transformElement(klass, data)
}
open fun transformRegularClass(regularClass: FirRegularClass, data: D): CompositeTransformResult {
return transformElement(regularClass, data)
}
open fun transformTypeAlias(typeAlias: FirTypeAlias, data: D): CompositeTransformResult {
return transformElement(typeAlias, data)
}
open fun > transformFunction(function: FirFunction, data: D): CompositeTransformResult {
return transformElement(function, data)
}
open fun transformContractDescriptionOwner(contractDescriptionOwner: FirContractDescriptionOwner, data: D): CompositeTransformResult {
return transformElement(contractDescriptionOwner, data)
}
open fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: D): CompositeTransformResult {
return transformElement(simpleFunction, data)
}
open fun transformPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: D): CompositeTransformResult {
return transformElement(propertyAccessor, data)
}
open fun transformConstructor(constructor: FirConstructor, data: D): CompositeTransformResult {
return transformElement(constructor, data)
}
open fun transformFile(file: FirFile, data: D): CompositeTransformResult {
return transformElement(file, data)
}
open fun transformAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: D): CompositeTransformResult {
return transformElement(anonymousFunction, data)
}
open fun transformAnonymousObject(anonymousObject: FirAnonymousObject, data: D): CompositeTransformResult {
return transformElement(anonymousObject, data)
}
open fun transformDiagnosticHolder(diagnosticHolder: FirDiagnosticHolder, data: D): CompositeTransformResult {
return transformElement(diagnosticHolder, data)
}
open fun transformLoop(loop: FirLoop, data: D): CompositeTransformResult {
return transformElement(loop, data)
}
open fun transformErrorLoop(errorLoop: FirErrorLoop, data: D): CompositeTransformResult {
return transformElement(errorLoop, data)
}
open fun transformDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: D): CompositeTransformResult {
return transformElement(doWhileLoop, data)
}
open fun transformWhileLoop(whileLoop: FirWhileLoop, data: D): CompositeTransformResult {
return transformElement(whileLoop, data)
}
open fun transformBlock(block: FirBlock, data: D): CompositeTransformResult {
return transformElement(block, data)
}
open fun transformBinaryLogicExpression(binaryLogicExpression: FirBinaryLogicExpression, data: D): CompositeTransformResult {
return transformElement(binaryLogicExpression, data)
}
open fun transformJump(jump: FirJump, data: D): CompositeTransformResult {
return transformElement(jump, data)
}
open fun transformLoopJump(loopJump: FirLoopJump, data: D): CompositeTransformResult {
return transformElement(loopJump, data)
}
open fun transformBreakExpression(breakExpression: FirBreakExpression, data: D): CompositeTransformResult {
return transformElement(breakExpression, data)
}
open fun transformContinueExpression(continueExpression: FirContinueExpression, data: D): CompositeTransformResult {
return transformElement(continueExpression, data)
}
open fun transformCatch(catch: FirCatch, data: D): CompositeTransformResult {
return transformElement(catch, data)
}
open fun transformTryExpression(tryExpression: FirTryExpression, data: D): CompositeTransformResult {
return transformElement(tryExpression, data)
}
open fun transformConstExpression(constExpression: FirConstExpression, data: D): CompositeTransformResult {
return transformElement(constExpression, data)
}
open fun transformTypeProjection(typeProjection: FirTypeProjection, data: D): CompositeTransformResult {
return transformElement(typeProjection, data)
}
open fun transformStarProjection(starProjection: FirStarProjection, data: D): CompositeTransformResult {
return transformElement(starProjection, data)
}
open fun transformTypeProjectionWithVariance(typeProjectionWithVariance: FirTypeProjectionWithVariance, data: D): CompositeTransformResult {
return transformElement(typeProjectionWithVariance, data)
}
open fun transformArgumentList(argumentList: FirArgumentList, data: D): CompositeTransformResult {
return transformElement(argumentList, data)
}
open fun transformCall(call: FirCall, data: D): CompositeTransformResult {
return transformElement(call, data)
}
open fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: D): CompositeTransformResult {
return transformElement(annotationCall, data)
}
open fun transformComparisonExpression(comparisonExpression: FirComparisonExpression, data: D): CompositeTransformResult {
return transformElement(comparisonExpression, data)
}
open fun transformTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: D): CompositeTransformResult {
return transformElement(typeOperatorCall, data)
}
open fun transformAssignmentOperatorStatement(assignmentOperatorStatement: FirAssignmentOperatorStatement, data: D): CompositeTransformResult {
return transformElement(assignmentOperatorStatement, data)
}
open fun transformEqualityOperatorCall(equalityOperatorCall: FirEqualityOperatorCall, data: D): CompositeTransformResult {
return transformElement(equalityOperatorCall, data)
}
open fun transformWhenExpression(whenExpression: FirWhenExpression, data: D): CompositeTransformResult {
return transformElement(whenExpression, data)
}
open fun transformWhenBranch(whenBranch: FirWhenBranch, data: D): CompositeTransformResult {
return transformElement(whenBranch, data)
}
open fun transformQualifiedAccess(qualifiedAccess: FirQualifiedAccess, data: D): CompositeTransformResult {
return transformElement(qualifiedAccess, data)
}
open fun transformCheckNotNullCall(checkNotNullCall: FirCheckNotNullCall, data: D): CompositeTransformResult {
return transformElement(checkNotNullCall, data)
}
open fun transformElvisExpression(elvisExpression: FirElvisExpression, data: D): CompositeTransformResult {
return transformElement(elvisExpression, data)
}
open fun transformArrayOfCall(arrayOfCall: FirArrayOfCall, data: D): CompositeTransformResult {
return transformElement(arrayOfCall, data)
}
open fun transformAugmentedArraySetCall(augmentedArraySetCall: FirAugmentedArraySetCall, data: D): CompositeTransformResult {
return transformElement(augmentedArraySetCall, data)
}
open fun transformClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression, data: D): CompositeTransformResult {
return transformElement(classReferenceExpression, data)
}
open fun transformErrorExpression(errorExpression: FirErrorExpression, data: D): CompositeTransformResult {
return transformElement(errorExpression, data)
}
open fun transformErrorFunction(errorFunction: FirErrorFunction, data: D): CompositeTransformResult {
return transformElement(errorFunction, data)
}
open fun transformErrorProperty(errorProperty: FirErrorProperty, data: D): CompositeTransformResult {
return transformElement(errorProperty, data)
}
open fun transformQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression, data: D): CompositeTransformResult {
return transformElement(qualifiedAccessExpression, data)
}
open fun transformFunctionCall(functionCall: FirFunctionCall, data: D): CompositeTransformResult {
return transformElement(functionCall, data)
}
open fun transformDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall, data: D): CompositeTransformResult {
return transformElement(delegatedConstructorCall, data)
}
open fun transformComponentCall(componentCall: FirComponentCall, data: D): CompositeTransformResult {
return transformElement(componentCall, data)
}
open fun transformCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess, data: D): CompositeTransformResult {
return transformElement(callableReferenceAccess, data)
}
open fun transformThisReceiverExpression(thisReceiverExpression: FirThisReceiverExpression, data: D): CompositeTransformResult {
return transformElement(thisReceiverExpression, data)
}
open fun transformExpressionWithSmartcast(expressionWithSmartcast: FirExpressionWithSmartcast, data: D): CompositeTransformResult {
return transformElement(expressionWithSmartcast, data)
}
open fun transformSafeCallExpression(safeCallExpression: FirSafeCallExpression, data: D): CompositeTransformResult {
return transformElement(safeCallExpression, data)
}
open fun transformCheckedSafeCallSubject(checkedSafeCallSubject: FirCheckedSafeCallSubject, data: D): CompositeTransformResult {
return transformElement(checkedSafeCallSubject, data)
}
open fun transformGetClassCall(getClassCall: FirGetClassCall, data: D): CompositeTransformResult {
return transformElement(getClassCall, data)
}
open fun transformWrappedExpression(wrappedExpression: FirWrappedExpression, data: D): CompositeTransformResult {
return transformElement(wrappedExpression, data)
}
open fun transformWrappedArgumentExpression(wrappedArgumentExpression: FirWrappedArgumentExpression, data: D): CompositeTransformResult {
return transformElement(wrappedArgumentExpression, data)
}
open fun transformLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression, data: D): CompositeTransformResult {
return transformElement(lambdaArgumentExpression, data)
}
open fun transformSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression, data: D): CompositeTransformResult {
return transformElement(spreadArgumentExpression, data)
}
open fun transformNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression, data: D): CompositeTransformResult {
return transformElement(namedArgumentExpression, data)
}
open fun transformVarargArgumentsExpression(varargArgumentsExpression: FirVarargArgumentsExpression, data: D): CompositeTransformResult {
return transformElement(varargArgumentsExpression, data)
}
open fun transformResolvedQualifier(resolvedQualifier: FirResolvedQualifier, data: D): CompositeTransformResult {
return transformElement(resolvedQualifier, data)
}
open fun transformErrorResolvedQualifier(errorResolvedQualifier: FirErrorResolvedQualifier, data: D): CompositeTransformResult {
return transformElement(errorResolvedQualifier, data)
}
open fun transformResolvedReifiedParameterReference(resolvedReifiedParameterReference: FirResolvedReifiedParameterReference, data: D): CompositeTransformResult {
return transformElement(resolvedReifiedParameterReference, data)
}
open fun transformReturnExpression(returnExpression: FirReturnExpression, data: D): CompositeTransformResult {
return transformElement(returnExpression, data)
}
open fun transformStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall, data: D): CompositeTransformResult {
return transformElement(stringConcatenationCall, data)
}
open fun transformThrowExpression(throwExpression: FirThrowExpression, data: D): CompositeTransformResult {
return transformElement(throwExpression, data)
}
open fun transformVariableAssignment(variableAssignment: FirVariableAssignment, data: D): CompositeTransformResult {
return transformElement(variableAssignment, data)
}
open fun transformWhenSubjectExpression(whenSubjectExpression: FirWhenSubjectExpression, data: D): CompositeTransformResult {
return transformElement(whenSubjectExpression, data)
}
open fun transformWrappedDelegateExpression(wrappedDelegateExpression: FirWrappedDelegateExpression, data: D): CompositeTransformResult {
return transformElement(wrappedDelegateExpression, data)
}
open fun transformNamedReference(namedReference: FirNamedReference, data: D): CompositeTransformResult {
return transformElement(namedReference, data)
}
open fun transformErrorNamedReference(errorNamedReference: FirErrorNamedReference, data: D): CompositeTransformResult {
return transformElement(errorNamedReference, data)
}
open fun transformSuperReference(superReference: FirSuperReference, data: D): CompositeTransformResult {
return transformElement(superReference, data)
}
open fun transformThisReference(thisReference: FirThisReference, data: D): CompositeTransformResult {
return transformElement(thisReference, data)
}
open fun transformControlFlowGraphReference(controlFlowGraphReference: FirControlFlowGraphReference, data: D): CompositeTransformResult {
return transformElement(controlFlowGraphReference, data)
}
open fun transformResolvedNamedReference(resolvedNamedReference: FirResolvedNamedReference, data: D): CompositeTransformResult {
return transformElement(resolvedNamedReference, data)
}
open fun transformDelegateFieldReference(delegateFieldReference: FirDelegateFieldReference, data: D): CompositeTransformResult {
return transformElement(delegateFieldReference, data)
}
open fun transformBackingFieldReference(backingFieldReference: FirBackingFieldReference, data: D): CompositeTransformResult {
return transformElement(backingFieldReference, data)
}
open fun transformResolvedCallableReference(resolvedCallableReference: FirResolvedCallableReference, data: D): CompositeTransformResult {
return transformElement(resolvedCallableReference, data)
}
open fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: D): CompositeTransformResult {
return transformElement(resolvedTypeRef, data)
}
open fun transformErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: D): CompositeTransformResult {
return transformElement(errorTypeRef, data)
}
open fun transformTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability, data: D): CompositeTransformResult {
return transformElement(typeRefWithNullability, data)
}
open fun transformUserTypeRef(userTypeRef: FirUserTypeRef, data: D): CompositeTransformResult {
return transformElement(userTypeRef, data)
}
open fun transformDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: D): CompositeTransformResult {
return transformElement(dynamicTypeRef, data)
}
open fun transformFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: D): CompositeTransformResult {
return transformElement(functionTypeRef, data)
}
open fun transformResolvedFunctionTypeRef(resolvedFunctionTypeRef: FirResolvedFunctionTypeRef, data: D): CompositeTransformResult {
return transformElement(resolvedFunctionTypeRef, data)
}
open fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: D): CompositeTransformResult {
return transformElement(implicitTypeRef, data)
}
open fun transformComposedSuperTypeRef(composedSuperTypeRef: FirComposedSuperTypeRef, data: D): CompositeTransformResult {
return transformElement(composedSuperTypeRef, data)
}
open fun transformEffectDeclaration(effectDeclaration: FirEffectDeclaration, data: D): CompositeTransformResult {
return transformElement(effectDeclaration, data)
}
open fun transformContractDescription(contractDescription: FirContractDescription, data: D): CompositeTransformResult {
return transformElement(contractDescription, data)
}
open fun transformLegacyRawContractDescription(legacyRawContractDescription: FirLegacyRawContractDescription, data: D): CompositeTransformResult {
return transformElement(legacyRawContractDescription, data)
}
open fun transformRawContractDescription(rawContractDescription: FirRawContractDescription, data: D): CompositeTransformResult {
return transformElement(rawContractDescription, data)
}
open fun transformResolvedContractDescription(resolvedContractDescription: FirResolvedContractDescription, data: D): CompositeTransformResult {
return transformElement(resolvedContractDescription, data)
}
final override fun visitElement(element: FirElement, data: D): CompositeTransformResult {
return transformElement(element, data)
}
final override fun visitAnnotationContainer(annotationContainer: FirAnnotationContainer, data: D): CompositeTransformResult {
return transformAnnotationContainer(annotationContainer, data)
}
final override fun visitTypeRef(typeRef: FirTypeRef, data: D): CompositeTransformResult {
return transformTypeRef(typeRef, data)
}
final override fun visitReference(reference: FirReference, data: D): CompositeTransformResult {
return transformReference(reference, data)
}
final override fun visitLabel(label: FirLabel, data: D): CompositeTransformResult {
return transformLabel(label, data)
}
final override fun visitImport(import: FirImport, data: D): CompositeTransformResult {
return transformImport(import, data)
}
final override fun visitResolvedImport(resolvedImport: FirResolvedImport, data: D): CompositeTransformResult {
return transformResolvedImport(resolvedImport, data)
}
final override fun visitSymbolOwner(symbolOwner: FirSymbolOwner, data: D): CompositeTransformResult> where E : FirSymbolOwner, E : FirDeclaration {
return transformSymbolOwner(symbolOwner, data)
}
final override fun visitResolvable(resolvable: FirResolvable, data: D): CompositeTransformResult {
return transformResolvable(resolvable, data)
}
final override fun visitTargetElement(targetElement: FirTargetElement, data: D): CompositeTransformResult {
return transformTargetElement(targetElement, data)
}
final override fun visitDeclarationStatus(declarationStatus: FirDeclarationStatus, data: D): CompositeTransformResult {
return transformDeclarationStatus(declarationStatus, data)
}
final override fun visitResolvedDeclarationStatus(resolvedDeclarationStatus: FirResolvedDeclarationStatus, data: D): CompositeTransformResult {
return transformResolvedDeclarationStatus(resolvedDeclarationStatus, data)
}
final override fun visitControlFlowGraphOwner(controlFlowGraphOwner: FirControlFlowGraphOwner, data: D): CompositeTransformResult {
return transformControlFlowGraphOwner(controlFlowGraphOwner, data)
}
final override fun visitStatement(statement: FirStatement, data: D): CompositeTransformResult {
return transformStatement(statement, data)
}
final override fun visitExpression(expression: FirExpression, data: D): CompositeTransformResult {
return transformExpression(expression, data)
}
final override fun visitDeclaration(declaration: FirDeclaration, data: D): CompositeTransformResult {
return transformDeclaration(declaration, data)
}
final override fun visitAnnotatedDeclaration(annotatedDeclaration: FirAnnotatedDeclaration, data: D): CompositeTransformResult {
return transformAnnotatedDeclaration(annotatedDeclaration, data)
}
final override fun visitAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, data: D): CompositeTransformResult {
return transformAnonymousInitializer(anonymousInitializer, data)
}
final override fun visitTypedDeclaration(typedDeclaration: FirTypedDeclaration, data: D): CompositeTransformResult {
return transformTypedDeclaration(typedDeclaration, data)
}
final override fun > visitCallableDeclaration(callableDeclaration: FirCallableDeclaration, data: D): CompositeTransformResult {
return transformCallableDeclaration(callableDeclaration, data)
}
final override fun visitTypeParameterRef(typeParameterRef: FirTypeParameterRef, data: D): CompositeTransformResult {
return transformTypeParameterRef(typeParameterRef, data)
}
final override fun visitTypeParameter(typeParameter: FirTypeParameter, data: D): CompositeTransformResult {
return transformTypeParameter(typeParameter, data)
}
final override fun visitTypeParameterRefsOwner(typeParameterRefsOwner: FirTypeParameterRefsOwner, data: D): CompositeTransformResult {
return transformTypeParameterRefsOwner(typeParameterRefsOwner, data)
}
final override fun visitTypeParametersOwner(typeParametersOwner: FirTypeParametersOwner, data: D): CompositeTransformResult {
return transformTypeParametersOwner(typeParametersOwner, data)
}
final override fun visitMemberDeclaration(memberDeclaration: FirMemberDeclaration, data: D): CompositeTransformResult {
return transformMemberDeclaration(memberDeclaration, data)
}
final override fun > visitCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration, data: D): CompositeTransformResult {
return transformCallableMemberDeclaration(callableMemberDeclaration, data)
}
final override fun > visitVariable(variable: FirVariable, data: D): CompositeTransformResult {
return transformVariable(variable, data)
}
final override fun visitValueParameter(valueParameter: FirValueParameter, data: D): CompositeTransformResult {
return transformValueParameter(valueParameter, data)
}
final override fun visitProperty(property: FirProperty, data: D): CompositeTransformResult {
return transformProperty(property, data)
}
final override fun visitField(field: FirField, data: D): CompositeTransformResult {
return transformField(field, data)
}
final override fun visitEnumEntry(enumEntry: FirEnumEntry, data: D): CompositeTransformResult {
return transformEnumEntry(enumEntry, data)
}
final override fun > visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, data: D): CompositeTransformResult {
return transformClassLikeDeclaration(classLikeDeclaration, data)
}
final override fun > visitClass(klass: FirClass, data: D): CompositeTransformResult {
return transformClass(klass, data)
}
final override fun visitRegularClass(regularClass: FirRegularClass, data: D): CompositeTransformResult {
return transformRegularClass(regularClass, data)
}
final override fun visitTypeAlias(typeAlias: FirTypeAlias, data: D): CompositeTransformResult {
return transformTypeAlias(typeAlias, data)
}
final override fun > visitFunction(function: FirFunction, data: D): CompositeTransformResult {
return transformFunction(function, data)
}
final override fun visitContractDescriptionOwner(contractDescriptionOwner: FirContractDescriptionOwner, data: D): CompositeTransformResult {
return transformContractDescriptionOwner(contractDescriptionOwner, data)
}
final override fun visitSimpleFunction(simpleFunction: FirSimpleFunction, data: D): CompositeTransformResult {
return transformSimpleFunction(simpleFunction, data)
}
final override fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: D): CompositeTransformResult {
return transformPropertyAccessor(propertyAccessor, data)
}
final override fun visitConstructor(constructor: FirConstructor, data: D): CompositeTransformResult {
return transformConstructor(constructor, data)
}
final override fun visitFile(file: FirFile, data: D): CompositeTransformResult {
return transformFile(file, data)
}
final override fun visitAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: D): CompositeTransformResult {
return transformAnonymousFunction(anonymousFunction, data)
}
final override fun visitAnonymousObject(anonymousObject: FirAnonymousObject, data: D): CompositeTransformResult {
return transformAnonymousObject(anonymousObject, data)
}
final override fun visitDiagnosticHolder(diagnosticHolder: FirDiagnosticHolder, data: D): CompositeTransformResult {
return transformDiagnosticHolder(diagnosticHolder, data)
}
final override fun visitLoop(loop: FirLoop, data: D): CompositeTransformResult {
return transformLoop(loop, data)
}
final override fun visitErrorLoop(errorLoop: FirErrorLoop, data: D): CompositeTransformResult {
return transformErrorLoop(errorLoop, data)
}
final override fun visitDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: D): CompositeTransformResult {
return transformDoWhileLoop(doWhileLoop, data)
}
final override fun visitWhileLoop(whileLoop: FirWhileLoop, data: D): CompositeTransformResult {
return transformWhileLoop(whileLoop, data)
}
final override fun visitBlock(block: FirBlock, data: D): CompositeTransformResult {
return transformBlock(block, data)
}
final override fun visitBinaryLogicExpression(binaryLogicExpression: FirBinaryLogicExpression, data: D): CompositeTransformResult {
return transformBinaryLogicExpression(binaryLogicExpression, data)
}
final override fun visitJump(jump: FirJump, data: D): CompositeTransformResult {
return transformJump(jump, data)
}
final override fun visitLoopJump(loopJump: FirLoopJump, data: D): CompositeTransformResult {
return transformLoopJump(loopJump, data)
}
final override fun visitBreakExpression(breakExpression: FirBreakExpression, data: D): CompositeTransformResult {
return transformBreakExpression(breakExpression, data)
}
final override fun visitContinueExpression(continueExpression: FirContinueExpression, data: D): CompositeTransformResult {
return transformContinueExpression(continueExpression, data)
}
final override fun visitCatch(catch: FirCatch, data: D): CompositeTransformResult {
return transformCatch(catch, data)
}
final override fun visitTryExpression(tryExpression: FirTryExpression, data: D): CompositeTransformResult {
return transformTryExpression(tryExpression, data)
}
final override fun visitConstExpression(constExpression: FirConstExpression, data: D): CompositeTransformResult {
return transformConstExpression(constExpression, data)
}
final override fun visitTypeProjection(typeProjection: FirTypeProjection, data: D): CompositeTransformResult {
return transformTypeProjection(typeProjection, data)
}
final override fun visitStarProjection(starProjection: FirStarProjection, data: D): CompositeTransformResult {
return transformStarProjection(starProjection, data)
}
final override fun visitTypeProjectionWithVariance(typeProjectionWithVariance: FirTypeProjectionWithVariance, data: D): CompositeTransformResult {
return transformTypeProjectionWithVariance(typeProjectionWithVariance, data)
}
final override fun visitArgumentList(argumentList: FirArgumentList, data: D): CompositeTransformResult {
return transformArgumentList(argumentList, data)
}
final override fun visitCall(call: FirCall, data: D): CompositeTransformResult {
return transformCall(call, data)
}
final override fun visitAnnotationCall(annotationCall: FirAnnotationCall, data: D): CompositeTransformResult {
return transformAnnotationCall(annotationCall, data)
}
final override fun visitComparisonExpression(comparisonExpression: FirComparisonExpression, data: D): CompositeTransformResult {
return transformComparisonExpression(comparisonExpression, data)
}
final override fun visitTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: D): CompositeTransformResult {
return transformTypeOperatorCall(typeOperatorCall, data)
}
final override fun visitAssignmentOperatorStatement(assignmentOperatorStatement: FirAssignmentOperatorStatement, data: D): CompositeTransformResult {
return transformAssignmentOperatorStatement(assignmentOperatorStatement, data)
}
final override fun visitEqualityOperatorCall(equalityOperatorCall: FirEqualityOperatorCall, data: D): CompositeTransformResult {
return transformEqualityOperatorCall(equalityOperatorCall, data)
}
final override fun visitWhenExpression(whenExpression: FirWhenExpression, data: D): CompositeTransformResult {
return transformWhenExpression(whenExpression, data)
}
final override fun visitWhenBranch(whenBranch: FirWhenBranch, data: D): CompositeTransformResult {
return transformWhenBranch(whenBranch, data)
}
final override fun visitQualifiedAccess(qualifiedAccess: FirQualifiedAccess, data: D): CompositeTransformResult {
return transformQualifiedAccess(qualifiedAccess, data)
}
final override fun visitCheckNotNullCall(checkNotNullCall: FirCheckNotNullCall, data: D): CompositeTransformResult {
return transformCheckNotNullCall(checkNotNullCall, data)
}
final override fun visitElvisExpression(elvisExpression: FirElvisExpression, data: D): CompositeTransformResult {
return transformElvisExpression(elvisExpression, data)
}
final override fun visitArrayOfCall(arrayOfCall: FirArrayOfCall, data: D): CompositeTransformResult {
return transformArrayOfCall(arrayOfCall, data)
}
final override fun visitAugmentedArraySetCall(augmentedArraySetCall: FirAugmentedArraySetCall, data: D): CompositeTransformResult {
return transformAugmentedArraySetCall(augmentedArraySetCall, data)
}
final override fun visitClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression, data: D): CompositeTransformResult {
return transformClassReferenceExpression(classReferenceExpression, data)
}
final override fun visitErrorExpression(errorExpression: FirErrorExpression, data: D): CompositeTransformResult {
return transformErrorExpression(errorExpression, data)
}
final override fun visitErrorFunction(errorFunction: FirErrorFunction, data: D): CompositeTransformResult {
return transformErrorFunction(errorFunction, data)
}
final override fun visitErrorProperty(errorProperty: FirErrorProperty, data: D): CompositeTransformResult {
return transformErrorProperty(errorProperty, data)
}
final override fun visitQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression, data: D): CompositeTransformResult {
return transformQualifiedAccessExpression(qualifiedAccessExpression, data)
}
final override fun visitFunctionCall(functionCall: FirFunctionCall, data: D): CompositeTransformResult {
return transformFunctionCall(functionCall, data)
}
final override fun visitDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall, data: D): CompositeTransformResult {
return transformDelegatedConstructorCall(delegatedConstructorCall, data)
}
final override fun visitComponentCall(componentCall: FirComponentCall, data: D): CompositeTransformResult {
return transformComponentCall(componentCall, data)
}
final override fun visitCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess, data: D): CompositeTransformResult {
return transformCallableReferenceAccess(callableReferenceAccess, data)
}
final override fun visitThisReceiverExpression(thisReceiverExpression: FirThisReceiverExpression, data: D): CompositeTransformResult {
return transformThisReceiverExpression(thisReceiverExpression, data)
}
final override fun visitExpressionWithSmartcast(expressionWithSmartcast: FirExpressionWithSmartcast, data: D): CompositeTransformResult