From 263f6b1fd8d9889af04ef30f34057dc6b01ee081 Mon Sep 17 00:00:00 2001 From: Tianyu Geng Date: Tue, 28 Sep 2021 16:20:06 -0700 Subject: [PATCH] FIR: generate FirDefaultVisitor and FirDefaultVisitorVoid... so they won't be outdated when FIR class tree is updated. --- .../FirInlineDeclarationChecker.kt | 5 +- .../kotlin/fir/visitors/FirDefaultVisitor.kt | 409 ++++++++++++++++++ .../fir/visitors/FirDefaultVisitorVoid.kt | 409 ++++++++++++++++++ .../kotlin/fir/visitors/FirDefaultVisitor.kt | 99 ----- .../fir/visitors/FirDefaultVisitorVoid.kt | 98 ----- .../kotlin/fir/tree/generator/printer/main.kt | 4 +- .../fir/tree/generator/printer/visitor.kt | 58 ++- 7 files changed, 876 insertions(+), 206 deletions(-) create mode 100644 compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitor.kt create mode 100644 compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitorVoid.kt delete mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitor.kt delete mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitorVoid.kt diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInlineDeclarationChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInlineDeclarationChecker.kt index 58866637b05..94b6554426a 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInlineDeclarationChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInlineDeclarationChecker.kt @@ -112,9 +112,8 @@ object FirInlineDeclarationChecker : FirFunctionChecker() { checkReceiversOfQualifiedAccessExpression(qualifiedAccessExpression, targetSymbol, data) } - override fun visitPropertyAccessExpression(propertyAccessExpression: FirPropertyAccessExpression, data: CheckerContext) { - visitQualifiedAccessExpression(propertyAccessExpression, data) - } + // prevent delegation to visitQualifiedAccessExpression, which causes redundant diagnostics + override fun visitExpressionWithSmartcast(expressionWithSmartcast: FirExpressionWithSmartcast, data: CheckerContext) {} override fun visitVariableAssignment(variableAssignment: FirVariableAssignment, data: CheckerContext) { val propertySymbol = variableAssignment.calleeReference.toResolvedCallableSymbol() as? FirPropertySymbol ?: return 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 new file mode 100644 index 00000000000..84487a42b03 --- /dev/null +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitor.kt @@ -0,0 +1,409 @@ +/* + * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.fir.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.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.FirTypeParameterRefsOwner +import org.jetbrains.kotlin.fir.declarations.FirTypeParametersOwner +import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration +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.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.FirBackingField +import org.jetbrains.kotlin.fir.declarations.FirConstructor +import org.jetbrains.kotlin.fir.declarations.FirFile +import org.jetbrains.kotlin.fir.FirPackageDirective +import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction +import org.jetbrains.kotlin.fir.expressions.FirAnonymousFunctionExpression +import org.jetbrains.kotlin.fir.declarations.FirAnonymousObject +import org.jetbrains.kotlin.fir.expressions.FirAnonymousObjectExpression +import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder +import org.jetbrains.kotlin.fir.declarations.FirImport +import org.jetbrains.kotlin.fir.declarations.FirResolvedImport +import org.jetbrains.kotlin.fir.declarations.FirErrorImport +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.FirAnnotation +import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall +import org.jetbrains.kotlin.fir.expressions.FirAnnotationArgumentMapping +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.FirPropertyAccessExpression +import org.jetbrains.kotlin.fir.expressions.FirFunctionCall +import org.jetbrains.kotlin.fir.expressions.FirImplicitInvokeCall +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.FirExpressionWithSmartcastToNull +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.FirImplicitTypeRef +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 + +/* + * This file was generated automatically + * DO NOT MODIFY IT MANUALLY + */ + +abstract class FirDefaultVisitor : FirVisitor() { + override fun visitAnnotationContainer(annotationContainer: FirAnnotationContainer, data: D): R = visitElement(annotationContainer, data) + + override fun visitTypeRef(typeRef: FirTypeRef, data: D): R = visitAnnotationContainer(typeRef, data) + + override fun visitReference(reference: FirReference, data: D): R = visitElement(reference, data) + + override fun visitLabel(label: FirLabel, data: D): R = visitElement(label, data) + + override fun visitResolvable(resolvable: FirResolvable, data: D): R = visitElement(resolvable, data) + + override fun visitTargetElement(targetElement: FirTargetElement, data: D): R = visitElement(targetElement, data) + + override fun visitDeclarationStatus(declarationStatus: FirDeclarationStatus, data: D): R = visitElement(declarationStatus, data) + + override fun visitResolvedDeclarationStatus(resolvedDeclarationStatus: FirResolvedDeclarationStatus, data: D): R = visitDeclarationStatus(resolvedDeclarationStatus, data) + + override fun visitControlFlowGraphOwner(controlFlowGraphOwner: FirControlFlowGraphOwner, data: D): R = visitElement(controlFlowGraphOwner, data) + + override fun visitStatement(statement: FirStatement, data: D): R = visitAnnotationContainer(statement, data) + + override fun visitExpression(expression: FirExpression, data: D): R = visitStatement(expression, data) + + override fun visitDeclaration(declaration: FirDeclaration, data: D): R = visitElement(declaration, data) + + override fun visitAnnotatedDeclaration(annotatedDeclaration: FirAnnotatedDeclaration, data: D): R = visitDeclaration(annotatedDeclaration, data) + + override fun visitAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, data: D): R = visitDeclaration(anonymousInitializer, data) + + override fun visitTypedDeclaration(typedDeclaration: FirTypedDeclaration, data: D): R = visitAnnotatedDeclaration(typedDeclaration, data) + + override fun visitTypeParameterRefsOwner(typeParameterRefsOwner: FirTypeParameterRefsOwner, data: D): R = visitElement(typeParameterRefsOwner, data) + + override fun visitTypeParametersOwner(typeParametersOwner: FirTypeParametersOwner, data: D): R = visitTypeParameterRefsOwner(typeParametersOwner, data) + + override fun visitMemberDeclaration(memberDeclaration: FirMemberDeclaration, data: D): R = visitTypeParameterRefsOwner(memberDeclaration, data) + + override fun visitCallableDeclaration(callableDeclaration: FirCallableDeclaration, data: D): R = visitTypedDeclaration(callableDeclaration, data) + + override fun visitTypeParameterRef(typeParameterRef: FirTypeParameterRef, data: D): R = visitElement(typeParameterRef, data) + + override fun visitTypeParameter(typeParameter: FirTypeParameter, data: D): R = visitTypeParameterRef(typeParameter, data) + + override fun visitVariable(variable: FirVariable, data: D): R = visitCallableDeclaration(variable, data) + + override fun visitValueParameter(valueParameter: FirValueParameter, data: D): R = visitVariable(valueParameter, data) + + override fun visitProperty(property: FirProperty, data: D): R = visitVariable(property, data) + + override fun visitField(field: FirField, data: D): R = visitVariable(field, data) + + override fun visitEnumEntry(enumEntry: FirEnumEntry, data: D): R = visitVariable(enumEntry, data) + + override fun visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, data: D): R = visitAnnotatedDeclaration(classLikeDeclaration, data) + + override fun visitClass(klass: FirClass, data: D): R = visitClassLikeDeclaration(klass, data) + + override fun visitRegularClass(regularClass: FirRegularClass, data: D): R = visitClass(regularClass, data) + + override fun visitTypeAlias(typeAlias: FirTypeAlias, data: D): R = visitClassLikeDeclaration(typeAlias, data) + + override fun visitFunction(function: FirFunction, data: D): R = visitCallableDeclaration(function, data) + + override fun visitContractDescriptionOwner(contractDescriptionOwner: FirContractDescriptionOwner, data: D): R = visitElement(contractDescriptionOwner, data) + + override fun visitSimpleFunction(simpleFunction: FirSimpleFunction, data: D): R = visitFunction(simpleFunction, data) + + override fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: D): R = visitFunction(propertyAccessor, data) + + override fun visitBackingField(backingField: FirBackingField, data: D): R = visitVariable(backingField, data) + + override fun visitConstructor(constructor: FirConstructor, data: D): R = visitFunction(constructor, data) + + override fun visitFile(file: FirFile, data: D): R = visitAnnotatedDeclaration(file, data) + + override fun visitPackageDirective(packageDirective: FirPackageDirective, data: D): R = visitElement(packageDirective, data) + + override fun visitAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: D): R = visitFunction(anonymousFunction, data) + + override fun visitAnonymousFunctionExpression(anonymousFunctionExpression: FirAnonymousFunctionExpression, data: D): R = visitExpression(anonymousFunctionExpression, data) + + override fun visitAnonymousObject(anonymousObject: FirAnonymousObject, data: D): R = visitClass(anonymousObject, data) + + override fun visitAnonymousObjectExpression(anonymousObjectExpression: FirAnonymousObjectExpression, data: D): R = visitExpression(anonymousObjectExpression, data) + + override fun visitDiagnosticHolder(diagnosticHolder: FirDiagnosticHolder, data: D): R = visitElement(diagnosticHolder, data) + + override fun visitImport(import: FirImport, data: D): R = visitElement(import, data) + + override fun visitResolvedImport(resolvedImport: FirResolvedImport, data: D): R = visitImport(resolvedImport, data) + + override fun visitErrorImport(errorImport: FirErrorImport, data: D): R = visitImport(errorImport, data) + + override fun visitLoop(loop: FirLoop, data: D): R = visitStatement(loop, data) + + override fun visitErrorLoop(errorLoop: FirErrorLoop, data: D): R = visitLoop(errorLoop, data) + + override fun visitDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: D): R = visitLoop(doWhileLoop, data) + + override fun visitWhileLoop(whileLoop: FirWhileLoop, data: D): R = visitLoop(whileLoop, data) + + override fun visitBlock(block: FirBlock, data: D): R = visitExpression(block, data) + + override fun visitBinaryLogicExpression(binaryLogicExpression: FirBinaryLogicExpression, data: D): R = visitExpression(binaryLogicExpression, data) + + override fun visitJump(jump: FirJump, data: D): R = visitExpression(jump, data) + + override fun visitLoopJump(loopJump: FirLoopJump, data: D): R = visitJump(loopJump, data) + + override fun visitBreakExpression(breakExpression: FirBreakExpression, data: D): R = visitLoopJump(breakExpression, data) + + override fun visitContinueExpression(continueExpression: FirContinueExpression, data: D): R = visitLoopJump(continueExpression, data) + + override fun visitCatch(catch: FirCatch, data: D): R = visitElement(catch, data) + + override fun visitTryExpression(tryExpression: FirTryExpression, data: D): R = visitExpression(tryExpression, data) + + override fun visitConstExpression(constExpression: FirConstExpression, data: D): R = visitExpression(constExpression, data) + + override fun visitTypeProjection(typeProjection: FirTypeProjection, data: D): R = visitElement(typeProjection, data) + + override fun visitStarProjection(starProjection: FirStarProjection, data: D): R = visitTypeProjection(starProjection, data) + + override fun visitTypeProjectionWithVariance(typeProjectionWithVariance: FirTypeProjectionWithVariance, data: D): R = visitTypeProjection(typeProjectionWithVariance, data) + + override fun visitArgumentList(argumentList: FirArgumentList, data: D): R = visitElement(argumentList, data) + + override fun visitCall(call: FirCall, data: D): R = visitStatement(call, data) + + override fun visitAnnotation(annotation: FirAnnotation, data: D): R = visitExpression(annotation, data) + + override fun visitAnnotationCall(annotationCall: FirAnnotationCall, data: D): R = visitAnnotation(annotationCall, data) + + override fun visitAnnotationArgumentMapping(annotationArgumentMapping: FirAnnotationArgumentMapping, data: D): R = visitElement(annotationArgumentMapping, data) + + override fun visitComparisonExpression(comparisonExpression: FirComparisonExpression, data: D): R = visitExpression(comparisonExpression, data) + + override fun visitTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: D): R = visitExpression(typeOperatorCall, data) + + override fun visitAssignmentOperatorStatement(assignmentOperatorStatement: FirAssignmentOperatorStatement, data: D): R = visitStatement(assignmentOperatorStatement, data) + + override fun visitEqualityOperatorCall(equalityOperatorCall: FirEqualityOperatorCall, data: D): R = visitExpression(equalityOperatorCall, data) + + override fun visitWhenExpression(whenExpression: FirWhenExpression, data: D): R = visitExpression(whenExpression, data) + + override fun visitWhenBranch(whenBranch: FirWhenBranch, data: D): R = visitElement(whenBranch, data) + + override fun visitQualifiedAccess(qualifiedAccess: FirQualifiedAccess, data: D): R = visitResolvable(qualifiedAccess, data) + + override fun visitCheckNotNullCall(checkNotNullCall: FirCheckNotNullCall, data: D): R = visitExpression(checkNotNullCall, data) + + override fun visitElvisExpression(elvisExpression: FirElvisExpression, data: D): R = visitExpression(elvisExpression, data) + + override fun visitArrayOfCall(arrayOfCall: FirArrayOfCall, data: D): R = visitExpression(arrayOfCall, data) + + override fun visitAugmentedArraySetCall(augmentedArraySetCall: FirAugmentedArraySetCall, data: D): R = visitStatement(augmentedArraySetCall, data) + + override fun visitClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression, data: D): R = visitExpression(classReferenceExpression, data) + + override fun visitErrorExpression(errorExpression: FirErrorExpression, data: D): R = visitExpression(errorExpression, data) + + override fun visitErrorFunction(errorFunction: FirErrorFunction, data: D): R = visitFunction(errorFunction, data) + + override fun visitErrorProperty(errorProperty: FirErrorProperty, data: D): R = visitVariable(errorProperty, data) + + override fun visitQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression, data: D): R = visitExpression(qualifiedAccessExpression, data) + + override fun visitPropertyAccessExpression(propertyAccessExpression: FirPropertyAccessExpression, data: D): R = visitQualifiedAccessExpression(propertyAccessExpression, data) + + override fun visitFunctionCall(functionCall: FirFunctionCall, data: D): R = visitQualifiedAccessExpression(functionCall, data) + + override fun visitImplicitInvokeCall(implicitInvokeCall: FirImplicitInvokeCall, data: D): R = visitFunctionCall(implicitInvokeCall, data) + + override fun visitDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall, data: D): R = visitResolvable(delegatedConstructorCall, data) + + override fun visitComponentCall(componentCall: FirComponentCall, data: D): R = visitFunctionCall(componentCall, data) + + override fun visitCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess, data: D): R = visitQualifiedAccessExpression(callableReferenceAccess, data) + + override fun visitThisReceiverExpression(thisReceiverExpression: FirThisReceiverExpression, data: D): R = visitQualifiedAccessExpression(thisReceiverExpression, data) + + override fun visitExpressionWithSmartcast(expressionWithSmartcast: FirExpressionWithSmartcast, data: D): R = visitQualifiedAccessExpression(expressionWithSmartcast, data) + + override fun visitExpressionWithSmartcastToNull(expressionWithSmartcastToNull: FirExpressionWithSmartcastToNull, data: D): R = visitExpressionWithSmartcast(expressionWithSmartcastToNull, data) + + override fun visitSafeCallExpression(safeCallExpression: FirSafeCallExpression, data: D): R = visitExpression(safeCallExpression, data) + + override fun visitCheckedSafeCallSubject(checkedSafeCallSubject: FirCheckedSafeCallSubject, data: D): R = visitExpression(checkedSafeCallSubject, data) + + override fun visitGetClassCall(getClassCall: FirGetClassCall, data: D): R = visitExpression(getClassCall, data) + + override fun visitWrappedExpression(wrappedExpression: FirWrappedExpression, data: D): R = visitExpression(wrappedExpression, data) + + override fun visitWrappedArgumentExpression(wrappedArgumentExpression: FirWrappedArgumentExpression, data: D): R = visitWrappedExpression(wrappedArgumentExpression, data) + + override fun visitLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression, data: D): R = visitWrappedArgumentExpression(lambdaArgumentExpression, data) + + override fun visitSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression, data: D): R = visitWrappedArgumentExpression(spreadArgumentExpression, data) + + override fun visitNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression, data: D): R = visitWrappedArgumentExpression(namedArgumentExpression, data) + + override fun visitVarargArgumentsExpression(varargArgumentsExpression: FirVarargArgumentsExpression, data: D): R = visitExpression(varargArgumentsExpression, data) + + override fun visitResolvedQualifier(resolvedQualifier: FirResolvedQualifier, data: D): R = visitExpression(resolvedQualifier, data) + + override fun visitErrorResolvedQualifier(errorResolvedQualifier: FirErrorResolvedQualifier, data: D): R = visitResolvedQualifier(errorResolvedQualifier, data) + + override fun visitResolvedReifiedParameterReference(resolvedReifiedParameterReference: FirResolvedReifiedParameterReference, data: D): R = visitExpression(resolvedReifiedParameterReference, data) + + override fun visitReturnExpression(returnExpression: FirReturnExpression, data: D): R = visitJump(returnExpression, data) + + override fun visitStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall, data: D): R = visitCall(stringConcatenationCall, data) + + override fun visitThrowExpression(throwExpression: FirThrowExpression, data: D): R = visitExpression(throwExpression, data) + + override fun visitVariableAssignment(variableAssignment: FirVariableAssignment, data: D): R = visitQualifiedAccess(variableAssignment, data) + + override fun visitWhenSubjectExpression(whenSubjectExpression: FirWhenSubjectExpression, data: D): R = visitExpression(whenSubjectExpression, data) + + override fun visitWrappedDelegateExpression(wrappedDelegateExpression: FirWrappedDelegateExpression, data: D): R = visitWrappedExpression(wrappedDelegateExpression, data) + + override fun visitNamedReference(namedReference: FirNamedReference, data: D): R = visitReference(namedReference, data) + + override fun visitErrorNamedReference(errorNamedReference: FirErrorNamedReference, data: D): R = visitNamedReference(errorNamedReference, data) + + override fun visitSuperReference(superReference: FirSuperReference, data: D): R = visitReference(superReference, data) + + override fun visitThisReference(thisReference: FirThisReference, data: D): R = visitReference(thisReference, data) + + override fun visitControlFlowGraphReference(controlFlowGraphReference: FirControlFlowGraphReference, data: D): R = visitReference(controlFlowGraphReference, data) + + override fun visitResolvedNamedReference(resolvedNamedReference: FirResolvedNamedReference, data: D): R = visitNamedReference(resolvedNamedReference, data) + + override fun visitDelegateFieldReference(delegateFieldReference: FirDelegateFieldReference, data: D): R = visitResolvedNamedReference(delegateFieldReference, data) + + override fun visitBackingFieldReference(backingFieldReference: FirBackingFieldReference, data: D): R = visitResolvedNamedReference(backingFieldReference, data) + + override fun visitResolvedCallableReference(resolvedCallableReference: FirResolvedCallableReference, data: D): R = visitResolvedNamedReference(resolvedCallableReference, data) + + override fun visitResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: D): R = visitTypeRef(resolvedTypeRef, data) + + override fun visitErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: D): R = visitResolvedTypeRef(errorTypeRef, data) + + override fun visitTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability, data: D): R = visitTypeRef(typeRefWithNullability, data) + + override fun visitUserTypeRef(userTypeRef: FirUserTypeRef, data: D): R = visitTypeRefWithNullability(userTypeRef, data) + + override fun visitDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: D): R = visitTypeRefWithNullability(dynamicTypeRef, data) + + override fun visitFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: D): R = visitTypeRefWithNullability(functionTypeRef, data) + + override fun visitImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: D): R = visitTypeRef(implicitTypeRef, data) + + override fun visitEffectDeclaration(effectDeclaration: FirEffectDeclaration, data: D): R = visitElement(effectDeclaration, data) + + override fun visitContractDescription(contractDescription: FirContractDescription, data: D): R = visitElement(contractDescription, data) + + override fun visitLegacyRawContractDescription(legacyRawContractDescription: FirLegacyRawContractDescription, data: D): R = visitContractDescription(legacyRawContractDescription, data) + + 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/FirDefaultVisitorVoid.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitorVoid.kt new file mode 100644 index 00000000000..3dd364000a1 --- /dev/null +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitorVoid.kt @@ -0,0 +1,409 @@ +/* + * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.fir.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.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.FirTypeParameterRefsOwner +import org.jetbrains.kotlin.fir.declarations.FirTypeParametersOwner +import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration +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.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.FirBackingField +import org.jetbrains.kotlin.fir.declarations.FirConstructor +import org.jetbrains.kotlin.fir.declarations.FirFile +import org.jetbrains.kotlin.fir.FirPackageDirective +import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction +import org.jetbrains.kotlin.fir.expressions.FirAnonymousFunctionExpression +import org.jetbrains.kotlin.fir.declarations.FirAnonymousObject +import org.jetbrains.kotlin.fir.expressions.FirAnonymousObjectExpression +import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder +import org.jetbrains.kotlin.fir.declarations.FirImport +import org.jetbrains.kotlin.fir.declarations.FirResolvedImport +import org.jetbrains.kotlin.fir.declarations.FirErrorImport +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.FirAnnotation +import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall +import org.jetbrains.kotlin.fir.expressions.FirAnnotationArgumentMapping +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.FirPropertyAccessExpression +import org.jetbrains.kotlin.fir.expressions.FirFunctionCall +import org.jetbrains.kotlin.fir.expressions.FirImplicitInvokeCall +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.FirExpressionWithSmartcastToNull +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.FirImplicitTypeRef +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 + +/* + * This file was generated automatically + * DO NOT MODIFY IT MANUALLY + */ + +abstract class FirDefaultVisitorVoid : FirVisitorVoid() { + override fun visitAnnotationContainer(annotationContainer: FirAnnotationContainer) = visitElement(annotationContainer) + + override fun visitTypeRef(typeRef: FirTypeRef) = visitAnnotationContainer(typeRef) + + override fun visitReference(reference: FirReference) = visitElement(reference) + + override fun visitLabel(label: FirLabel) = visitElement(label) + + override fun visitResolvable(resolvable: FirResolvable) = visitElement(resolvable) + + override fun visitTargetElement(targetElement: FirTargetElement) = visitElement(targetElement) + + override fun visitDeclarationStatus(declarationStatus: FirDeclarationStatus) = visitElement(declarationStatus) + + override fun visitResolvedDeclarationStatus(resolvedDeclarationStatus: FirResolvedDeclarationStatus) = visitDeclarationStatus(resolvedDeclarationStatus) + + override fun visitControlFlowGraphOwner(controlFlowGraphOwner: FirControlFlowGraphOwner) = visitElement(controlFlowGraphOwner) + + override fun visitStatement(statement: FirStatement) = visitAnnotationContainer(statement) + + override fun visitExpression(expression: FirExpression) = visitStatement(expression) + + override fun visitDeclaration(declaration: FirDeclaration) = visitElement(declaration) + + override fun visitAnnotatedDeclaration(annotatedDeclaration: FirAnnotatedDeclaration) = visitDeclaration(annotatedDeclaration) + + override fun visitAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer) = visitDeclaration(anonymousInitializer) + + override fun visitTypedDeclaration(typedDeclaration: FirTypedDeclaration) = visitAnnotatedDeclaration(typedDeclaration) + + override fun visitTypeParameterRefsOwner(typeParameterRefsOwner: FirTypeParameterRefsOwner) = visitElement(typeParameterRefsOwner) + + override fun visitTypeParametersOwner(typeParametersOwner: FirTypeParametersOwner) = visitTypeParameterRefsOwner(typeParametersOwner) + + override fun visitMemberDeclaration(memberDeclaration: FirMemberDeclaration) = visitTypeParameterRefsOwner(memberDeclaration) + + override fun visitCallableDeclaration(callableDeclaration: FirCallableDeclaration) = visitTypedDeclaration(callableDeclaration) + + override fun visitTypeParameterRef(typeParameterRef: FirTypeParameterRef) = visitElement(typeParameterRef) + + override fun visitTypeParameter(typeParameter: FirTypeParameter) = visitTypeParameterRef(typeParameter) + + override fun visitVariable(variable: FirVariable) = visitCallableDeclaration(variable) + + override fun visitValueParameter(valueParameter: FirValueParameter) = visitVariable(valueParameter) + + override fun visitProperty(property: FirProperty) = visitVariable(property) + + override fun visitField(field: FirField) = visitVariable(field) + + override fun visitEnumEntry(enumEntry: FirEnumEntry) = visitVariable(enumEntry) + + override fun visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration) = visitAnnotatedDeclaration(classLikeDeclaration) + + override fun visitClass(klass: FirClass) = visitClassLikeDeclaration(klass) + + override fun visitRegularClass(regularClass: FirRegularClass) = visitClass(regularClass) + + override fun visitTypeAlias(typeAlias: FirTypeAlias) = visitClassLikeDeclaration(typeAlias) + + override fun visitFunction(function: FirFunction) = visitCallableDeclaration(function) + + override fun visitContractDescriptionOwner(contractDescriptionOwner: FirContractDescriptionOwner) = visitElement(contractDescriptionOwner) + + override fun visitSimpleFunction(simpleFunction: FirSimpleFunction) = visitFunction(simpleFunction) + + override fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor) = visitFunction(propertyAccessor) + + override fun visitBackingField(backingField: FirBackingField) = visitVariable(backingField) + + override fun visitConstructor(constructor: FirConstructor) = visitFunction(constructor) + + override fun visitFile(file: FirFile) = visitAnnotatedDeclaration(file) + + override fun visitPackageDirective(packageDirective: FirPackageDirective) = visitElement(packageDirective) + + override fun visitAnonymousFunction(anonymousFunction: FirAnonymousFunction) = visitFunction(anonymousFunction) + + override fun visitAnonymousFunctionExpression(anonymousFunctionExpression: FirAnonymousFunctionExpression) = visitExpression(anonymousFunctionExpression) + + override fun visitAnonymousObject(anonymousObject: FirAnonymousObject) = visitClass(anonymousObject) + + override fun visitAnonymousObjectExpression(anonymousObjectExpression: FirAnonymousObjectExpression) = visitExpression(anonymousObjectExpression) + + override fun visitDiagnosticHolder(diagnosticHolder: FirDiagnosticHolder) = visitElement(diagnosticHolder) + + override fun visitImport(import: FirImport) = visitElement(import) + + override fun visitResolvedImport(resolvedImport: FirResolvedImport) = visitImport(resolvedImport) + + override fun visitErrorImport(errorImport: FirErrorImport) = visitImport(errorImport) + + override fun visitLoop(loop: FirLoop) = visitStatement(loop) + + override fun visitErrorLoop(errorLoop: FirErrorLoop) = visitLoop(errorLoop) + + override fun visitDoWhileLoop(doWhileLoop: FirDoWhileLoop) = visitLoop(doWhileLoop) + + override fun visitWhileLoop(whileLoop: FirWhileLoop) = visitLoop(whileLoop) + + override fun visitBlock(block: FirBlock) = visitExpression(block) + + override fun visitBinaryLogicExpression(binaryLogicExpression: FirBinaryLogicExpression) = visitExpression(binaryLogicExpression) + + override fun visitJump(jump: FirJump) = visitExpression(jump) + + override fun visitLoopJump(loopJump: FirLoopJump) = visitJump(loopJump) + + override fun visitBreakExpression(breakExpression: FirBreakExpression) = visitLoopJump(breakExpression) + + override fun visitContinueExpression(continueExpression: FirContinueExpression) = visitLoopJump(continueExpression) + + override fun visitCatch(catch: FirCatch) = visitElement(catch) + + override fun visitTryExpression(tryExpression: FirTryExpression) = visitExpression(tryExpression) + + override fun visitConstExpression(constExpression: FirConstExpression) = visitExpression(constExpression) + + override fun visitTypeProjection(typeProjection: FirTypeProjection) = visitElement(typeProjection) + + override fun visitStarProjection(starProjection: FirStarProjection) = visitTypeProjection(starProjection) + + override fun visitTypeProjectionWithVariance(typeProjectionWithVariance: FirTypeProjectionWithVariance) = visitTypeProjection(typeProjectionWithVariance) + + override fun visitArgumentList(argumentList: FirArgumentList) = visitElement(argumentList) + + override fun visitCall(call: FirCall) = visitStatement(call) + + override fun visitAnnotation(annotation: FirAnnotation) = visitExpression(annotation) + + override fun visitAnnotationCall(annotationCall: FirAnnotationCall) = visitAnnotation(annotationCall) + + override fun visitAnnotationArgumentMapping(annotationArgumentMapping: FirAnnotationArgumentMapping) = visitElement(annotationArgumentMapping) + + override fun visitComparisonExpression(comparisonExpression: FirComparisonExpression) = visitExpression(comparisonExpression) + + override fun visitTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall) = visitExpression(typeOperatorCall) + + override fun visitAssignmentOperatorStatement(assignmentOperatorStatement: FirAssignmentOperatorStatement) = visitStatement(assignmentOperatorStatement) + + override fun visitEqualityOperatorCall(equalityOperatorCall: FirEqualityOperatorCall) = visitExpression(equalityOperatorCall) + + override fun visitWhenExpression(whenExpression: FirWhenExpression) = visitExpression(whenExpression) + + override fun visitWhenBranch(whenBranch: FirWhenBranch) = visitElement(whenBranch) + + override fun visitQualifiedAccess(qualifiedAccess: FirQualifiedAccess) = visitResolvable(qualifiedAccess) + + override fun visitCheckNotNullCall(checkNotNullCall: FirCheckNotNullCall) = visitExpression(checkNotNullCall) + + override fun visitElvisExpression(elvisExpression: FirElvisExpression) = visitExpression(elvisExpression) + + override fun visitArrayOfCall(arrayOfCall: FirArrayOfCall) = visitExpression(arrayOfCall) + + override fun visitAugmentedArraySetCall(augmentedArraySetCall: FirAugmentedArraySetCall) = visitStatement(augmentedArraySetCall) + + override fun visitClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression) = visitExpression(classReferenceExpression) + + override fun visitErrorExpression(errorExpression: FirErrorExpression) = visitExpression(errorExpression) + + override fun visitErrorFunction(errorFunction: FirErrorFunction) = visitFunction(errorFunction) + + override fun visitErrorProperty(errorProperty: FirErrorProperty) = visitVariable(errorProperty) + + override fun visitQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression) = visitExpression(qualifiedAccessExpression) + + override fun visitPropertyAccessExpression(propertyAccessExpression: FirPropertyAccessExpression) = visitQualifiedAccessExpression(propertyAccessExpression) + + override fun visitFunctionCall(functionCall: FirFunctionCall) = visitQualifiedAccessExpression(functionCall) + + override fun visitImplicitInvokeCall(implicitInvokeCall: FirImplicitInvokeCall) = visitFunctionCall(implicitInvokeCall) + + override fun visitDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall) = visitResolvable(delegatedConstructorCall) + + override fun visitComponentCall(componentCall: FirComponentCall) = visitFunctionCall(componentCall) + + override fun visitCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess) = visitQualifiedAccessExpression(callableReferenceAccess) + + override fun visitThisReceiverExpression(thisReceiverExpression: FirThisReceiverExpression) = visitQualifiedAccessExpression(thisReceiverExpression) + + override fun visitExpressionWithSmartcast(expressionWithSmartcast: FirExpressionWithSmartcast) = visitQualifiedAccessExpression(expressionWithSmartcast) + + override fun visitExpressionWithSmartcastToNull(expressionWithSmartcastToNull: FirExpressionWithSmartcastToNull) = visitExpressionWithSmartcast(expressionWithSmartcastToNull) + + override fun visitSafeCallExpression(safeCallExpression: FirSafeCallExpression) = visitExpression(safeCallExpression) + + override fun visitCheckedSafeCallSubject(checkedSafeCallSubject: FirCheckedSafeCallSubject) = visitExpression(checkedSafeCallSubject) + + override fun visitGetClassCall(getClassCall: FirGetClassCall) = visitExpression(getClassCall) + + override fun visitWrappedExpression(wrappedExpression: FirWrappedExpression) = visitExpression(wrappedExpression) + + override fun visitWrappedArgumentExpression(wrappedArgumentExpression: FirWrappedArgumentExpression) = visitWrappedExpression(wrappedArgumentExpression) + + override fun visitLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression) = visitWrappedArgumentExpression(lambdaArgumentExpression) + + override fun visitSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression) = visitWrappedArgumentExpression(spreadArgumentExpression) + + override fun visitNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression) = visitWrappedArgumentExpression(namedArgumentExpression) + + override fun visitVarargArgumentsExpression(varargArgumentsExpression: FirVarargArgumentsExpression) = visitExpression(varargArgumentsExpression) + + override fun visitResolvedQualifier(resolvedQualifier: FirResolvedQualifier) = visitExpression(resolvedQualifier) + + override fun visitErrorResolvedQualifier(errorResolvedQualifier: FirErrorResolvedQualifier) = visitResolvedQualifier(errorResolvedQualifier) + + override fun visitResolvedReifiedParameterReference(resolvedReifiedParameterReference: FirResolvedReifiedParameterReference) = visitExpression(resolvedReifiedParameterReference) + + override fun visitReturnExpression(returnExpression: FirReturnExpression) = visitJump(returnExpression) + + override fun visitStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall) = visitCall(stringConcatenationCall) + + override fun visitThrowExpression(throwExpression: FirThrowExpression) = visitExpression(throwExpression) + + override fun visitVariableAssignment(variableAssignment: FirVariableAssignment) = visitQualifiedAccess(variableAssignment) + + override fun visitWhenSubjectExpression(whenSubjectExpression: FirWhenSubjectExpression) = visitExpression(whenSubjectExpression) + + override fun visitWrappedDelegateExpression(wrappedDelegateExpression: FirWrappedDelegateExpression) = visitWrappedExpression(wrappedDelegateExpression) + + override fun visitNamedReference(namedReference: FirNamedReference) = visitReference(namedReference) + + override fun visitErrorNamedReference(errorNamedReference: FirErrorNamedReference) = visitNamedReference(errorNamedReference) + + override fun visitSuperReference(superReference: FirSuperReference) = visitReference(superReference) + + override fun visitThisReference(thisReference: FirThisReference) = visitReference(thisReference) + + override fun visitControlFlowGraphReference(controlFlowGraphReference: FirControlFlowGraphReference) = visitReference(controlFlowGraphReference) + + override fun visitResolvedNamedReference(resolvedNamedReference: FirResolvedNamedReference) = visitNamedReference(resolvedNamedReference) + + override fun visitDelegateFieldReference(delegateFieldReference: FirDelegateFieldReference) = visitResolvedNamedReference(delegateFieldReference) + + override fun visitBackingFieldReference(backingFieldReference: FirBackingFieldReference) = visitResolvedNamedReference(backingFieldReference) + + override fun visitResolvedCallableReference(resolvedCallableReference: FirResolvedCallableReference) = visitResolvedNamedReference(resolvedCallableReference) + + override fun visitResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef) = visitTypeRef(resolvedTypeRef) + + override fun visitErrorTypeRef(errorTypeRef: FirErrorTypeRef) = visitResolvedTypeRef(errorTypeRef) + + override fun visitTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability) = visitTypeRef(typeRefWithNullability) + + override fun visitUserTypeRef(userTypeRef: FirUserTypeRef) = visitTypeRefWithNullability(userTypeRef) + + override fun visitDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef) = visitTypeRefWithNullability(dynamicTypeRef) + + override fun visitFunctionTypeRef(functionTypeRef: FirFunctionTypeRef) = visitTypeRefWithNullability(functionTypeRef) + + override fun visitImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef) = visitTypeRef(implicitTypeRef) + + override fun visitEffectDeclaration(effectDeclaration: FirEffectDeclaration) = visitElement(effectDeclaration) + + override fun visitContractDescription(contractDescription: FirContractDescription) = visitElement(contractDescription) + + override fun visitLegacyRawContractDescription(legacyRawContractDescription: FirLegacyRawContractDescription) = visitContractDescription(legacyRawContractDescription) + + override fun visitRawContractDescription(rawContractDescription: FirRawContractDescription) = visitContractDescription(rawContractDescription) + + override fun visitResolvedContractDescription(resolvedContractDescription: FirResolvedContractDescription) = visitContractDescription(resolvedContractDescription) + +} diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitor.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitor.kt deleted file mode 100644 index 4f3caad71a4..00000000000 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitor.kt +++ /dev/null @@ -1,99 +0,0 @@ -/* - * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors. - * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. - */ - -package org.jetbrains.kotlin.fir.visitors - -import org.jetbrains.kotlin.fir.declarations.FirErrorFunction -import org.jetbrains.kotlin.fir.expressions.* -import org.jetbrains.kotlin.fir.references.FirErrorNamedReference -import org.jetbrains.kotlin.fir.types.* - -abstract class FirDefaultVisitor : FirVisitor() { - override fun visitImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: D): R { - return visitTypeRef(implicitTypeRef, data) - } - - override fun visitResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: D): R { - return visitTypeRef(resolvedTypeRef, data) - } - - override fun visitErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: D): R { - return visitResolvedTypeRef(errorTypeRef, data) - } - - override fun visitTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability, data: D): R { - return visitTypeRef(typeRefWithNullability, data) - } - - override fun visitDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: D): R { - return visitTypeRefWithNullability(dynamicTypeRef, data) - } - - override fun visitFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: D): R { - return visitTypeRefWithNullability(functionTypeRef, data) - } - - override fun visitUserTypeRef(userTypeRef: FirUserTypeRef, data: D): R { - return visitTypeRefWithNullability(userTypeRef, data) - } - - override fun visitCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess, data: D): R { - return visitQualifiedAccessExpression(callableReferenceAccess, data) - } - - override fun visitComponentCall(componentCall: FirComponentCall, data: D): R { - return visitFunctionCall(componentCall, data) - } - - override fun visitReturnExpression(returnExpression: FirReturnExpression, data: D): R { - return visitJump(returnExpression, data) - } - - override fun visitContinueExpression(continueExpression: FirContinueExpression, data: D): R { - return visitJump(continueExpression, data) - } - - override fun visitBreakExpression(breakExpression: FirBreakExpression, data: D): R { - return visitJump(breakExpression, data) - } - - - override fun visitLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression, data: D): R { - return visitWrappedArgumentExpression(lambdaArgumentExpression, data) - } - - override fun visitSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression, data: D): R { - return visitWrappedArgumentExpression(spreadArgumentExpression, data) - } - - override fun visitNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression, data: D): R { - return visitWrappedArgumentExpression(namedArgumentExpression, data) - } - - override fun visitErrorExpression(errorExpression: FirErrorExpression, data: D): R { - return visitExpression(errorExpression, data) - } - - override fun visitErrorLoop(errorLoop: FirErrorLoop, data: D): R { - return visitLoop(errorLoop, data) - } - - override fun visitErrorNamedReference(errorNamedReference: FirErrorNamedReference, data: D): R { - return visitNamedReference(errorNamedReference, data) - } - - override fun visitErrorFunction(errorFunction: FirErrorFunction, data: D): R { - return visitFunction(errorFunction, data) - } - - override fun visitErrorResolvedQualifier(errorResolvedQualifier: FirErrorResolvedQualifier, data: D): R { - return visitResolvedQualifier(errorResolvedQualifier, data) - } - - override fun visitImplicitInvokeCall(implicitInvokeCall: FirImplicitInvokeCall, data: D): R { - return visitFunctionCall(implicitInvokeCall, data) - } -} - diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitorVoid.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitorVoid.kt deleted file mode 100644 index 1da0f42a361..00000000000 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitorVoid.kt +++ /dev/null @@ -1,98 +0,0 @@ -/* - * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors. - * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. - */ - -package org.jetbrains.kotlin.fir.visitors - -import org.jetbrains.kotlin.fir.declarations.FirErrorFunction -import org.jetbrains.kotlin.fir.expressions.* -import org.jetbrains.kotlin.fir.references.FirErrorNamedReference -import org.jetbrains.kotlin.fir.types.* - -abstract class FirDefaultVisitorVoid : FirVisitorVoid() { - override fun visitImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef) { - return visitTypeRef(implicitTypeRef) - } - - override fun visitResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef) { - return visitTypeRef(resolvedTypeRef) - } - - override fun visitErrorTypeRef(errorTypeRef: FirErrorTypeRef) { - return visitResolvedTypeRef(errorTypeRef) - } - - override fun visitTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability) { - return visitTypeRef(typeRefWithNullability) - } - - override fun visitDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef) { - return visitTypeRefWithNullability(dynamicTypeRef) - } - - override fun visitFunctionTypeRef(functionTypeRef: FirFunctionTypeRef) { - return visitTypeRefWithNullability(functionTypeRef) - } - - override fun visitUserTypeRef(userTypeRef: FirUserTypeRef) { - return visitTypeRefWithNullability(userTypeRef) - } - - override fun visitCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess) { - return visitQualifiedAccessExpression(callableReferenceAccess) - } - - override fun visitComponentCall(componentCall: FirComponentCall) { - return visitFunctionCall(componentCall) - } - - override fun visitReturnExpression(returnExpression: FirReturnExpression) { - return visitJump(returnExpression) - } - - override fun visitContinueExpression(continueExpression: FirContinueExpression) { - return visitJump(continueExpression) - } - - override fun visitBreakExpression(breakExpression: FirBreakExpression) { - return visitJump(breakExpression) - } - - - override fun visitLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression) { - return visitWrappedArgumentExpression(lambdaArgumentExpression) - } - - override fun visitSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression) { - return visitWrappedArgumentExpression(spreadArgumentExpression) - } - - override fun visitNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression) { - return visitWrappedArgumentExpression(namedArgumentExpression) - } - - override fun visitErrorExpression(errorExpression: FirErrorExpression) { - return visitExpression(errorExpression) - } - - override fun visitErrorLoop(errorLoop: FirErrorLoop) { - return visitLoop(errorLoop) - } - - override fun visitErrorNamedReference(errorNamedReference: FirErrorNamedReference) { - return visitNamedReference(errorNamedReference) - } - - override fun visitErrorFunction(errorFunction: FirErrorFunction) { - return visitFunction(errorFunction) - } - - override fun visitErrorResolvedQualifier(errorResolvedQualifier: FirErrorResolvedQualifier) { - return visitResolvedQualifier(errorResolvedQualifier) - } - - override fun visitImplicitInvokeCall(implicitInvokeCall: FirImplicitInvokeCall) { - return visitFunctionCall(implicitInvokeCall) - } -} diff --git a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/main.kt b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/main.kt index b7d926a5c82..3b01e85f05f 100644 --- a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/main.kt +++ b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/main.kt @@ -27,8 +27,10 @@ fun generateElements(builder: AbstractFirTreeBuilder, generationPath: File): Lis builder.elements.flatMap { it.allImplementations }.mapNotNull { it.builder }.mapTo(generatedFiles) { it.generateCode(generationPath) } builder.intermediateBuilders.mapTo(generatedFiles) { it.generateCode(generationPath) } - generatedFiles += printVisitor(builder.elements, generationPath) + generatedFiles += printVisitor(builder.elements, generationPath, false) generatedFiles += printVisitorVoid(builder.elements, generationPath) + generatedFiles += printVisitor(builder.elements, generationPath, true) + generatedFiles += printDefaultVisitorVoid(builder.elements, generationPath) generatedFiles += printTransformer(builder.elements, generationPath) return generatedFiles } 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 2a5368108ca..35155083019 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 @@ -11,9 +11,10 @@ import org.jetbrains.kotlin.util.SmartPrinter import org.jetbrains.kotlin.util.withIndent import java.io.File -fun printVisitor(elements: List, generationPath: File): GeneratedFile { +fun printVisitor(elements: List, generationPath: File, visitSuperTypeByDefault: Boolean): GeneratedFile { + val className = if (visitSuperTypeByDefault) "FirDefaultVisitor" else "FirVisitor" val dir = File(generationPath, VISITOR_PACKAGE.replace(".", "/")) - val file = File(dir, "FirVisitor.kt") + val file = File(dir, "$className.kt") val stringBuilder = StringBuilder() SmartPrinter(stringBuilder).apply { printCopyright() @@ -23,15 +24,32 @@ fun printVisitor(elements: List, generationPath: File): GeneratedFile { println() printGeneratedMessage() - println("abstract class FirVisitor {") + print("abstract class $className ") + if (visitSuperTypeByDefault) { + print(": FirVisitor() ") + } + println("{") pushIndent() - println("abstract fun visitElement(element: FirElement, data: D): R\n") + if (!visitSuperTypeByDefault) { + println("abstract fun visitElement(element: FirElement, data: D): R\n") + } for (element in elements) { if (element == AbstractFirTreeBuilder.baseFirElement) continue with(element) { val varName = safeDecapitalizedName - println("open fun ${typeParameters}visit$name($varName: $typeWithArguments, data: D): R${multipleUpperBoundsList()} = visitElement($varName, data)") + if (visitSuperTypeByDefault) { + print("override") + } else { + print("open") + } + print(" fun ${typeParameters}visit$name($varName: $typeWithArguments, data: D): R${multipleUpperBoundsList()} = visit") + if (visitSuperTypeByDefault) { + print(parents.first().name) + } else { + print("Element") + } + println("($varName, data)") println() } } @@ -88,3 +106,33 @@ fun printVisitorVoid(elements: List, generationPath: File): GeneratedFi } return GeneratedFile(file, stringBuilder.toString()) } + +fun printDefaultVisitorVoid(elements: List, generationPath: File): GeneratedFile { + val className = "FirDefaultVisitorVoid" + val dir = File(generationPath, VISITOR_PACKAGE.replace(".", "/")) + val file = File(dir, "$className.kt") + val stringBuilder = StringBuilder() + SmartPrinter(stringBuilder).apply { + printCopyright() + println("package $VISITOR_PACKAGE") + println() + elements.forEach { println("import ${it.fullQualifiedName}") } + println() + printGeneratedMessage() + + println("abstract class $className : FirVisitorVoid() {") + + pushIndent() + for (element in elements) { + if (element == AbstractFirTreeBuilder.baseFirElement) continue + with(element) { + val varName = safeDecapitalizedName + println("override fun ${typeParameters}visit$name($varName: $typeWithArguments)${multipleUpperBoundsList()} = visit${parents.first().name}($varName)") + println() + } + } + popIndent() + println("}") + } + return GeneratedFile(file, stringBuilder.toString()) +}