From 038a8af80ec840a7c4fe69b2bef9f199da71854f Mon Sep 17 00:00:00 2001 From: Ilya Chernikov Date: Fri, 12 Mar 2021 21:52:26 +0100 Subject: [PATCH] FIR: convert some hot void visitors to any reduces call indirection (Nothing -> Void bridges) and therefore callstack depth --- .../collectors/AbstractDiagnosticCollector.kt | 44 +++++++++---------- .../signaturer/FirBasedSignatureComposer.kt | 20 ++++----- .../GeneratedDeclarationValidation.kt | 40 ++++++++--------- .../dfa/cfg/ControlFlowGraphBuilder.kt | 18 ++++---- ...irAbstractTreeTransformerWithSuperTypes.kt | 4 +- ...rCallCompletionResultsWriterTransformer.kt | 26 +++++------ .../FirImportResolveTransformer.kt | 8 ++-- .../FirSealedClassInheritorsProcessor.kt | 8 ++-- .../transformers/FirSupertypesResolution.kt | 42 +++++++++--------- .../transformers/FirTypeResolveTransformer.kt | 32 +++++++------- .../FirWhenExhaustivenessTransformer.kt | 6 +-- .../transformers/InvocationKindTransformer.kt | 6 +-- .../resolve/transformers/ResolvePhaseUtils.kt | 6 +-- .../FirBodyResolveTransformerAdapters.kt | 6 +-- .../FirDeclarationsResolveTransformer.kt | 6 +-- .../FirExpressionsResolveTransformer.kt | 6 +-- .../body/resolve/FirImplicitBodyResolve.kt | 6 +-- .../body/resolve/LocalClassesNavigation.kt | 37 ++++++++-------- .../FirContractResolveTransformerAdapter.kt | 6 +-- .../FirAnnotationArgumentsResolveProcessor.kt | 8 ++-- .../FirPluginAnnotationsResolveTransformer.kt | 6 +-- 21 files changed, 171 insertions(+), 170 deletions(-) diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/AbstractDiagnosticCollector.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/AbstractDiagnosticCollector.kt index f9773ff7218..a41137baad7 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/AbstractDiagnosticCollector.kt +++ b/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() { + private inner class Visitor : FirDefaultVisitor() { private fun 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) } diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/signaturer/FirBasedSignatureComposer.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/signaturer/FirBasedSignatureComposer.kt index d9fd8ee6027..5f6825eead9 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/signaturer/FirBasedSignatureComposer.kt +++ b/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() { 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) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/declarations/GeneratedDeclarationValidation.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/declarations/GeneratedDeclarationValidation.kt index 7f1a76a146f..e0f34ee6541 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/declarations/GeneratedDeclarationValidation.kt +++ b/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() { - override fun visitElement(element: FirElement) { - element.acceptChildren(this) +object FirGeneratedElementsValidator : FirDefaultVisitor() { + override fun visitElement(element: FirElement, data: Any?) { + 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) { - regularClass.acceptChildren(this) + override fun visitRegularClass(regularClass: FirRegularClass, data: Any?) { + 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) { - resolvedTypeRef.annotations.forEach { it.accept(this) } + override fun visitResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: Any?) { + 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) { - typeParameterRef.symbol.fir.accept(this) + override fun visitTypeParameterRef(typeParameterRef: FirTypeParameterRef, data: Any?) { + typeParameterRef.symbol.fir.accept(this, null) } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraphBuilder.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraphBuilder.kt index 8233d78b26f..309a67f0bae 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraphBuilder.kt +++ b/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() - call.acceptChildren(object : FirDefaultVisitorVoid() { - override fun visitElement(element: FirElement) { - element.acceptChildren(this) + call.acceptChildren(object : FirDefaultVisitor() { + override fun visitElement(element: FirElement, data: Any?) { + element.acceptChildren(this, null) } - override fun visitAnonymousFunction(anonymousFunction: FirAnonymousFunction) { - anonymousFunction.controlFlowGraphReference?.accept(this) + override fun visitAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: Any?) { + anonymousFunction.controlFlowGraphReference?.accept(this, null) } - override fun visitAnonymousObject(anonymousObject: FirAnonymousObject) { - anonymousObject.controlFlowGraphReference?.accept(this) + override fun visitAnonymousObject(anonymousObject: FirAnonymousObject, data: Any?) { + 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 diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractTreeTransformerWithSuperTypes.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractTreeTransformerWithSuperTypes.kt index d306a2cbccd..a2e8be36c91 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractTreeTransformerWithSuperTypes.kt +++ b/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(phase) { +) : FirAbstractTreeTransformer(phase) { protected val scopes = mutableListOf() 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 { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt index 8e21b0ce4b0..7f45f52f159 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt @@ -355,14 +355,14 @@ class FirCallCompletionResultsWriterTransformer( } } - private inner class TypeUpdaterForDelegateArguments : FirTransformer() { - override fun transformElement(element: E, data: Nothing?): E { + private inner class TypeUpdaterForDelegateArguments : FirTransformer() { + override fun 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() { - override fun transformElement(element: E, data: Nothing?): E { + val implicitTypeTransformer = object : FirDefaultTransformer() { + override fun 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() { - override fun transformElement(element: E, data: Nothing?): E { +class FirDeclarationCompletionResultsWriter(private val finalSubstitutor: ConeSubstitutor) : FirDefaultTransformer() { + override fun 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 diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirImportResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirImportResolveTransformer.kt index f1d8a4d1dc9..8dc72b1eefc 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirImportResolveTransformer.kt +++ b/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(phase) { - override fun transformElement(element: E, data: Nothing?): E { +) : FirAbstractTreeTransformer(phase) { + override fun 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 diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSealedClassInheritorsProcessor.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSealedClassInheritorsProcessor.kt index 7e0b26a4aae..cb99375bc3a 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSealedClassInheritorsProcessor.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSealedClassInheritorsProcessor.kt @@ -73,16 +73,16 @@ class FirSealedClassInheritorsProcessor( } } - class InheritorsTransformer(private val inheritorsMap: MutableMap>) : FirTransformer() { - override fun transformElement(element: E, data: Nothing?): E { + class InheritorsTransformer(private val inheritorsMap: MutableMap>) : FirTransformer() { + override fun 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) { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt index 73efd83e166..7c4a5c50276 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt +++ b/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(FirResolvePhase.SUPER_TYPES) { +) : FirAbstractPhaseTransformer(FirResolvePhase.SUPER_TYPES) { private val supertypeComputationSession = SupertypeComputationSession() private val supertypeResolverVisitor = FirSupertypeResolverVisitor(session, supertypeComputationSession, scopeSession) private val applySupertypesTransformer = FirApplySupertypesTransformer(supertypeComputationSession) - override fun transformElement(element: E, data: Nothing?): E { + override fun 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.runSupertypeResolvePhaseForLocalClass( localClassesNavigationInfo ) - this.accept(supertypeResolverVisitor) + this.accept(supertypeResolverVisitor, null) supertypeComputationSession.breakLoops(session) val applySupertypesTransformer = FirApplySupertypesTransformer(supertypeComputationSession) @@ -80,18 +80,18 @@ fun > F.runSupertypeResolvePhaseForLocalClass( private class FirApplySupertypesTransformer( private val supertypeComputationSession: SupertypeComputationSession -) : FirDefaultTransformer() { - override fun transformElement(element: E, data: Nothing?): E { +) : FirDefaultTransformer() { + override fun 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? = null, private val localClassesNavigationInfo: LocalClassesNavigationInfo? = null -) : FirDefaultVisitorVoid() { +) : FirDefaultVisitor() { 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()?.fir if (expansionTypeAlias != null) { - visitTypeAlias(expansionTypeAlias) + visitTypeAlias(expansionTypeAlias, null) } } @@ -354,8 +354,8 @@ private class FirSupertypeResolverVisitor( } } - override fun visitFile(file: FirFile) { - file.acceptChildren(this) + override fun visitFile(file: FirFile, data: Any?) { + file.acceptChildren(this, null) } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeResolveTransformer.kt index bd58eeb6bc7..9a8de8f2ced 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeResolveTransformer.kt +++ b/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(this, data) + delegatedConstructorCall.constructedTypeRef.transform(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 } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirWhenExhaustivenessTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirWhenExhaustivenessTransformer.kt index 21a93415023..39d9b33aa38 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirWhenExhaustivenessTransformer.kt +++ b/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() { +class FirWhenExhaustivenessTransformer(private val bodyResolveComponents: BodyResolveComponents) : FirTransformer() { companion object { private val exhaustivenessCheckers = listOf( WhenOnBooleanExhaustivenessChecker, @@ -35,11 +35,11 @@ class FirWhenExhaustivenessTransformer(private val bodyResolveComponents: BodyRe ) } - override fun transformElement(element: E, data: Nothing?): E { + override fun 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 } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/InvocationKindTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/InvocationKindTransformer.kt index b1118be0b0c..7bbd383ffd9 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/InvocationKindTransformer.kt +++ b/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() { +object InvocationKindTransformer : FirTransformer() { private object ArgumentsTransformer : FirTransformer, EventOccurrencesRange?>>() { override fun transformElement(element: E, data: Pair, EventOccurrencesRange?>): E { return element @@ -52,11 +52,11 @@ object InvocationKindTransformer : FirTransformer() { } } - override fun transformElement(element: E, data: Nothing?): E { + override fun 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 diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ResolvePhaseUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ResolvePhaseUtils.kt index bcc4a9566ee..dbc68dbef1c 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ResolvePhaseUtils.kt +++ b/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 + override val transformer: FirTransformer get() = DummyTransformer - private object DummyTransformer : FirTransformer() { - override fun transformElement(element: E, data: Nothing?): E { + private object DummyTransformer : FirTransformer() { + override fun transformElement(element: E, data: Any?): E { return element } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformerAdapters.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformerAdapters.kt index 9157101be02..2ff764493ee 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformerAdapters.kt +++ b/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() { +class FirBodyResolveTransformerAdapter(session: FirSession, scopeSession: ScopeSession) : FirTransformer() { private val transformer = FirBodyResolveTransformer( session, phase = FirResolvePhase.BODY_RESOLVE, @@ -29,11 +29,11 @@ class FirBodyResolveTransformerAdapter(session: FirSession, scopeSession: ScopeS scopeSession = scopeSession ) - override fun transformElement(element: E, data: Nothing?): E { + override fun 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) } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt index cb2851c9745..1a76ab4a44b 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt +++ b/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() { - override fun transformElement(element: E, data: Nothing?): E { + private object ImplicitToErrorTypeTransformer : FirTransformer() { + override fun 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, diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt index cddb0fdef78..fda789cf059 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt +++ b/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() { - override fun transformElement(element: E, data: Nothing?): E { + resolved.transformChildren(object : FirDefaultTransformer() { + override fun 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 { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt index 2664c611f99..0e37d5a3f38 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt +++ b/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() { +class FirImplicitTypeBodyResolveTransformerAdapter(session: FirSession, scopeSession: ScopeSession) : FirTransformer() { private val implicitBodyResolveComputationSession = ImplicitBodyResolveComputationSession() private val returnTypeCalculator = ReturnTypeCalculatorWithJump(session, scopeSession, implicitBodyResolveComputationSession) @@ -45,11 +45,11 @@ class FirImplicitTypeBodyResolveTransformerAdapter(session: FirSession, scopeSes returnTypeCalculator ) - override fun transformElement(element: E, data: Nothing?): E { + override fun 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) } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/LocalClassesNavigation.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/LocalClassesNavigation.kt index 0ee9decc8eb..a5912811fd1 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/LocalClassesNavigation.kt +++ b/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() { val resultingMap: MutableMap, FirClassLikeDeclaration<*>> = mutableMapOf() val parentForClass: MutableMap, FirClassLikeDeclaration<*>?> = mutableMapOf() val allMembers: MutableList> = mutableListOf() private var currentPath: PersistentList> = persistentListOf() - override fun visitElement(element: FirElement) {} + override fun visitElement(element: FirElement, data: Any?) {} - override fun visitRegularClass(regularClass: FirRegularClass) { - visitClass(regularClass) + override fun visitRegularClass(regularClass: FirRegularClass, data: Any?) { + visitClass(regularClass, null) } - override fun visitAnonymousObject(anonymousObject: FirAnonymousObject) { - visitClass(anonymousObject) + override fun visitAnonymousObject(anonymousObject: FirAnonymousObject, data: Any?) { + visitClass(anonymousObject, null) } - override fun > visitClass(klass: FirClass) { + override fun > visitClass(klass: FirClass, 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) { - visitCallableMemberDeclaration(simpleFunction) + override fun visitSimpleFunction(simpleFunction: FirSimpleFunction, data: Any?) { + visitCallableMemberDeclaration(simpleFunction, null) } - override fun visitProperty(property: FirProperty) { - visitCallableMemberDeclaration(property) + override fun visitProperty(property: FirProperty, data: Any?) { + visitCallableMemberDeclaration(property, null) } - override fun visitConstructor(constructor: FirConstructor) { - visitCallableMemberDeclaration(constructor) + override fun visitConstructor(constructor: FirConstructor, data: Any?) { + visitCallableMemberDeclaration(constructor, null) } override fun > visitCallableMemberDeclaration( - callableMemberDeclaration: FirCallableMemberDeclaration + callableMemberDeclaration: FirCallableMemberDeclaration, + 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 } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/FirContractResolveTransformerAdapter.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/FirContractResolveTransformerAdapter.kt index e897825e493..80b5dfddd95 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/FirContractResolveTransformerAdapter.kt +++ b/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() { +class FirContractResolveTransformerAdapter(session: FirSession, scopeSession: ScopeSession) : FirTransformer() { private val transformer = FirContractResolveTransformer(session, scopeSession) - override fun transformElement(element: E, data: Nothing?): E { + override fun 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) } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsResolveProcessor.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsResolveProcessor.kt index 2a93bcd64d0..ce3cbaf3d1f 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsResolveProcessor.kt +++ b/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 = FirAnnotationArgumentsResolveTransformerAdapter(session, scopeSession) + override val transformer: FirTransformer = FirAnnotationArgumentsResolveTransformerAdapter(session, scopeSession) } @AdapterForResolveProcessor -class FirAnnotationArgumentsResolveTransformerAdapter(session: FirSession, scopeSession: ScopeSession) : FirTransformer() { +class FirAnnotationArgumentsResolveTransformerAdapter(session: FirSession, scopeSession: ScopeSession) : FirTransformer() { private val transformer = FirAnnotationArgumentsResolveTransformer(session, scopeSession) private val hasAnnotations = session.registeredPluginAnnotations.annotations.isNotEmpty() private val predicateBasedProvider = session.predicateBasedProvider - override fun transformElement(element: E, data: Nothing?): E { + override fun 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) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirPluginAnnotationsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirPluginAnnotationsResolveTransformer.kt index 8ce6f6abf13..0821f95af3e 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirPluginAnnotationsResolveTransformer.kt +++ b/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(FirResolvePhase.ANNOTATIONS_FOR_PLUGINS) { +) : FirAbstractPhaseTransformer(FirResolvePhase.ANNOTATIONS_FOR_PLUGINS) { private val annotationTransformer = FirAnnotationResolveTransformer(session, scopeSession) private val importTransformer = FirPartialImportResolveTransformer(session) val extensionService = session.extensionService - override fun transformElement(element: E, data: Nothing?): E { + override fun 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