From 16ead499675f6755b17022640dc4e42e1d949a13 Mon Sep 17 00:00:00 2001 From: Mikhail Glukhikh Date: Mon, 17 Jun 2019 16:59:48 +0300 Subject: [PATCH] FIR: implement backing field references via 'field' synthetic variable --- .../transformers/FirBodyResolveTransformer.kt | 64 ++++++++++++++----- .../kotlin/fir/scopes/impl/FirLocalScope.kt | 6 ++ .../testData/resolve/stdlib/backingField.kt | 7 ++ .../testData/resolve/stdlib/backingField.txt | 8 +++ .../testData/resolve/stdlib/hashSet.kt | 13 ++++ .../testData/resolve/stdlib/hashSet.txt | 12 ++++ ...FirResolveTestCaseWithStdlibGenerated.java | 10 +++ .../kotlin/fir/FirBackingFieldReference.kt | 26 ++++++++ .../org/jetbrains/kotlin/fir/FirRenderer.kt | 6 ++ .../kotlin/fir/declarations/FirProperty.kt | 6 ++ .../impl/FirMemberPropertyImpl.kt | 22 +++++-- .../FirBackingFieldReferenceImpl.kt | 18 ++++++ .../fir/symbols/impl/FirPropertySymbol.kt | 2 + .../fir/visitors/FirTransformerGenerated.kt | 8 +++ .../fir/visitors/FirVisitorGenerated.kt | 4 ++ .../fir/visitors/FirVisitorVoidGenerated.kt | 8 +++ 16 files changed, 199 insertions(+), 21 deletions(-) create mode 100644 compiler/fir/resolve/testData/resolve/stdlib/backingField.kt create mode 100644 compiler/fir/resolve/testData/resolve/stdlib/backingField.txt create mode 100644 compiler/fir/resolve/testData/resolve/stdlib/hashSet.kt create mode 100644 compiler/fir/resolve/testData/resolve/stdlib/hashSet.txt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirBackingFieldReference.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirBackingFieldReferenceImpl.kt diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirBodyResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirBodyResolveTransformer.kt index 2a349f3af9d..12c33b0a702 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirBodyResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirBodyResolveTransformer.kt @@ -13,6 +13,7 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor import org.jetbrains.kotlin.fir.declarations.impl.FirValueParameterImpl import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.expressions.impl.FirResolvedQualifierImpl +import org.jetbrains.kotlin.fir.references.FirBackingFieldReferenceImpl import org.jetbrains.kotlin.fir.references.FirErrorNamedReference import org.jetbrains.kotlin.fir.references.FirSimpleNamedReference import org.jetbrains.kotlin.fir.resolve.* @@ -24,6 +25,7 @@ import org.jetbrains.kotlin.fir.scopes.impl.FirLocalScope import org.jetbrains.kotlin.fir.scopes.impl.FirTopLevelDeclaredMemberScope import org.jetbrains.kotlin.fir.scopes.impl.withReplacedConeType import org.jetbrains.kotlin.fir.symbols.* +import org.jetbrains.kotlin.fir.symbols.impl.FirBackingFieldSymbol import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.types.impl.* import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult @@ -723,24 +725,29 @@ open class FirBodyResolveTransformer(val session: FirSession, val implicitTypeOn applicability: CandidateApplicability ): FirNamedReference { val name = namedReference.name + val firSession = namedReference.session + val psi = namedReference.psi return when { candidates.isEmpty() -> FirErrorNamedReference( - namedReference.session, namedReference.psi, "Unresolved name: $name" + firSession, psi, "Unresolved name: $name" ) applicability < CandidateApplicability.SYNTHETIC_RESOLVED -> { FirErrorNamedReference( - namedReference.session, - namedReference.psi, + firSession, psi, "Inapplicable($applicability): ${candidates.map { describeSymbol(it.symbol) }}", namedReference.name ) } - candidates.size == 1 -> FirNamedReferenceWithCandidate( - namedReference.session, namedReference.psi, - name, candidates.single() - ) + candidates.size == 1 -> { + val candidate = candidates.single() + if (candidate.symbol is FirBackingFieldSymbol) { + FirBackingFieldReferenceImpl(firSession, psi, candidate.symbol) + } else { + FirNamedReferenceWithCandidate(firSession, psi, name, candidate) + } + } else -> FirErrorNamedReference( - namedReference.session, namedReference.psi, "Ambiguity: $name, ${candidates.map { describeSymbol(it.symbol) }}", + firSession, psi, "Ambiguity: $name, ${candidates.map { describeSymbol(it.symbol) }}", namedReference.name ) } @@ -845,15 +852,20 @@ open class FirBodyResolveTransformer(val session: FirSession, val implicitTypeOn replaceTypeRef(type) } - - override fun transformDeclaration(declaration: FirDeclaration, data: Any?): CompositeTransformResult { + private fun withContainer(declaration: FirDeclaration, f: () -> T): T { val prevContainer = container container = declaration - val result = super.transformDeclaration(declaration, data) + val result = f() container = prevContainer return result } + override fun transformDeclaration(declaration: FirDeclaration, data: Any?): CompositeTransformResult { + return withContainer(declaration) { + super.transformDeclaration(declaration, data) + } + } + override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: Any?): CompositeTransformResult { annotationCall.resultType = annotationCall.annotationTypeRef return (annotationCall.transformChildren(this, data) as FirStatement).compose() @@ -890,8 +902,7 @@ open class FirBodyResolveTransformer(val session: FirSession, val implicitTypeOn } } - override fun transformVariable(variable: FirVariable, data: Any?): CompositeTransformResult { - val variable = super.transformVariable(variable, variable.returnTypeRef).single as FirVariable + private fun storeVariableReturnType(variable: FirVariable) { val initializer = variable.initializer if (variable.returnTypeRef is FirImplicitTypeRef) { when { @@ -937,6 +948,11 @@ open class FirBodyResolveTransformer(val session: FirSession, val implicitTypeOn } } } + } + + override fun transformVariable(variable: FirVariable, data: Any?): CompositeTransformResult { + val variable = super.transformVariable(variable, variable.returnTypeRef).single as FirVariable + storeVariableReturnType(variable) if (variable !is FirProperty) { localScopes.lastOrNull()?.storeDeclaration(variable) } @@ -944,12 +960,26 @@ open class FirBodyResolveTransformer(val session: FirSession, val implicitTypeOn } override fun transformProperty(property: FirProperty, data: Any?): CompositeTransformResult { - if (property.returnTypeRef !is FirImplicitTypeRef && implicitTypeOnly) return property.compose() + val returnTypeRef = property.returnTypeRef + if (returnTypeRef !is FirImplicitTypeRef && implicitTypeOnly) return property.compose() return withScopeCleanup(localScopes) { localScopes.addIfNotNull(primaryConstructorParametersScope) - (transformVariable(property, data).single as FirProperty).apply { - setter?.let { it.valueParameters[0].transformReturnTypeRef(StoreType, property.returnTypeRef) } - }.compose() + withContainer(property) { + property.transformChildrenWithoutAccessors(this, returnTypeRef) + storeVariableReturnType(property) + withScopeCleanup(localScopes) { + localScopes.add(FirLocalScope().apply { + storeBackingField(property) + }) + val enhancedTypeRef = property.returnTypeRef + property.getter.transform(this, enhancedTypeRef) + property.setter?.let { + it.transform(this, enhancedTypeRef) + it.valueParameters[0].transformReturnTypeRef(StoreType, enhancedTypeRef) + } + } + } + property.compose() } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirLocalScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirLocalScope.kt index 370a494dfb4..9a5ecea5c89 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirLocalScope.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirLocalScope.kt @@ -5,8 +5,10 @@ package org.jetbrains.kotlin.fir.scopes.impl +import org.jetbrains.kotlin.fir.FirBackingFieldReference import org.jetbrains.kotlin.fir.declarations.FirNamedDeclaration import org.jetbrains.kotlin.fir.declarations.FirNamedFunction +import org.jetbrains.kotlin.fir.declarations.FirProperty import org.jetbrains.kotlin.fir.expressions.FirVariable import org.jetbrains.kotlin.fir.scopes.FirScope import org.jetbrains.kotlin.fir.scopes.ProcessorAction @@ -27,6 +29,10 @@ class FirLocalScope : FirScope() { } } + fun storeBackingField(property: FirProperty) { + properties[FirBackingFieldReference.NAME] = property.backingFieldSymbol + } + override fun processFunctionsByName(name: Name, processor: (ConeFunctionSymbol) -> ProcessorAction): ProcessorAction { val prop = functions[name] if (prop != null) { diff --git a/compiler/fir/resolve/testData/resolve/stdlib/backingField.kt b/compiler/fir/resolve/testData/resolve/stdlib/backingField.kt new file mode 100644 index 00000000000..b3dbfc9ff68 --- /dev/null +++ b/compiler/fir/resolve/testData/resolve/stdlib/backingField.kt @@ -0,0 +1,7 @@ +var myProperty = listOf(1, 2, 3) + get() { + return field + field + } + set(param) { + field = param + } \ No newline at end of file diff --git a/compiler/fir/resolve/testData/resolve/stdlib/backingField.txt b/compiler/fir/resolve/testData/resolve/stdlib/backingField.txt new file mode 100644 index 00000000000..f946915c4b9 --- /dev/null +++ b/compiler/fir/resolve/testData/resolve/stdlib/backingField.txt @@ -0,0 +1,8 @@ +FILE: backingField.kt + public final var myProperty: R|kotlin/collections/List| = R|kotlin/collections/listOf|(Int(1), Int(2), Int(3)) + public get(): R|kotlin/collections/List| { + ^ F|/myProperty|.R|kotlin/collections/plus|(F|/myProperty|) + } + public set(param: R|kotlin/collections/List|): R|kotlin/Unit| { + F|/myProperty| = R|/param| + } diff --git a/compiler/fir/resolve/testData/resolve/stdlib/hashSet.kt b/compiler/fir/resolve/testData/resolve/stdlib/hashSet.kt new file mode 100644 index 00000000000..1d231c2ab24 --- /dev/null +++ b/compiler/fir/resolve/testData/resolve/stdlib/hashSet.kt @@ -0,0 +1,13 @@ +import java.util.HashSet + +val a: MutableSet? = HashSet() + +var b: MutableSet? = null + set(_) { + field = HashSet() + } + +fun foo() { + var c: MutableSet? = null + c = HashSet() +} \ No newline at end of file diff --git a/compiler/fir/resolve/testData/resolve/stdlib/hashSet.txt b/compiler/fir/resolve/testData/resolve/stdlib/hashSet.txt new file mode 100644 index 00000000000..ca80d3e7ee9 --- /dev/null +++ b/compiler/fir/resolve/testData/resolve/stdlib/hashSet.txt @@ -0,0 +1,12 @@ +FILE: hashSet.kt + public final val a: R|kotlin/collections/MutableSet|? = R|java/util/HashSet.HashSet|() + public get(): R|kotlin/collections/MutableSet|? + public final var b: R|kotlin/collections/MutableSet|? = Null(null) + public get(): R|kotlin/collections/MutableSet|? + public set(_: R|kotlin/collections/MutableSet|?): R|kotlin/Unit| { + F|/b| = R|java/util/HashSet.HashSet|() + } + public final fun foo(): R|kotlin/Unit| { + lvar c: R|kotlin/collections/MutableSet|? = Null(null) + R|/c| = R|java/util/HashSet.HashSet|() + } diff --git a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirResolveTestCaseWithStdlibGenerated.java b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirResolveTestCaseWithStdlibGenerated.java index 08c86d070bb..24c2c868f09 100644 --- a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirResolveTestCaseWithStdlibGenerated.java +++ b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirResolveTestCaseWithStdlibGenerated.java @@ -34,6 +34,11 @@ public class FirResolveTestCaseWithStdlibGenerated extends AbstractFirResolveTes runTest("compiler/fir/resolve/testData/resolve/stdlib/arrayFirstOrNull.kt"); } + @TestMetadata("backingField.kt") + public void testBackingField() throws Exception { + runTest("compiler/fir/resolve/testData/resolve/stdlib/backingField.kt"); + } + @TestMetadata("companionLoad.kt") public void testCompanionLoad() throws Exception { runTest("compiler/fir/resolve/testData/resolve/stdlib/companionLoad.kt"); @@ -64,6 +69,11 @@ public class FirResolveTestCaseWithStdlibGenerated extends AbstractFirResolveTes runTest("compiler/fir/resolve/testData/resolve/stdlib/functionX.kt"); } + @TestMetadata("hashSet.kt") + public void testHashSet() throws Exception { + runTest("compiler/fir/resolve/testData/resolve/stdlib/hashSet.kt"); + } + @TestMetadata("helloWorld.kt") public void testHelloWorld() throws Exception { runTest("compiler/fir/resolve/testData/resolve/stdlib/helloWorld.kt"); diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirBackingFieldReference.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirBackingFieldReference.kt new file mode 100644 index 00000000000..e5cf307f463 --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirBackingFieldReference.kt @@ -0,0 +1,26 @@ +/* + * 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 + +import org.jetbrains.kotlin.fir.symbols.impl.FirBackingFieldSymbol +import org.jetbrains.kotlin.fir.visitors.FirVisitor +import org.jetbrains.kotlin.name.Name + +interface FirBackingFieldReference : FirResolvedCallableReference { + + override val name: Name + get() = NAME + + override val coneSymbol: FirBackingFieldSymbol + + override fun accept(visitor: FirVisitor, data: D): R { + return visitor.visitBackingFieldReference(this, data) + } + + companion object { + val NAME = Name.identifier("field") + } +} \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt index 13ad60446a2..abc950cb27d 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt @@ -786,6 +786,12 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() { } } + override fun visitBackingFieldReference(backingFieldReference: FirBackingFieldReference) { + print("F|") + print(backingFieldReference.coneSymbol.callableId) + print("|") + } + override fun visitResolvedCallableReference(resolvedCallableReference: FirResolvedCallableReference) { print("R|") val isFakeOverride = (resolvedCallableReference.coneSymbol as? FirFunctionSymbol)?.isFakeOverride == true diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirProperty.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirProperty.kt index 48c9d50ea44..d21aae15132 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirProperty.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirProperty.kt @@ -8,6 +8,8 @@ package org.jetbrains.kotlin.fir.declarations import org.jetbrains.kotlin.fir.BaseTransformedType import org.jetbrains.kotlin.fir.VisitedSupertype import org.jetbrains.kotlin.fir.expressions.FirVariable +import org.jetbrains.kotlin.fir.symbols.impl.FirBackingFieldSymbol +import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.fir.visitors.FirVisitor // May be should not inherit FirVariable @@ -24,6 +26,10 @@ interface FirProperty : @VisitedSupertype FirDeclaration, FirCallableMemberDecla val setter: FirPropertyAccessor? + val backingFieldSymbol: FirBackingFieldSymbol + + fun transformChildrenWithoutAccessors(transformer: FirTransformer, data: D) + override fun accept(visitor: FirVisitor, data: D): R = visitor.visitProperty(this, data) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirMemberPropertyImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirMemberPropertyImpl.kt index 7252d3059f2..3ef2bb43b2a 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirMemberPropertyImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirMemberPropertyImpl.kt @@ -13,7 +13,9 @@ import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirProperty import org.jetbrains.kotlin.fir.declarations.FirPropertyAccessor import org.jetbrains.kotlin.fir.expressions.FirExpression +import org.jetbrains.kotlin.fir.symbols.impl.FirBackingFieldSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol +import org.jetbrains.kotlin.fir.transformInplace import org.jetbrains.kotlin.fir.transformSingle import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.visitors.FirTransformer @@ -41,18 +43,30 @@ class FirMemberPropertyImpl( ) : FirAbstractCallableMember( session, psi, name, visibility, modality, isExpect, isActual, isOverride, receiverTypeRef, returnTypeRef ), FirProperty { + override val backingFieldSymbol = FirBackingFieldSymbol(symbol.callableId) + init { symbol.bind(this) + backingFieldSymbol.bind(this) status.isConst = isConst status.isLateInit = isLateInit } + override fun transformChildrenWithoutAccessors(transformer: FirTransformer, data: D) { + initializer = initializer?.transformSingle(transformer, data) + delegate = delegate?.transformSingle(transformer, data) + receiverTypeRef = receiverTypeRef?.transformSingle(transformer, data) + returnTypeRef = returnTypeRef.transformSingle(transformer, data) + typeParameters.transformInplace(transformer, data) + status = status.transformSingle(transformer, data) + annotations.transformInplace(transformer, data) + } + override fun transformChildren(transformer: FirTransformer, data: D): FirElement { getter = getter.transformSingle(transformer, data) setter = setter?.transformSingle(transformer, data) - initializer = initializer?.transformSingle(transformer, data) - delegate = delegate?.transformSingle(transformer, data) - - return super.transformChildren(transformer, data) + transformChildrenWithoutAccessors(transformer, data) + // Everything other (annotations, etc.) is done above + return this } } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirBackingFieldReferenceImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirBackingFieldReferenceImpl.kt new file mode 100644 index 00000000000..4322ab1fd3a --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirBackingFieldReferenceImpl.kt @@ -0,0 +1,18 @@ +/* + * 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.references + +import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.fir.FirAbstractElement +import org.jetbrains.kotlin.fir.FirBackingFieldReference +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.symbols.impl.FirBackingFieldSymbol + +class FirBackingFieldReferenceImpl( + session: FirSession, + psi: PsiElement?, + override val coneSymbol: FirBackingFieldSymbol +) : FirAbstractElement(session, psi), FirBackingFieldReference \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirPropertySymbol.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirPropertySymbol.kt index f2a7c5c4cc9..69dd5c0910d 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirPropertySymbol.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirPropertySymbol.kt @@ -12,6 +12,8 @@ import org.jetbrains.kotlin.name.Name open class FirPropertySymbol(callableId: CallableId) : FirVariableSymbol(callableId), ConePropertySymbol +class FirBackingFieldSymbol(callableId: CallableId) : FirVariableSymbol(callableId) + open class FirVariableSymbol(override val callableId: CallableId) : ConeVariableSymbol, FirCallableSymbol() { @Deprecated("TODO: Better solution for local vars?") diff --git a/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirTransformerGenerated.kt b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirTransformerGenerated.kt index d49a4c5d14d..510fa142a29 100644 --- a/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirTransformerGenerated.kt +++ b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirTransformerGenerated.kt @@ -160,6 +160,10 @@ abstract class FirTransformer : FirVisitor { + return transformResolvedCallableReference(backingFieldReference, data) + } + open fun transformSuperReference(superReference: E, data: D): CompositeTransformResult { return transformReference(superReference, data) } @@ -464,6 +468,10 @@ abstract class FirTransformer : FirVisitor { + return transformBackingFieldReference(backingFieldReference, data) + } + final override fun visitBlock(block: FirBlock, data: D): CompositeTransformResult { return transformBlock(block, data) } diff --git a/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorGenerated.kt b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorGenerated.kt index 00f56e7eebf..28435ed25ca 100644 --- a/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorGenerated.kt +++ b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorGenerated.kt @@ -160,6 +160,10 @@ abstract class FirVisitor { return visitNamedReference(resolvedCallableReference, data) } + open fun visitBackingFieldReference(backingFieldReference: FirBackingFieldReference, data: D): R { + return visitResolvedCallableReference(backingFieldReference, data) + } + open fun visitSuperReference(superReference: FirSuperReference, data: D): R { return visitReference(superReference, data) } diff --git a/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorVoidGenerated.kt b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorVoidGenerated.kt index e197510a61b..09e42f02cf7 100644 --- a/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorVoidGenerated.kt +++ b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorVoidGenerated.kt @@ -160,6 +160,10 @@ abstract class FirVisitorVoid : FirVisitor() { visitNamedReference(resolvedCallableReference, null) } + open fun visitBackingFieldReference(backingFieldReference: FirBackingFieldReference) { + visitResolvedCallableReference(backingFieldReference, null) + } + open fun visitSuperReference(superReference: FirSuperReference) { visitReference(superReference, null) } @@ -464,6 +468,10 @@ abstract class FirVisitorVoid : FirVisitor() { visitAssignment(assignment) } + final override fun visitBackingFieldReference(backingFieldReference: FirBackingFieldReference, data: Nothing?) { + visitBackingFieldReference(backingFieldReference) + } + final override fun visitBlock(block: FirBlock, data: Nothing?) { visitBlock(block) }