FIR: convert some hot void visitors to any

reduces call indirection (Nothing -> Void bridges) and therefore
callstack depth

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/AbstractDiagnosticCollector.kt

@@ -65,7 +65,7 @@ abstract class AbstractDiagnosticCollector(
     protected open fun beforeRunningAllComponentsOnElement(element: FirElement) {}
     protected open fun beforeRunningSingleComponentOnElement(element: FirElement) {}
 
-    private inner class Visitor : FirDefaultVisitor<Unit, Nothing?>() {
+    private inner class Visitor : FirDefaultVisitor<Unit, Any?>() {
         private fun <T : FirElement> T.runComponents() {
             if (currentAction.checkInCurrentDeclaration) {
                 beforeRunningAllComponentsOnElement(this)
@@ -76,7 +76,7 @@ abstract class AbstractDiagnosticCollector(
             }
         }
 
-        override fun visitElement(element: FirElement, data: Nothing?) {
+        override fun visitElement(element: FirElement, data: Any?) {
             if (element is FirAnnotationContainer) {
                 visitAnnotationContainer(element, data)
                 return
@@ -85,7 +85,7 @@ abstract class AbstractDiagnosticCollector(
             element.acceptChildren(this, null)
         }
 
-        override fun visitAnnotationContainer(annotationContainer: FirAnnotationContainer, data: Nothing?) {
+        override fun visitAnnotationContainer(annotationContainer: FirAnnotationContainer, data: Any?) {
             withSuppressedDiagnostics(annotationContainer) {
                 annotationContainer.runComponents()
                 annotationContainer.acceptChildren(this, null)
@@ -99,11 +99,11 @@ abstract class AbstractDiagnosticCollector(
             }
         }
 
-        override fun visitBreakExpression(breakExpression: FirBreakExpression, data: Nothing?) {
+        override fun visitBreakExpression(breakExpression: FirBreakExpression, data: Any?) {
             visitJump(breakExpression)
         }
 
-        override fun visitContinueExpression(continueExpression: FirContinueExpression, data: Nothing?) {
+        override fun visitContinueExpression(continueExpression: FirContinueExpression, data: Any?) {
             visitJump(continueExpression)
         }
 
@@ -114,31 +114,31 @@ abstract class AbstractDiagnosticCollector(
             visitWithDeclarationAndReceiver(klass, (klass as? FirRegularClass)?.name, typeRef)
         }
 
-        override fun visitRegularClass(regularClass: FirRegularClass, data: Nothing?) {
+        override fun visitRegularClass(regularClass: FirRegularClass, data: Any?) {
             withSuppressedDiagnostics(regularClass) {
                 visitClassAndChildren(regularClass, regularClass.defaultType())
             }
         }
 
-        override fun visitAnonymousObject(anonymousObject: FirAnonymousObject, data: Nothing?) {
+        override fun visitAnonymousObject(anonymousObject: FirAnonymousObject, data: Any?) {
             withSuppressedDiagnostics(anonymousObject) {
                 visitClassAndChildren(anonymousObject, anonymousObject.defaultType())
             }
         }
 
-        override fun visitSimpleFunction(simpleFunction: FirSimpleFunction, data: Nothing?) {
+        override fun visitSimpleFunction(simpleFunction: FirSimpleFunction, data: Any?) {
             withSuppressedDiagnostics(simpleFunction) {
                 visitWithDeclarationAndReceiver(simpleFunction, simpleFunction.name, simpleFunction.receiverTypeRef)
             }
         }
 
-        override fun visitConstructor(constructor: FirConstructor, data: Nothing?) {
+        override fun visitConstructor(constructor: FirConstructor, data: Any?) {
             withSuppressedDiagnostics(constructor) {
                 visitWithDeclaration(constructor)
             }
         }
 
-        override fun visitAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: Nothing?) {
+        override fun visitAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: Any?) {
             withSuppressedDiagnostics(anonymousFunction) {
                 val labelName = anonymousFunction.label?.name?.let { Name.identifier(it) }
                 visitWithDeclarationAndReceiver(
@@ -149,13 +149,13 @@ abstract class AbstractDiagnosticCollector(
             }
         }
 
-        override fun visitProperty(property: FirProperty, data: Nothing?) {
+        override fun visitProperty(property: FirProperty, data: Any?) {
             withSuppressedDiagnostics(property) {
                 visitWithDeclaration(property)
             }
         }
 
-        override fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: Nothing?) {
+        override fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: Any?) {
             if (propertyAccessor !is FirDefaultPropertyAccessor) {
                 val property = context.containingDeclarations.last() as FirProperty
                 withSuppressedDiagnostics(propertyAccessor) {
@@ -164,35 +164,35 @@ abstract class AbstractDiagnosticCollector(
             }
         }
 
-        override fun visitValueParameter(valueParameter: FirValueParameter, data: Nothing?) {
+        override fun visitValueParameter(valueParameter: FirValueParameter, data: Any?) {
             withSuppressedDiagnostics(valueParameter) {
                 visitWithDeclaration(valueParameter)
             }
         }
 
-        override fun visitEnumEntry(enumEntry: FirEnumEntry, data: Nothing?) {
+        override fun visitEnumEntry(enumEntry: FirEnumEntry, data: Any?) {
             withSuppressedDiagnostics(enumEntry) {
                 visitWithDeclaration(enumEntry)
             }
         }
 
-        override fun visitFile(file: FirFile, data: Nothing?) {
+        override fun visitFile(file: FirFile, data: Any?) {
             withSuppressedDiagnostics(file) {
                 visitWithDeclaration(file)
             }
         }
 
-        override fun visitAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, data: Nothing?) {
+        override fun visitAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, data: Any?) {
             visitWithDeclaration(anonymousInitializer)
         }
 
-        override fun visitBlock(block: FirBlock, data: Nothing?) {
+        override fun visitBlock(block: FirBlock, data: Any?) {
             withSuppressedDiagnostics(block) {
                 visitExpression(block, data)
             }
         }
 
-        override fun visitTypeRef(typeRef: FirTypeRef, data: Nothing?) {
+        override fun visitTypeRef(typeRef: FirTypeRef, data: Any?) {
             if (typeRef.source != null && typeRef.source?.kind !is FirFakeSourceElementKind) {
                 withSuppressedDiagnostics(typeRef) {
                     typeRef.runComponents()
@@ -201,20 +201,20 @@ abstract class AbstractDiagnosticCollector(
             }
         }
 
-        override fun visitResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: Nothing?) {
+        override fun visitResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: Any?) {
             super.visitResolvedTypeRef(resolvedTypeRef, data)
             resolvedTypeRef.delegatedTypeRef?.accept(this, data)
         }
 
-        override fun visitFunctionCall(functionCall: FirFunctionCall, data: Nothing?) {
+        override fun visitFunctionCall(functionCall: FirFunctionCall, data: Any?) {
             visitWithQualifiedAccess(functionCall)
         }
 
-        override fun visitQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression, data: Nothing?) {
+        override fun visitQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression, data: Any?) {
             visitWithQualifiedAccess(qualifiedAccessExpression)
         }
 
-        override fun visitGetClassCall(getClassCall: FirGetClassCall, data: Nothing?) {
+        override fun visitGetClassCall(getClassCall: FirGetClassCall, data: Any?) {
             visitWithGetClassCall(getClassCall)
         }
 

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/signaturer/FirBasedSignatureComposer.kt

@@ -10,12 +10,12 @@ import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.backend.Fir2IrSignatureComposer
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
-import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
 import org.jetbrains.kotlin.ir.util.IdSignature
 
 @NoMutableState
 class FirBasedSignatureComposer(private val mangler: FirMangler) : Fir2IrSignatureComposer {
-    inner class SignatureBuilder : FirVisitorVoid() {
+    inner class SignatureBuilder : FirVisitor<Unit, Any?>() {
         var hashId: Long? = null
         var mask = 0L
 
@@ -23,35 +23,35 @@ class FirBasedSignatureComposer(private val mangler: FirMangler) : Fir2IrSignatu
             mask = mask or IdSignature.Flags.IS_EXPECT.encode(f)
         }
 
-        override fun visitElement(element: FirElement) {
+        override fun visitElement(element: FirElement, data: Any?) {
             TODO("Should not be here")
         }
 
-        override fun visitRegularClass(regularClass: FirRegularClass) {
+        override fun visitRegularClass(regularClass: FirRegularClass, data: Any?) {
             setExpected(regularClass.isExpect)
             //platformSpecificClass(descriptor)
         }
 
-        override fun visitTypeAlias(typeAlias: FirTypeAlias) {
+        override fun visitTypeAlias(typeAlias: FirTypeAlias, data: Any?) {
             setExpected(typeAlias.isExpect)
         }
 
-        override fun visitConstructor(constructor: FirConstructor) {
+        override fun visitConstructor(constructor: FirConstructor, data: Any?) {
             hashId = mangler.run { constructor.signatureMangle }
             setExpected(constructor.isExpect)
         }
 
-        override fun visitSimpleFunction(simpleFunction: FirSimpleFunction) {
+        override fun visitSimpleFunction(simpleFunction: FirSimpleFunction, data: Any?) {
             hashId = mangler.run { simpleFunction.signatureMangle }
             setExpected(simpleFunction.isExpect)
         }
 
-        override fun visitProperty(property: FirProperty) {
+        override fun visitProperty(property: FirProperty, data: Any?) {
             hashId = mangler.run { property.signatureMangle }
             setExpected(property.isExpect)
         }
 
-        override fun visitEnumEntry(enumEntry: FirEnumEntry) {
+        override fun visitEnumEntry(enumEntry: FirEnumEntry, data: Any?) {
             setExpected(enumEntry.isExpect)
         }
     }
@@ -65,7 +65,7 @@ class FirBasedSignatureComposer(private val mangler: FirMangler) : Fir2IrSignatu
         }
         val builder = SignatureBuilder()
         try {
-            declaration.accept(builder)
+            declaration.accept(builder, null)
         } catch (t: Throwable) {
             throw IllegalStateException("Error while composing signature for ${declaration.render()}", t)
         }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/declarations/GeneratedDeclarationValidation.kt

@@ -14,10 +14,10 @@ import org.jetbrains.kotlin.fir.references.FirNamedReference
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.FirTypeRef
-import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitorVoid
+import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitor
 
 fun FirElement.validate() {
-    accept(FirGeneratedElementsValidator)
+    accept(FirGeneratedElementsValidator, null)
 }
 
 /*
@@ -25,44 +25,44 @@ fun FirElement.validate() {
  *  - add proper error messages to all `require`
  *  - add validation of declaration origin and resolve phase for all declarations
  */
-object FirGeneratedElementsValidator : FirDefaultVisitorVoid() {
+object FirGeneratedElementsValidator : FirDefaultVisitor<Unit, Any?>() {
-    override fun visitElement(element: FirElement) {
+    override fun visitElement(element: FirElement, data: Any?) {
-        element.acceptChildren(this)
+        element.acceptChildren(this, null)
     }
 
-    override fun visitAnnotationCall(annotationCall: FirAnnotationCall) {
+    override fun visitAnnotationCall(annotationCall: FirAnnotationCall, data: Any?) {
         require(annotationCall.resolveStatus == FirAnnotationResolveStatus.Resolved)
-        annotationCall.acceptChildren(this)
+        annotationCall.acceptChildren(this, null)
     }
 
-    override fun visitRegularClass(regularClass: FirRegularClass) {
+    override fun visitRegularClass(regularClass: FirRegularClass, data: Any?) {
-        regularClass.acceptChildren(this)
+        regularClass.acceptChildren(this, null)
     }
 
-    override fun visitArgumentList(argumentList: FirArgumentList) {
+    override fun visitArgumentList(argumentList: FirArgumentList, data: Any?) {
         require(argumentList is FirResolvedArgumentList)
-        argumentList.acceptChildren(this)
+        argumentList.acceptChildren(this, null)
     }
 
-    override fun visitNamedReference(namedReference: FirNamedReference) {
+    override fun visitNamedReference(namedReference: FirNamedReference, data: Any?) {
         require(namedReference is FirResolvedNamedReference)
-        namedReference.acceptChildren(this)
+        namedReference.acceptChildren(this, null)
     }
 
-    override fun visitTypeRef(typeRef: FirTypeRef) {
+    override fun visitTypeRef(typeRef: FirTypeRef, data: Any?) {
         require(typeRef is FirResolvedTypeRef)
-        typeRef.acceptChildren(this)
+        typeRef.acceptChildren(this, null)
     }
 
-    override fun visitResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef) {
+    override fun visitResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: Any?) {
-        resolvedTypeRef.annotations.forEach { it.accept(this) }
+        resolvedTypeRef.annotations.forEach { it.accept(this, null) }
     }
 
-    override fun visitDeclarationStatus(declarationStatus: FirDeclarationStatus) {
+    override fun visitDeclarationStatus(declarationStatus: FirDeclarationStatus, data: Any?) {
         require(declarationStatus is FirResolvedDeclarationStatus)
     }
 
-    override fun visitTypeParameterRef(typeParameterRef: FirTypeParameterRef) {
+    override fun visitTypeParameterRef(typeParameterRef: FirTypeParameterRef, data: Any?) {
-        typeParameterRef.symbol.fir.accept(this)
+        typeParameterRef.symbol.fir.accept(this, null)
     }
 }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraphBuilder.kt

@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.resultType
 import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.fir.types.isNothing
-import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitorVoid
+import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitor
 import org.jetbrains.kotlin.utils.addToStdlib.runIf
 import kotlin.random.Random
 
@@ -1213,20 +1213,20 @@ class ControlFlowGraphBuilder {
     fun dropSubgraphFromCall(call: FirFunctionCall) {
         val graphs = mutableListOf<ControlFlowGraph>()
 
-        call.acceptChildren(object : FirDefaultVisitorVoid() {
+        call.acceptChildren(object : FirDefaultVisitor<Unit, Any?>() {
-            override fun visitElement(element: FirElement) {
+            override fun visitElement(element: FirElement, data: Any?) {
-                element.acceptChildren(this)
+                element.acceptChildren(this, null)
             }
 
-            override fun visitAnonymousFunction(anonymousFunction: FirAnonymousFunction) {
+            override fun visitAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: Any?) {
-                anonymousFunction.controlFlowGraphReference?.accept(this)
+                anonymousFunction.controlFlowGraphReference?.accept(this, null)
             }
 
-            override fun visitAnonymousObject(anonymousObject: FirAnonymousObject) {
+            override fun visitAnonymousObject(anonymousObject: FirAnonymousObject, data: Any?) {
-                anonymousObject.controlFlowGraphReference?.accept(this)
+                anonymousObject.controlFlowGraphReference?.accept(this, null)
             }
 
-            override fun visitControlFlowGraphReference(controlFlowGraphReference: FirControlFlowGraphReference) {
+            override fun visitControlFlowGraphReference(controlFlowGraphReference: FirControlFlowGraphReference, data: Any?) {
                 val graph = controlFlowGraphReference.controlFlowGraph ?: return
                 if (graph.owner == null) return
                 graphs += graph

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractTreeTransformerWithSuperTypes.kt

@@ -31,7 +31,7 @@ import org.jetbrains.kotlin.fir.types.ConeLookupTagBasedType
 abstract class FirAbstractTreeTransformerWithSuperTypes(
     phase: FirResolvePhase,
     protected val scopeSession: ScopeSession
-) : FirAbstractTreeTransformer<Nothing?>(phase) {
+) : FirAbstractTreeTransformer<Any?>(phase) {
     protected val scopes = mutableListOf<FirScope>()
     protected val towerScope = FirCompositeScope(scopes.asReversed())
 
@@ -48,7 +48,7 @@ abstract class FirAbstractTreeTransformerWithSuperTypes(
 
     protected fun resolveNestedClassesSupertypes(
         firClass: FirClass<*>,
-        data: Nothing?
+        data: Any?
     ): FirStatement {
         firClass.replaceResolvePhase(transformerPhase)
         return withScopeCleanup {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt

@@ -355,14 +355,14 @@ class FirCallCompletionResultsWriterTransformer(
         }
     }
 
-    private inner class TypeUpdaterForDelegateArguments : FirTransformer<Nothing?>() {
+    private inner class TypeUpdaterForDelegateArguments : FirTransformer<Any?>() {
-        override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
+        override fun <E : FirElement> transformElement(element: E, data: Any?): E {
             return element
         }
 
         override fun transformQualifiedAccessExpression(
             qualifiedAccessExpression: FirQualifiedAccessExpression,
-            data: Nothing?
+            data: Any?
         ): FirStatement {
             val originalType = qualifiedAccessExpression.typeRef.coneType
             val substitutedReceiverType = finalSubstitutor.substituteOrNull(originalType) ?: return qualifiedAccessExpression
@@ -563,15 +563,15 @@ class FirCallCompletionResultsWriterTransformer(
     private fun transformImplicitTypeRefInAnonymousFunction(
         anonymousFunction: FirAnonymousFunction
     ): FirStatement {
-        val implicitTypeTransformer = object : FirDefaultTransformer<Nothing?>() {
+        val implicitTypeTransformer = object : FirDefaultTransformer<Any?>() {
-            override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
+            override fun <E : FirElement> transformElement(element: E, data: Any?): E {
                 @Suppress("UNCHECKED_CAST")
                 return (element.transformChildren(this, data) as E)
             }
 
             override fun transformImplicitTypeRef(
                 implicitTypeRef: FirImplicitTypeRef,
-                data: Nothing?
+                data: Any?
             ): FirTypeRef =
                 buildErrorTypeRef {
                     source = implicitTypeRef.source
@@ -745,19 +745,19 @@ private fun FirExpression.unwrapArgument(): FirExpression = when (this) {
     else -> this
 }
 
-class FirDeclarationCompletionResultsWriter(private val finalSubstitutor: ConeSubstitutor) : FirDefaultTransformer<Nothing?>() {
+class FirDeclarationCompletionResultsWriter(private val finalSubstitutor: ConeSubstitutor) : FirDefaultTransformer<Any?>() {
-    override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
+    override fun <E : FirElement> transformElement(element: E, data: Any?): E {
         return element
     }
 
-    override fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: Nothing?): FirDeclaration {
+    override fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: Any?): FirDeclaration {
         simpleFunction.transformReturnTypeRef(this, data)
         simpleFunction.transformValueParameters(this, data)
         simpleFunction.transformReceiverTypeRef(this, data)
         return simpleFunction
     }
 
-    override fun transformProperty(property: FirProperty, data: Nothing?): FirDeclaration {
+    override fun transformProperty(property: FirProperty, data: Any?): FirDeclaration {
         property.transformGetter(this, data)
         property.transformSetter(this, data)
         property.transformReturnTypeRef(this, data)
@@ -767,7 +767,7 @@ class FirDeclarationCompletionResultsWriter(private val finalSubstitutor: ConeSu
 
     override fun transformPropertyAccessor(
         propertyAccessor: FirPropertyAccessor,
-        data: Nothing?
+        data: Any?
     ): FirDeclaration {
         propertyAccessor.transformReturnTypeRef(this, data)
         propertyAccessor.transformValueParameters(this, data)
@@ -776,13 +776,13 @@ class FirDeclarationCompletionResultsWriter(private val finalSubstitutor: ConeSu
 
     override fun transformValueParameter(
         valueParameter: FirValueParameter,
-        data: Nothing?
+        data: Any?
     ): FirStatement {
         valueParameter.transformReturnTypeRef(this, data)
         return valueParameter
     }
 
-    override fun transformTypeRef(typeRef: FirTypeRef, data: Nothing?): FirTypeRef {
+    override fun transformTypeRef(typeRef: FirTypeRef, data: Any?): FirTypeRef {
         return finalSubstitutor.substituteOrNull(typeRef.coneType)?.let {
             typeRef.resolvedTypeFromPrototype(it)
         } ?: typeRef

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirImportResolveTransformer.kt

@@ -26,8 +26,8 @@ class FirImportResolveProcessor(session: FirSession, scopeSession: ScopeSession)
 open class FirImportResolveTransformer protected constructor(
     final override val session: FirSession,
     phase: FirResolvePhase
-) : FirAbstractTreeTransformer<Nothing?>(phase) {
+) : FirAbstractTreeTransformer<Any?>(phase) {
-    override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
+    override fun <E : FirElement> transformElement(element: E, data: Any?): E {
         return element
     }
 
@@ -37,7 +37,7 @@ open class FirImportResolveTransformer protected constructor(
 
     private var currentFile: FirFile? = null
 
-    override fun transformFile(file: FirFile, data: Nothing?): FirFile {
+    override fun transformFile(file: FirFile, data: Any?): FirFile {
         checkSessionConsistency(file)
         file.replaceResolvePhase(transformerPhase)
         return file.also {
@@ -51,7 +51,7 @@ open class FirImportResolveTransformer protected constructor(
         }
     }
 
-    override fun transformImport(import: FirImport, data: Nothing?): FirImport {
+    override fun transformImport(import: FirImport, data: Any?): FirImport {
         val fqName = import.importedFqName?.takeUnless { it.isRoot } ?: return import
 
         if (!fqName.isAcceptable) return import

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSealedClassInheritorsProcessor.kt

@@ -73,16 +73,16 @@ class FirSealedClassInheritorsProcessor(
         }
     }
 
-    class InheritorsTransformer(private val inheritorsMap: MutableMap<FirRegularClass, MutableList<ClassId>>) : FirTransformer<Nothing?>() {
+    class InheritorsTransformer(private val inheritorsMap: MutableMap<FirRegularClass, MutableList<ClassId>>) : FirTransformer<Any?>() {
-        override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
+        override fun <E : FirElement> transformElement(element: E, data: Any?): E {
             return element
         }
 
-        override fun transformFile(file: FirFile, data: Nothing?): FirDeclaration {
+        override fun transformFile(file: FirFile, data: Any?): FirDeclaration {
             return (file.transformChildren(this, data) as FirFile)
         }
 
-        override fun transformRegularClass(regularClass: FirRegularClass, data: Nothing?): FirStatement {
+        override fun transformRegularClass(regularClass: FirRegularClass, data: Any?): FirStatement {
             if (regularClass.modality == Modality.SEALED) {
                 val inheritors = inheritorsMap.remove(regularClass)
                 if (inheritors != null) {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt

@@ -40,19 +40,19 @@ class FirSupertypeResolverProcessor(session: FirSession, scopeSession: ScopeSess
 class FirSupertypeResolverTransformer(
     override val session: FirSession,
     scopeSession: ScopeSession
-) : FirAbstractPhaseTransformer<Nothing?>(FirResolvePhase.SUPER_TYPES) {
+) : FirAbstractPhaseTransformer<Any?>(FirResolvePhase.SUPER_TYPES) {
     private val supertypeComputationSession = SupertypeComputationSession()
 
     private val supertypeResolverVisitor = FirSupertypeResolverVisitor(session, supertypeComputationSession, scopeSession)
     private val applySupertypesTransformer = FirApplySupertypesTransformer(supertypeComputationSession)
 
-    override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
+    override fun <E : FirElement> transformElement(element: E, data: Any?): E {
         return element
     }
 
-    override fun transformFile(file: FirFile, data: Nothing?): FirFile {
+    override fun transformFile(file: FirFile, data: Any?): FirFile {
         checkSessionConsistency(file)
-        file.accept(supertypeResolverVisitor)
+        file.accept(supertypeResolverVisitor, null)
         supertypeComputationSession.breakLoops(session)
         return file.transform(applySupertypesTransformer, null)
     }
@@ -71,7 +71,7 @@ fun <F : FirClassLikeDeclaration<F>> F.runSupertypeResolvePhaseForLocalClass(
         localClassesNavigationInfo
     )
 
-    this.accept(supertypeResolverVisitor)
+    this.accept(supertypeResolverVisitor, null)
     supertypeComputationSession.breakLoops(session)
 
     val applySupertypesTransformer = FirApplySupertypesTransformer(supertypeComputationSession)
@@ -80,18 +80,18 @@ fun <F : FirClassLikeDeclaration<F>> F.runSupertypeResolvePhaseForLocalClass(
 
 private class FirApplySupertypesTransformer(
     private val supertypeComputationSession: SupertypeComputationSession
-) : FirDefaultTransformer<Nothing?>() {
+) : FirDefaultTransformer<Any?>() {
-    override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
+    override fun <E : FirElement> transformElement(element: E, data: Any?): E {
         return element
     }
 
-    override fun transformFile(file: FirFile, data: Nothing?): FirDeclaration {
+    override fun transformFile(file: FirFile, data: Any?): FirDeclaration {
         file.replaceResolvePhase(FirResolvePhase.SUPER_TYPES)
 
         return (file.transformChildren(this, null) as FirFile)
     }
 
-    override fun transformRegularClass(regularClass: FirRegularClass, data: Nothing?): FirStatement {
+    override fun transformRegularClass(regularClass: FirRegularClass, data: Any?): FirStatement {
         applyResolvedSupertypesToClass(regularClass)
 
         return (regularClass.transformChildren(this, null) as FirRegularClass)
@@ -107,7 +107,7 @@ private class FirApplySupertypesTransformer(
         firClass.replaceResolvePhase(FirResolvePhase.SUPER_TYPES)
     }
 
-    override fun transformAnonymousObject(anonymousObject: FirAnonymousObject, data: Nothing?): FirStatement {
+    override fun transformAnonymousObject(anonymousObject: FirAnonymousObject, data: Any?): FirStatement {
         applyResolvedSupertypesToClass(anonymousObject)
 
         return super.transformAnonymousObject(anonymousObject, data)
@@ -121,7 +121,7 @@ private class FirApplySupertypesTransformer(
         return status.supertypeRefs
     }
 
-    override fun transformTypeAlias(typeAlias: FirTypeAlias, data: Nothing?): FirDeclaration {
+    override fun transformTypeAlias(typeAlias: FirTypeAlias, data: Any?): FirDeclaration {
         if (typeAlias.expandedTypeRef is FirResolvedTypeRef) return typeAlias
         val supertypeRefs = getResolvedSupertypeRefs(typeAlias)
 
@@ -176,10 +176,10 @@ private class FirSupertypeResolverVisitor(
     private val scopeSession: ScopeSession,
     private val scopeForLocalClass: PersistentList<FirScope>? = null,
     private val localClassesNavigationInfo: LocalClassesNavigationInfo? = null
-) : FirDefaultVisitorVoid() {
+) : FirDefaultVisitor<Unit, Any?>() {
     private val supertypeGenerationExtensions = session.extensionService.supertypeGenerators
 
-    override fun visitElement(element: FirElement) {}
+    override fun visitElement(element: FirElement, data: Any?) {}
 
     private fun prepareFileScopes(file: FirFile): ScopePersistentList {
         return supertypeComputationSession.getOrPutFileScope(file) {
@@ -265,14 +265,14 @@ private class FirSupertypeResolverVisitor(
         return resolvedTypesRefs
     }
 
-    override fun visitRegularClass(regularClass: FirRegularClass) {
+    override fun visitRegularClass(regularClass: FirRegularClass, data: Any?) {
         resolveSpecificClassLikeSupertypes(regularClass, regularClass.superTypeRefs)
-        regularClass.acceptChildren(this)
+        regularClass.acceptChildren(this, null)
     }
 
-    override fun visitAnonymousObject(anonymousObject: FirAnonymousObject) {
+    override fun visitAnonymousObject(anonymousObject: FirAnonymousObject, data: Any?) {
         resolveSpecificClassLikeSupertypes(anonymousObject, anonymousObject.superTypeRefs)
-        anonymousObject.acceptChildren(this)
+        anonymousObject.acceptChildren(this, null)
     }
 
     fun resolveSpecificClassLikeSupertypes(
@@ -326,7 +326,7 @@ private class FirSupertypeResolverVisitor(
         }
     }
 
-    override fun visitTypeAlias(typeAlias: FirTypeAlias) {
+    override fun visitTypeAlias(typeAlias: FirTypeAlias, data: Any?) {
         // TODO: this if is a temporary hack for built-in types (because we can't load file for them)
         if (typeAlias.expandedTypeRef is FirResolvedTypeRef) {
             return
@@ -346,7 +346,7 @@ private class FirSupertypeResolverVisitor(
             if (type is ConeClassLikeType) {
                 val expansionTypeAlias = type.lookupTag.toSymbol(session)?.safeAs<FirTypeAliasSymbol>()?.fir
                 if (expansionTypeAlias != null) {
-                    visitTypeAlias(expansionTypeAlias)
+                    visitTypeAlias(expansionTypeAlias, null)
                 }
             }
 
@@ -354,8 +354,8 @@ private class FirSupertypeResolverVisitor(
         }
     }
 
-    override fun visitFile(file: FirFile) {
+    override fun visitFile(file: FirFile, data: Any?) {
-        file.acceptChildren(this)
+        file.acceptChildren(this, null)
     }
 }
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeResolveTransformer.kt

@@ -50,7 +50,7 @@ class FirTypeResolveTransformer(
     private val typeResolverTransformer: FirSpecificTypeResolverTransformer = FirSpecificTypeResolverTransformer(session)
     private var currentFile: FirFile? = null
 
-    override fun transformFile(file: FirFile, data: Nothing?): FirFile {
+    override fun transformFile(file: FirFile, data: Any?): FirFile {
         checkSessionConsistency(file)
         currentFile = file
         return withScopeCleanup {
@@ -59,7 +59,7 @@ class FirTypeResolveTransformer(
         }
     }
 
-    override fun transformRegularClass(regularClass: FirRegularClass, data: Nothing?): FirStatement {
+    override fun transformRegularClass(regularClass: FirRegularClass, data: Any?): FirStatement {
         withScopeCleanup {
             regularClass.addTypeParametersScope()
             regularClass.typeParameters.forEach {
@@ -71,25 +71,25 @@ class FirTypeResolveTransformer(
         return resolveNestedClassesSupertypes(regularClass, data)
     }
 
-    override fun transformAnonymousObject(anonymousObject: FirAnonymousObject, data: Nothing?): FirStatement {
+    override fun transformAnonymousObject(anonymousObject: FirAnonymousObject, data: Any?): FirStatement {
         return resolveNestedClassesSupertypes(anonymousObject, data)
     }
 
-    override fun transformConstructor(constructor: FirConstructor, data: Nothing?): FirDeclaration {
+    override fun transformConstructor(constructor: FirConstructor, data: Any?): FirDeclaration {
         return withScopeCleanup {
             constructor.addTypeParametersScope()
             transformDeclaration(constructor, data)
         }
     }
 
-    override fun transformTypeAlias(typeAlias: FirTypeAlias, data: Nothing?): FirDeclaration {
+    override fun transformTypeAlias(typeAlias: FirTypeAlias, data: Any?): FirDeclaration {
         return withScopeCleanup {
             typeAlias.addTypeParametersScope()
             transformDeclaration(typeAlias, data)
         }
     }
 
-    override fun transformEnumEntry(enumEntry: FirEnumEntry, data: Nothing?): FirDeclaration {
+    override fun transformEnumEntry(enumEntry: FirEnumEntry, data: Any?): FirDeclaration {
         enumEntry.replaceResolvePhase(FirResolvePhase.TYPES)
         enumEntry.transformReturnTypeRef(this, data)
         enumEntry.transformTypeParameters(this, data)
@@ -97,7 +97,7 @@ class FirTypeResolveTransformer(
         return enumEntry
     }
 
-    override fun transformProperty(property: FirProperty, data: Nothing?): FirDeclaration {
+    override fun transformProperty(property: FirProperty, data: Any?): FirDeclaration {
         return withScopeCleanup {
             property.addTypeParametersScope()
             property.replaceResolvePhase(FirResolvePhase.TYPES)
@@ -119,7 +119,7 @@ class FirTypeResolveTransformer(
         }
     }
 
-    override fun transformField(field: FirField, data: Nothing?): FirDeclaration {
+    override fun transformField(field: FirField, data: Any?): FirDeclaration {
         return withScopeCleanup {
             field.replaceResolvePhase(FirResolvePhase.TYPES)
             field.transformReturnTypeRef(this, data).transformAnnotations(this, data)
@@ -127,7 +127,7 @@ class FirTypeResolveTransformer(
         }
     }
 
-    override fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: Nothing?): FirDeclaration {
+    override fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: Any?): FirDeclaration {
         return withScopeCleanup {
             simpleFunction.addTypeParametersScope()
             transformDeclaration(simpleFunction, data).also {
@@ -163,38 +163,38 @@ class FirTypeResolveTransformer(
         }
     }
 
-    override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: Nothing?): FirTypeRef {
+    override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: Any?): FirTypeRef {
         if (implicitTypeRef is FirImplicitBuiltinTypeRef) return transformTypeRef(implicitTypeRef, data)
         return implicitTypeRef
     }
 
-    override fun transformTypeRef(typeRef: FirTypeRef, data: Nothing?): FirResolvedTypeRef {
+    override fun transformTypeRef(typeRef: FirTypeRef, data: Any?): FirResolvedTypeRef {
         return typeResolverTransformer.withFile(currentFile) { typeRef.transform(typeResolverTransformer, towerScope) }
     }
 
-    override fun transformValueParameter(valueParameter: FirValueParameter, data: Nothing?): FirStatement {
+    override fun transformValueParameter(valueParameter: FirValueParameter, data: Any?): FirStatement {
         valueParameter.transformReturnTypeRef(this, data)
         valueParameter.transformAnnotations(this, data)
         valueParameter.transformVarargTypeToArrayType()
         return valueParameter
     }
 
-    override fun transformBlock(block: FirBlock, data: Nothing?): FirStatement {
+    override fun transformBlock(block: FirBlock, data: Any?): FirStatement {
         return block
     }
 
     override fun transformDelegatedConstructorCall(
         delegatedConstructorCall: FirDelegatedConstructorCall,
-        data: Nothing?
+        data: Any?
     ): FirStatement {
         delegatedConstructorCall.replaceConstructedTypeRef(
-            delegatedConstructorCall.constructedTypeRef.transform<FirTypeRef, Nothing?>(this, data)
+            delegatedConstructorCall.constructedTypeRef.transform<FirTypeRef, Any?>(this, data)
         )
         delegatedConstructorCall.transformCalleeReference(this, data)
         return delegatedConstructorCall
     }
 
-    override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: Nothing?): FirStatement {
+    override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: Any?): FirStatement {
         annotationCall.transformAnnotationTypeRef(this, data)
         return annotationCall
     }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirWhenExhaustivenessTransformer.kt

@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
-class FirWhenExhaustivenessTransformer(private val bodyResolveComponents: BodyResolveComponents) : FirTransformer<Nothing?>() {
+class FirWhenExhaustivenessTransformer(private val bodyResolveComponents: BodyResolveComponents) : FirTransformer<Any?>() {
     companion object {
         private val exhaustivenessCheckers = listOf(
             WhenOnBooleanExhaustivenessChecker,
@@ -35,11 +35,11 @@ class FirWhenExhaustivenessTransformer(private val bodyResolveComponents: BodyRe
         )
     }
 
-    override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
+    override fun <E : FirElement> transformElement(element: E, data: Any?): E {
         throw IllegalArgumentException("Should not be there")
     }
 
-    override fun transformWhenExpression(whenExpression: FirWhenExpression, data: Nothing?): FirStatement {
+    override fun transformWhenExpression(whenExpression: FirWhenExpression, data: Any?): FirStatement {
         processExhaustivenessCheck(whenExpression)
         return whenExpression
     }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/InvocationKindTransformer.kt

@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.resolve.calls.FirNamedReferenceWithCandidate
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 
-object InvocationKindTransformer : FirTransformer<Nothing?>() {
+object InvocationKindTransformer : FirTransformer<Any?>() {
     private object ArgumentsTransformer : FirTransformer<Pair<Map<FirExpression, EventOccurrencesRange>, EventOccurrencesRange?>>() {
         override fun <E : FirElement> transformElement(element: E, data: Pair<Map<FirExpression, EventOccurrencesRange>, EventOccurrencesRange?>): E {
             return element
@@ -52,11 +52,11 @@ object InvocationKindTransformer : FirTransformer<Nothing?>() {
         }
     }
 
-    override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
+    override fun <E : FirElement> transformElement(element: E, data: Any?): E {
         return element
     }
 
-    override fun transformFunctionCall(functionCall: FirFunctionCall, data: Nothing?): FirStatement {
+    override fun transformFunctionCall(functionCall: FirFunctionCall, data: Any?): FirStatement {
         val calleeReference = functionCall.calleeReference as? FirNamedReferenceWithCandidate ?: return functionCall
         val argumentMapping = calleeReference.candidate.argumentMapping ?: return functionCall
         val function = calleeReference.candidateSymbol.fir as? FirSimpleFunction ?: return functionCall

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ResolvePhaseUtils.kt

@@ -42,11 +42,11 @@ class FirDummyTransformerBasedProcessor(
     session: FirSession,
     scopeSession: ScopeSession
 ) : FirTransformerBasedResolveProcessor(session, scopeSession) {
-    override val transformer: FirTransformer<Nothing?>
+    override val transformer: FirTransformer<Any?>
         get() = DummyTransformer
 
-    private object DummyTransformer : FirTransformer<Nothing?>() {
+    private object DummyTransformer : FirTransformer<Any?>() {
-        override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
+        override fun <E : FirElement> transformElement(element: E, data: Any?): E {
             return element
         }
     }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformerAdapters.kt

@@ -21,7 +21,7 @@ class FirBodyResolveProcessor(session: FirSession, scopeSession: ScopeSession) :
 }
 
 @AdapterForResolveProcessor
-class FirBodyResolveTransformerAdapter(session: FirSession, scopeSession: ScopeSession) : FirTransformer<Nothing?>() {
+class FirBodyResolveTransformerAdapter(session: FirSession, scopeSession: ScopeSession) : FirTransformer<Any?>() {
     private val transformer = FirBodyResolveTransformer(
         session,
         phase = FirResolvePhase.BODY_RESOLVE,
@@ -29,11 +29,11 @@ class FirBodyResolveTransformerAdapter(session: FirSession, scopeSession: ScopeS
         scopeSession = scopeSession
     )
 
-    override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
+    override fun <E : FirElement> transformElement(element: E, data: Any?): E {
         return element
     }
 
-    override fun transformFile(file: FirFile, data: Nothing?): FirFile {
+    override fun transformFile(file: FirFile, data: Any?): FirFile {
         return file.transform(transformer, ResolutionMode.ContextIndependent)
     }
 }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt

@@ -842,12 +842,12 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
         }
     }
 
-    private object ImplicitToErrorTypeTransformer : FirTransformer<Nothing?>() {
+    private object ImplicitToErrorTypeTransformer : FirTransformer<Any?>() {
-        override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
+        override fun <E : FirElement> transformElement(element: E, data: Any?): E {
             return element
         }
 
-        override fun transformValueParameter(valueParameter: FirValueParameter, data: Nothing?): FirStatement {
+        override fun transformValueParameter(valueParameter: FirValueParameter, data: Any?): FirStatement {
             if (valueParameter.returnTypeRef is FirImplicitTypeRef) {
                 valueParameter.transformReturnTypeRef(
                     StoreType,

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt

@@ -546,12 +546,12 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform
         }.transformOtherChildren(transformer, ResolutionMode.ContextIndependent)
 
         val conversionTypeRef = resolved.conversionTypeRef.withTypeArgumentsForBareType(resolved.argument)
-        resolved.transformChildren(object : FirDefaultTransformer<Nothing?>() {
+        resolved.transformChildren(object : FirDefaultTransformer<Any?>() {
-            override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
+            override fun <E : FirElement> transformElement(element: E, data: Any?): E {
                 return element
             }
 
-            override fun transformTypeRef(typeRef: FirTypeRef, data: Nothing?): FirTypeRef {
+            override fun transformTypeRef(typeRef: FirTypeRef, data: Any?): FirTypeRef {
                 return if (typeRef === resolved.conversionTypeRef) {
                     conversionTypeRef
                 } else {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt

@@ -33,7 +33,7 @@ class FirImplicitTypeBodyResolveProcessor(
 }
 
 @AdapterForResolveProcessor
-class FirImplicitTypeBodyResolveTransformerAdapter(session: FirSession, scopeSession: ScopeSession) : FirTransformer<Nothing?>() {
+class FirImplicitTypeBodyResolveTransformerAdapter(session: FirSession, scopeSession: ScopeSession) : FirTransformer<Any?>() {
     private val implicitBodyResolveComputationSession = ImplicitBodyResolveComputationSession()
     private val returnTypeCalculator = ReturnTypeCalculatorWithJump(session, scopeSession, implicitBodyResolveComputationSession)
 
@@ -45,11 +45,11 @@ class FirImplicitTypeBodyResolveTransformerAdapter(session: FirSession, scopeSes
         returnTypeCalculator
     )
 
-    override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
+    override fun <E : FirElement> transformElement(element: E, data: Any?): E {
         return element
     }
 
-    override fun transformFile(file: FirFile, data: Nothing?): FirFile {
+    override fun transformFile(file: FirFile, data: Any?): FirFile {
         return file.transform(transformer, ResolutionMode.ContextIndependent)
     }
 }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/LocalClassesNavigation.kt

@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSymbolOwner
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
-import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitorVoid
+import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitor
 import org.jetbrains.kotlin.utils.keysToMap
 
 class LocalClassesNavigationInfo(
@@ -40,58 +40,59 @@ class LocalClassesNavigationInfo(
 
 fun FirClassLikeDeclaration<*>.collectLocalClassesNavigationInfo(): LocalClassesNavigationInfo =
     NavigationInfoVisitor().run {
-        this@collectLocalClassesNavigationInfo.accept(this@run)
+        this@collectLocalClassesNavigationInfo.accept(this@run, null)
 
         LocalClassesNavigationInfo(parentForClass, resultingMap, allMembers)
     }
 
-private class NavigationInfoVisitor : FirDefaultVisitorVoid() {
+private class NavigationInfoVisitor : FirDefaultVisitor<Unit, Any?>() {
     val resultingMap: MutableMap<FirCallableMemberDeclaration<*>, FirClassLikeDeclaration<*>> = mutableMapOf()
     val parentForClass: MutableMap<FirClassLikeDeclaration<*>, FirClassLikeDeclaration<*>?> = mutableMapOf()
     val allMembers: MutableList<FirSymbolOwner<*>> = mutableListOf()
     private var currentPath: PersistentList<FirClassLikeDeclaration<*>> = persistentListOf()
 
-    override fun visitElement(element: FirElement) {}
+    override fun visitElement(element: FirElement, data: Any?) {}
 
-    override fun visitRegularClass(regularClass: FirRegularClass) {
+    override fun visitRegularClass(regularClass: FirRegularClass, data: Any?) {
-        visitClass(regularClass)
+        visitClass(regularClass, null)
     }
 
-    override fun visitAnonymousObject(anonymousObject: FirAnonymousObject) {
+    override fun visitAnonymousObject(anonymousObject: FirAnonymousObject, data: Any?) {
-        visitClass(anonymousObject)
+        visitClass(anonymousObject, null)
     }
 
-    override fun <F : FirClass<F>> visitClass(klass: FirClass<F>) {
+    override fun <F : FirClass<F>> visitClass(klass: FirClass<F>, data: Any?) {
         parentForClass[klass] = currentPath.lastOrNull()
         val prev = currentPath
         currentPath = currentPath.add(klass)
 
-        klass.acceptChildren(this)
+        klass.acceptChildren(this, null)
 
         currentPath = prev
     }
 
-    override fun visitSimpleFunction(simpleFunction: FirSimpleFunction) {
+    override fun visitSimpleFunction(simpleFunction: FirSimpleFunction, data: Any?) {
-        visitCallableMemberDeclaration(simpleFunction)
+        visitCallableMemberDeclaration(simpleFunction, null)
     }
 
-    override fun visitProperty(property: FirProperty) {
+    override fun visitProperty(property: FirProperty, data: Any?) {
-        visitCallableMemberDeclaration(property)
+        visitCallableMemberDeclaration(property, null)
     }
 
-    override fun visitConstructor(constructor: FirConstructor) {
+    override fun visitConstructor(constructor: FirConstructor, data: Any?) {
-        visitCallableMemberDeclaration(constructor)
+        visitCallableMemberDeclaration(constructor, null)
     }
 
     override fun <F : FirCallableMemberDeclaration<F>> visitCallableMemberDeclaration(
-        callableMemberDeclaration: FirCallableMemberDeclaration<F>
+        callableMemberDeclaration: FirCallableMemberDeclaration<F>,
+        data: Any?
     ) {
         allMembers += callableMemberDeclaration
         if (callableMemberDeclaration.returnTypeRef !is FirImplicitTypeRef) return
         resultingMap[callableMemberDeclaration] = currentPath.last()
     }
 
-    override fun visitAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer) {
+    override fun visitAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, data: Any?) {
         allMembers += anonymousInitializer
     }
 }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/FirContractResolveTransformerAdapter.kt

@@ -25,13 +25,13 @@ class FirContractResolveProcessor(session: FirSession, scopeSession: ScopeSessio
 }
 
 @AdapterForResolveProcessor
-class FirContractResolveTransformerAdapter(session: FirSession, scopeSession: ScopeSession) : FirTransformer<Nothing?>() {
+class FirContractResolveTransformerAdapter(session: FirSession, scopeSession: ScopeSession) : FirTransformer<Any?>() {
     private val transformer = FirContractResolveTransformer(session, scopeSession)
-    override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
+    override fun <E : FirElement> transformElement(element: E, data: Any?): E {
         return element
     }
 
-    override fun transformFile(file: FirFile, data: Nothing?): FirDeclaration {
+    override fun transformFile(file: FirFile, data: Any?): FirDeclaration {
         return file.transform(transformer, ResolutionMode.ContextIndependent)
     }
 }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsResolveProcessor.kt

@@ -22,20 +22,20 @@ class FirAnnotationArgumentsResolveProcessor(
     session: FirSession,
     scopeSession: ScopeSession
 ) : FirTransformerBasedResolveProcessor(session, scopeSession) {
-    override val transformer: FirTransformer<Nothing?> = FirAnnotationArgumentsResolveTransformerAdapter(session, scopeSession)
+    override val transformer: FirTransformer<Any?> = FirAnnotationArgumentsResolveTransformerAdapter(session, scopeSession)
 }
 
 @AdapterForResolveProcessor
-class FirAnnotationArgumentsResolveTransformerAdapter(session: FirSession, scopeSession: ScopeSession) : FirTransformer<Nothing?>() {
+class FirAnnotationArgumentsResolveTransformerAdapter(session: FirSession, scopeSession: ScopeSession) : FirTransformer<Any?>() {
     private val transformer = FirAnnotationArgumentsResolveTransformer(session, scopeSession)
     private val hasAnnotations = session.registeredPluginAnnotations.annotations.isNotEmpty()
     private val predicateBasedProvider = session.predicateBasedProvider
 
-    override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
+    override fun <E : FirElement> transformElement(element: E, data: Any?): E {
         return element
     }
 
-    override fun transformFile(file: FirFile, data: Nothing?): FirDeclaration {
+    override fun transformFile(file: FirFile, data: Any?): FirDeclaration {
         if (!hasAnnotations || !predicateBasedProvider.fileHasPluginAnnotations(file)) return file
         return file.transform(transformer, ResolutionMode.ContextIndependent)
     }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirPluginAnnotationsResolveTransformer.kt

@@ -31,16 +31,16 @@ class FirPluginAnnotationsResolveProcessor(session: FirSession, scopeSession: Sc
 class FirPluginAnnotationsResolveTransformer(
     override val session: FirSession,
     scopeSession: ScopeSession
-) : FirAbstractPhaseTransformer<Nothing?>(FirResolvePhase.ANNOTATIONS_FOR_PLUGINS) {
+) : FirAbstractPhaseTransformer<Any?>(FirResolvePhase.ANNOTATIONS_FOR_PLUGINS) {
     private val annotationTransformer = FirAnnotationResolveTransformer(session, scopeSession)
     private val importTransformer = FirPartialImportResolveTransformer(session)
 
     val extensionService = session.extensionService
-    override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
+    override fun <E : FirElement> transformElement(element: E, data: Any?): E {
         throw IllegalStateException("Should not be here")
     }
 
-    override fun transformFile(file: FirFile, data: Nothing?): FirFile {
+    override fun transformFile(file: FirFile, data: Any?): FirFile {
         checkSessionConsistency(file)
         if (!extensionService.hasPredicateBasedExtensions) return file
         val registeredPluginAnnotations = file.session.registeredPluginAnnotations