From 154ceaa89fa4f792625e578ab61bbf9ad6568375 Mon Sep 17 00:00:00 2001 From: Tianyu Geng Date: Wed, 29 Sep 2021 10:22:00 -0700 Subject: [PATCH] FIR: Make default visitor only visit single parent --- .../AbstractDiagnosticCollectorVisitor.kt | 4 + .../kotlin/fir/visitors/FirDefaultVisitor.kt | 124 ------------------ .../fir/visitors/FirDefaultVisitorVoid.kt | 124 ------------------ .../fir/tree/generator/printer/visitor.kt | 8 +- 4 files changed, 9 insertions(+), 251 deletions(-) diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/AbstractDiagnosticCollectorVisitor.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/AbstractDiagnosticCollectorVisitor.kt index 1376cb2758b..1efed235b4d 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/AbstractDiagnosticCollectorVisitor.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/AbstractDiagnosticCollectorVisitor.kt @@ -172,6 +172,10 @@ abstract class AbstractDiagnosticCollectorVisitor( } } + override fun visitErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: Nothing?) { + visitResolvedTypeRef(errorTypeRef, data) + } + override fun visitResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: Nothing?) { // Assuming no errors, the children of FirResolvedTypeRef (currently this can be FirAnnotationCalls) will also be present // as children in delegatedTypeRef. We should make sure those elements are only visited once, otherwise diagnostics will be diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitor.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitor.kt index 84487a42b03..90c8327a225 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitor.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitor.kt @@ -144,102 +144,32 @@ import org.jetbrains.kotlin.fir.contracts.FirResolvedContractDescription */ 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) @@ -256,68 +186,28 @@ abstract class FirDefaultVisitor : FirVisitor() { 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) @@ -332,8 +222,6 @@ abstract class FirDefaultVisitor : FirVisitor() { 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) @@ -348,14 +236,10 @@ abstract class FirDefaultVisitor : FirVisitor() { 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) @@ -366,8 +250,6 @@ abstract class FirDefaultVisitor : FirVisitor() { 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) @@ -384,8 +266,6 @@ abstract class FirDefaultVisitor : FirVisitor() { 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) @@ -396,10 +276,6 @@ abstract class FirDefaultVisitor : FirVisitor() { 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) 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 index 3dd364000a1..419a1396757 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitorVoid.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitorVoid.kt @@ -144,102 +144,32 @@ import org.jetbrains.kotlin.fir.contracts.FirResolvedContractDescription */ 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) @@ -256,68 +186,28 @@ abstract class FirDefaultVisitorVoid : FirVisitorVoid() { 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) @@ -332,8 +222,6 @@ abstract class FirDefaultVisitorVoid : FirVisitorVoid() { 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) @@ -348,14 +236,10 @@ abstract class FirDefaultVisitorVoid : FirVisitorVoid() { 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) @@ -366,8 +250,6 @@ abstract class FirDefaultVisitorVoid : FirVisitorVoid() { 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) @@ -384,8 +266,6 @@ abstract class FirDefaultVisitorVoid : FirVisitorVoid() { 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) @@ -396,10 +276,6 @@ abstract class FirDefaultVisitorVoid : FirVisitorVoid() { 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) 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 35155083019..3fccbf4b63c 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 @@ -35,7 +35,9 @@ fun printVisitor(elements: List, generationPath: File, visitSuperTypeBy println("abstract fun visitElement(element: FirElement, data: D): R\n") } for (element in elements) { - if (element == AbstractFirTreeBuilder.baseFirElement) continue + if (element == AbstractFirTreeBuilder.baseFirElement || + visitSuperTypeByDefault && (element.parents.size != 1 || element.parents.single().name == "Element") + ) continue with(element) { val varName = safeDecapitalizedName if (visitSuperTypeByDefault) { @@ -45,7 +47,7 @@ fun printVisitor(elements: List, generationPath: File, visitSuperTypeBy } print(" fun ${typeParameters}visit$name($varName: $typeWithArguments, data: D): R${multipleUpperBoundsList()} = visit") if (visitSuperTypeByDefault) { - print(parents.first().name) + print(parents.single().name) } else { print("Element") } @@ -124,7 +126,7 @@ fun printDefaultVisitorVoid(elements: List, generationPath: File): Gene pushIndent() for (element in elements) { - if (element == AbstractFirTreeBuilder.baseFirElement) continue + if (element == AbstractFirTreeBuilder.baseFirElement || element.parents.size != 1 || element.parents.single().name == "Element") continue with(element) { val varName = safeDecapitalizedName println("override fun ${typeParameters}visit$name($varName: $typeWithArguments)${multipleUpperBoundsList()} = visit${parents.first().name}($varName)")