diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/CompilerPhase.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/CompilerPhase.kt index d52fafe4d8d..72272ce9508 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/CompilerPhase.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/CompilerPhase.kt @@ -8,7 +8,9 @@ package org.jetbrains.kotlin.backend.common import org.jetbrains.kotlin.config.CommonConfigurationKeys import org.jetbrains.kotlin.config.CompilerConfiguration import org.jetbrains.kotlin.config.CompilerConfigurationKey -import org.jetbrains.kotlin.ir.declarations.IrFile +import org.jetbrains.kotlin.ir.IrElement +import org.jetbrains.kotlin.ir.util.dump +import kotlin.system.measureTimeMillis interface CompilerPhase { val name: String @@ -31,13 +33,21 @@ class CompilerPhases(private val phaseList: List, config: CompilerConf val toDumpStateBefore: Set val toDumpStateAfter: Set + val toValidateStateBefore: Set + val toValidateStateAfter: Set + init { with(CommonConfigurationKeys) { - val beforeSet = phaseSetFromConfiguration(config, PHASES_TO_DUMP_STATE_BEFORE) - val afterSet = phaseSetFromConfiguration(config, PHASES_TO_DUMP_STATE_AFTER) - val bothSet = phaseSetFromConfiguration(config, PHASES_TO_DUMP_STATE) - toDumpStateBefore = beforeSet + bothSet - toDumpStateAfter = afterSet + bothSet + val beforeDumpSet = phaseSetFromConfiguration(config, PHASES_TO_DUMP_STATE_BEFORE) + val afterDumpSet = phaseSetFromConfiguration(config, PHASES_TO_DUMP_STATE_AFTER) + val bothDumpSet = phaseSetFromConfiguration(config, PHASES_TO_DUMP_STATE) + toDumpStateBefore = beforeDumpSet + bothDumpSet + toDumpStateAfter = afterDumpSet + bothDumpSet + val beforeValidateSet = phaseSetFromConfiguration(config, PHASES_TO_VALIDATE_BEFORE) + val afterValidateSet = phaseSetFromConfiguration(config, PHASES_TO_VALIDATE_AFTER) + val bothValidateSet = phaseSetFromConfiguration(config, PHASES_TO_VALIDATE) + toValidateStateBefore = beforeValidateSet + bothValidateSet + toValidateStateAfter = afterValidateSet + bothValidateSet } } @@ -70,13 +80,95 @@ class CompilerPhases(private val phaseList: List, config: CompilerConf } } + interface PhaseRunner { - fun reportBefore(phase: CompilerPhase, depth: Int, context: Context, data: Data) + fun runBefore(phase: CompilerPhase, depth: Int, context: Context, data: Data) fun runBody(phase: CompilerPhase, context: Context, source: Data): Data - fun reportAfter(phase: CompilerPhase, depth: Int, context: Context, data: Data) + fun runAfter(phase: CompilerPhase, depth: Int, context: Context, data: Data) +} + +abstract class DefaultIrPhaseRunner(private val validator: (data: Data, context: Context) -> Unit = { _, _ -> }) : + PhaseRunner { + + enum class BeforeOrAfter { BEFORE, AFTER } + + abstract val startPhaseMarker: CompilerPhase + abstract val endPhaseMarker: CompilerPhase + + private var inVerbosePhase = false + + final override fun runBefore(phase: CompilerPhase, depth: Int, context: Context, data: Data) { + checkAndRun(phase, phases(context).toDumpStateBefore) { dumpElement(data, phase, context, BeforeOrAfter.BEFORE) } + checkAndRun(phase, phases(context).toValidateStateBefore) { validator(data, context) } + } + + final override fun runBody(phase: CompilerPhase, context: Context, source: Data): Data { + val runner = when { + phase === startPhaseMarker -> ::justRun + phase === endPhaseMarker -> ::justRun + needProfiling(context) -> ::runAndProfile + else -> ::justRun + } + + inVerbosePhase = phase in phases(context).verbose + + val result = runner(phase, context, source) + + inVerbosePhase = false + + return result + } + + final override fun runAfter(phase: CompilerPhase, depth: Int, context: Context, data: Data) { + checkAndRun(phase, phases(context).toDumpStateAfter) { dumpElement(data, phase, context, BeforeOrAfter.AFTER) } + checkAndRun(phase, phases(context).toValidateStateAfter) { validator(data, context) } + } + + open fun separator(title: String) = println("\n\n--- $title ----------------------\n") + + protected abstract fun phases(context: Context): CompilerPhases + protected abstract fun elementName(input: Data): String + protected abstract fun configuration(context: Context): CompilerConfiguration + + private fun needProfiling(context: Context) = configuration(context).getBoolean(CommonConfigurationKeys.PROFILE_PHASES) + + private fun shouldBeDumped(context: Context, input: Data) = + elementName(input) !in configuration(context).get(CommonConfigurationKeys.EXCLUDED_ELEMENTS_FROM_DUMPING, emptySet()) + + private fun checkAndRun(phase: CompilerPhase, set: Set, block: () -> Unit) { + if (phase in set) block() + } + + private fun dumpElement(input: Data, phase: CompilerPhase, context: Context, beforeOrAfter: BeforeOrAfter) { + // Exclude nonsensical combinations + if (phase === startPhaseMarker && beforeOrAfter == BeforeOrAfter.AFTER) return + if (phase === endPhaseMarker && beforeOrAfter == BeforeOrAfter.BEFORE) return + + if (!shouldBeDumped(context, input)) return + + val title = when (phase) { + startPhaseMarker -> "IR for ${elementName(input)} at the start of lowering process" + endPhaseMarker -> "IR for ${elementName(input)} at the end of lowering process" + else -> { + val beforeOrAfterStr = beforeOrAfter.name.toLowerCase() + "IR for ${elementName(input)} $beforeOrAfterStr ${phase.description}" + } + } + separator(title) + println(input.dump()) + } + + private fun runAndProfile(phase: CompilerPhase, context: Context, source: Data): Data { + var result: Data = source + val msec = measureTimeMillis { result = phase.invoke(context, source) } + println("${phase.description}: $msec msec") + return result + } + + private fun justRun(phase: CompilerPhase, context: Context, source: Data) = + phase.invoke(context, source) } -/* We assume that `element` is being modified by each phase, retaining its identity in the process. */ class CompilerPhaseManager( val context: Context, val phases: CompilerPhases, @@ -111,39 +203,27 @@ class CompilerPhaseManager( previousPhases.add(phase) - phaseRunner.reportBefore(phase, depth, context, source) + phaseRunner.runBefore(phase, depth, context, source) val result = phaseRunner.runBody(phase, context, source) - phaseRunner.reportAfter(phase, depth, context, result) + phaseRunner.runAfter(phase, depth, context, result) return result } } -fun makePhase( - loweringConstructor: (Context) -> FileLoweringPass, +fun makePhase( + lowering: (Context, Data) -> Unit, description: String, name: String, prerequisite: Set> = emptySet() -) = object : CompilerPhase { +) = object : CompilerPhase { override val name = name override val description = description override val prerequisite = prerequisite - override fun invoke(context: Context, input: IrFile): IrFile { - loweringConstructor(context).lower(input) + override fun invoke(context: Context, input: Data): Data { + lowering(context, input) return input } -} -object IrFileStartPhase : CompilerPhase { - override val name = "IrFileStart" - override val description = "State at start of IrFile lowering" - override val prerequisite = emptySet() - override fun invoke(context: BackendContext, input: IrFile) = input -} - -object IrFileEndPhase : CompilerPhase { - override val name = "IrFileEnd" - override val description = "State at end of IrFile lowering" - override val prerequisite = emptySet() - override fun invoke(context: BackendContext, input: IrFile) = input + override fun toString() = "Compiler Phase @$name" } \ No newline at end of file diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/DefaultArgumentStubGenerator.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/DefaultArgumentStubGenerator.kt index 194d4b549dd..a7fbeb4354f 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/DefaultArgumentStubGenerator.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/DefaultArgumentStubGenerator.kt @@ -37,16 +37,6 @@ import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid import org.jetbrains.kotlin.name.Name -fun makeDefaultArgumentStubPhase(skipInlineMethods: Boolean) = object : CompilerPhase { - override val name = "DefaultArgumentsStubGenerator" - override val description = "Generate synthetic stubs for functions with default parameter values" - - override fun invoke(context: CommonBackendContext, input: IrFile): IrFile { - DefaultArgumentStubGenerator(context, skipInlineMethods).lower(input) - return input - } -} - // TODO: fix expect/actual default parameters open class DefaultArgumentStubGenerator constructor(val context: CommonBackendContext, private val skipInlineMethods: Boolean = true) : diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/InitializersLowering.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/InitializersLowering.kt index d86897bfdff..23386fb9755 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/InitializersLowering.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/InitializersLowering.kt @@ -34,17 +34,6 @@ import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns -fun makeInitializersPhase(declarationOrigin: IrDeclarationOrigin, clinitNeeded: Boolean) = object : - CompilerPhase { - override val name = "Initializers" - override val description = "Handle initializer statements" - - override fun invoke(context: CommonBackendContext, input: IrFile): IrFile { - InitializersLowering(context, declarationOrigin, clinitNeeded).lower(input) - return input - } -} - object SYNTHESIZED_INIT_BLOCK: IrStatementOriginImpl("SYNTHESIZED_INIT_BLOCK") class InitializersLowering( diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/InnerClassesLowering.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/InnerClassesLowering.kt index bec7c759863..f640df43aa8 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/InnerClassesLowering.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/InnerClassesLowering.kt @@ -28,12 +28,6 @@ import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid import java.util.* -val InnerClassesPhase = makePhase( - ::InnerClassesLowering, - name = "InnerClasses", - description = "Move inner classes to toplevel" -) - class InnerClassesLowering(val context: BackendContext) : ClassLoweringPass { override fun lower(irClass: IrClass) { InnerClassTransformer(irClass).lowerInnerClass() @@ -175,12 +169,6 @@ class InnerClassesLowering(val context: BackendContext) : ClassLoweringPass { } } -val InnerClassConstructorCallsPhase = makePhase( - ::InnerClassConstructorCallsLowering, - name = "InnerClassConstructorCalls", - description = "Handle constructor calls for inner classes" -) - class InnerClassConstructorCallsLowering(val context: BackendContext) : BodyLoweringPass { override fun lower(irBody: IrBody) { irBody.transformChildrenVoid(object : IrElementTransformerVoid() { diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/KCallableNamePropertyLowering.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/KCallableNamePropertyLowering.kt index 79a8e393641..e02365ef3b5 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/KCallableNamePropertyLowering.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/KCallableNamePropertyLowering.kt @@ -38,12 +38,6 @@ import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid import org.jetbrains.kotlin.resolve.DescriptorUtils import org.jetbrains.kotlin.types.KotlinType -val KCallableNamePropertyPhase = makePhase( - ::KCallableNamePropertyLowering, - name = "KCallableNameProperty", - description = "Replace name references for callables with constants" -) - class KCallableNamePropertyLowering(val context: BackendContext) : FileLoweringPass { override fun lower(irFile: IrFile) { irFile.transformChildrenVoid(KCallableNamePropertyTransformer(this)) diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LocalDeclarationsLowering.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LocalDeclarationsLowering.kt index f856a28f0fe..665ec0e7495 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LocalDeclarationsLowering.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LocalDeclarationsLowering.kt @@ -40,20 +40,6 @@ import org.jetbrains.kotlin.name.NameUtils import org.jetbrains.kotlin.resolve.descriptorUtil.parents import java.util.* -val LocalDeclarationsPhase = makePhase( - ::LocalDeclarationsLowering, - name = "LocalDeclarations", - description = "Move local declarations to classes", - prerequisite = setOf(SharedVariablesPhase) -) - -val JvmLocalDeclarationsPhase = makePhase( - ::JvmLocalDeclarationsLowering, - name = "JvmLocalDeclarations", - description = "Move local declarations to classes", - prerequisite = setOf(SharedVariablesPhase) -) - interface LocalNameProvider { fun localName(descriptor: DeclarationDescriptor): String = descriptor.name.asString() @@ -71,18 +57,7 @@ val IrDeclaration.parents: Sequence object BOUND_VALUE_PARAMETER: IrDeclarationOriginImpl("BOUND_VALUE_PARAMETER") -class JvmLocalDeclarationsLowering(context: BackendContext) : - LocalDeclarationsLowering( - context, - object : LocalNameProvider { - override fun localName(descriptor: DeclarationDescriptor): String = - NameUtils.sanitizeAsJavaIdentifier(super.localName(descriptor)) - }, - Visibilities.PUBLIC, //TODO properly figure out visibility - true - ) - -open class LocalDeclarationsLowering( +class LocalDeclarationsLowering( val context: BackendContext, val localNameProvider: LocalNameProvider = LocalNameProvider.DEFAULT, val loweredConstructorVisibility: Visibility = Visibilities.PRIVATE, diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/PropertiesLowering.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/PropertiesLowering.kt index 3c0998e47a8..dc089494e5f 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/PropertiesLowering.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/PropertiesLowering.kt @@ -18,12 +18,6 @@ import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid import org.jetbrains.kotlin.utils.addIfNotNull import java.util.* -val PropertiesPhase = makePhase( - ::PropertiesLowering, - name = "Properties", - description = "move fields and accessors for properties to their classes" -) - class PropertiesLowering() : IrElementTransformerVoid(), FileLoweringPass { constructor(@Suppress("UNUSED_PARAMETER") context: BackendContext) : this() diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/SharedVariablesLowering.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/SharedVariablesLowering.kt index e922855c1e4..090f914d6db 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/SharedVariablesLowering.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/SharedVariablesLowering.kt @@ -34,12 +34,6 @@ import org.jetbrains.kotlin.ir.util.dump import org.jetbrains.kotlin.ir.visitors.* import java.util.* -val SharedVariablesPhase = makePhase( - ::SharedVariablesLowering, - name = "SharedVariables", - description = "Transform shared variables" -) - class SharedVariablesLowering(val context: BackendContext) : FunctionLoweringPass { override fun lower(irFunction: IrFunction) { SharedVariablesTransformer(irFunction).lowerSharedVariables() diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/TailrecLowering.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/TailrecLowering.kt index 4efb77bc7c4..17f4fc619d8 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/TailrecLowering.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/TailrecLowering.kt @@ -27,12 +27,6 @@ import org.jetbrains.kotlin.ir.util.getArgumentsWithIr import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid -val TailrecPhase = makePhase( - ::TailrecLowering, - name = "Tailrec", - description = "Handle tailrec calls" -) - /** * This pass lowers tail recursion calls in `tailrec` functions. * diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmLower.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmLower.kt index 6757cd641aa..5e11e498c43 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmLower.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmLower.kt @@ -18,63 +18,10 @@ package org.jetbrains.kotlin.backend.jvm import org.jetbrains.kotlin.backend.common.BackendContext import org.jetbrains.kotlin.backend.common.CompilerPhase -import org.jetbrains.kotlin.backend.common.IrFileEndPhase -import org.jetbrains.kotlin.backend.common.IrFileStartPhase -import org.jetbrains.kotlin.backend.common.lower.* -import org.jetbrains.kotlin.backend.jvm.lower.* import org.jetbrains.kotlin.ir.declarations.IrFile import org.jetbrains.kotlin.ir.util.PatchDeclarationParentsVisitor import org.jetbrains.kotlin.ir.visitors.acceptVoid -val jvmPhases = listOf( - IrFileStartPhase, - - JvmCoercionToUnitPhase, - FileClassPhase, - KCallableNamePropertyPhase, - - makeLateinitPhase(true), - - MoveCompanionObjectFieldsPhase, - ConstAndJvmFieldPropertiesPhase, - PropertiesPhase, - AnnotationPhase, - - makeDefaultArgumentStubPhase(false), - - InterfacePhase, - InterfaceDelegationPhase, - SharedVariablesPhase, - - makePatchParentsPhase(1), - - JvmLocalDeclarationsPhase, - CallableReferencePhase, - FunctionNVarargInvokePhase, - - InnerClassesPhase, - InnerClassConstructorCallsPhase, - - makePatchParentsPhase(2), - - EnumClassPhase, - ObjectClassPhase, - makeInitializersPhase(JvmLoweredDeclarationOrigin.CLASS_STATIC_INITIALIZER, true), - SingletonReferencesPhase, - SyntheticAccessorPhase, - BridgePhase, - JvmOverloadsAnnotationPhase, - JvmStaticAnnotationPhase, - StaticDefaultFunctionPhase, - - TailrecPhase, - ToArrayPhase, - - makePatchParentsPhase(3), - - IrFileEndPhase -) - fun makePatchParentsPhase(number: Int) = object : CompilerPhase { override val name: String = "PatchParents$number" override val description: String = "Patch parent references in IrFile, pass $number" @@ -90,8 +37,8 @@ class JvmLower(val context: JvmBackendContext) { fun lower(irFile: IrFile) { var state = irFile // TODO run lowering passes as callbacks in bottom-up visitor - - context.rootPhaseManager(irFile).apply { + + context.rootPhaseManager(irFile).apply { for (jvmPhase in jvmPhases) { state = phase(jvmPhase, context, state) } diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmLoweringPhase.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmLoweringPhase.kt deleted file mode 100644 index ce93cd6df12..00000000000 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmLoweringPhase.kt +++ /dev/null @@ -1,77 +0,0 @@ -/* - * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license - * that can be found in the license/LICENSE.txt file. - */ - -package org.jetbrains.kotlin.backend.jvm - -import org.jetbrains.kotlin.backend.common.* -import org.jetbrains.kotlin.config.CommonConfigurationKeys -import org.jetbrains.kotlin.ir.declarations.IrFile -import org.jetbrains.kotlin.ir.declarations.name -import org.jetbrains.kotlin.ir.util.dump -import kotlin.system.measureTimeMillis - -enum class BeforeOrAfter { BEFORE, AFTER } - -object JvmPhaseRunner : PhaseRunner { - override fun reportBefore(phase: CompilerPhase, depth: Int, context: JvmBackendContext, data: IrFile) { - if (phase in context.phases.toDumpStateBefore) { - dumpFile(data, phase, BeforeOrAfter.BEFORE) - } - } - - override fun runBody(phase: CompilerPhase, context: JvmBackendContext, source: IrFile): IrFile { - val runner = when { - phase === IrFileStartPhase -> ::justRun - phase === IrFileEndPhase -> ::justRun - (context.state.configuration.get(CommonConfigurationKeys.PROFILE_PHASES) == true) -> ::runAndProfile - else -> ::justRun - } - - context.inVerbosePhase = (phase in context.phases.verbose) - - val result = runner(phase, context, source) - - context.inVerbosePhase = false - - return result - } - - override fun reportAfter(phase: CompilerPhase, depth: Int, context: JvmBackendContext, data: IrFile) { - if (phase in context.phases.toDumpStateAfter) { - dumpFile(data, phase, BeforeOrAfter.AFTER) - } - } -} - -private fun runAndProfile(phase: CompilerPhase, context: JvmBackendContext, source: IrFile): IrFile { - var result: IrFile = source - val msec = measureTimeMillis { result = phase.invoke(context, source) } - println("${phase.description}: $msec msec") - return result -} - -private fun justRun(phase: CompilerPhase, context: JvmBackendContext, source: IrFile) = - phase.invoke(context, source) - -private fun separator(title: String) { - println("\n\n--- $title ----------------------\n") -} - -private fun dumpFile(irFile: IrFile, phase: CompilerPhase, beforeOrAfter: BeforeOrAfter) { - // Exclude nonsensical combinations - if (phase === IrFileStartPhase && beforeOrAfter == BeforeOrAfter.AFTER) return - if (phase === IrFileEndPhase && beforeOrAfter == BeforeOrAfter.BEFORE) return - - val title = when (phase) { - IrFileStartPhase -> "IR for ${irFile.name} at the start of lowering process" - IrFileEndPhase -> "IR for ${irFile.name} at the end of lowering process" - else -> { - val beforeOrAfterStr = beforeOrAfter.name.toLowerCase() - "IR for ${irFile.name} $beforeOrAfterStr ${phase.description}" - } - } - separator(title) - println(irFile.dump()) -} \ No newline at end of file diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmLoweringPhases.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmLoweringPhases.kt new file mode 100644 index 00000000000..06c2c2f079a --- /dev/null +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmLoweringPhases.kt @@ -0,0 +1,275 @@ +/* + * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.backend.jvm + +import org.jetbrains.kotlin.backend.common.BackendContext +import org.jetbrains.kotlin.backend.common.CompilerPhase +import org.jetbrains.kotlin.backend.common.lower.* +import org.jetbrains.kotlin.backend.common.makePhase +import org.jetbrains.kotlin.backend.common.runOnFilePostfix +import org.jetbrains.kotlin.backend.jvm.lower.* +import org.jetbrains.kotlin.descriptors.DeclarationDescriptor +import org.jetbrains.kotlin.descriptors.Visibilities +import org.jetbrains.kotlin.ir.declarations.IrFile +import org.jetbrains.kotlin.name.NameUtils + +object IrFileStartPhase : CompilerPhase { + override val name = "IrFileStart" + override val description = "State at start of IrFile lowering" + override val prerequisite = emptySet() + override fun invoke(context: BackendContext, input: IrFile) = input +} + +private fun makeJvmPhase( + lowering: (JvmBackendContext, IrFile) -> Unit, + description: String, + name: String, + prerequisite: Set> = emptySet() +) = makePhase(lowering, description, name, prerequisite) + +private val JvmCoercionToUnitPhase = makeJvmPhase( + { context, file -> JvmCoercionToUnitPatcher(context).lower(file) }, + name = "JvmCoercionToUnit", + description = "Insert conversions to unit after IrCalls where needed" +) + +private val FileClassPhase = makeJvmPhase( + { context, file -> FileClassLowering(context).lower(file) }, + name = "FileClass", + description = "Put file level function and property declaration into a class" +) + +private val KCallableNamePropertyPhase = makeJvmPhase( + { context, file -> KCallableNamePropertyLowering(context).lower(file) }, + name = "KCallableNameProperty", + description = "Replace name references for callables with constants" +) + +private val LateinitPhase = makeJvmPhase( + { context, file -> LateinitLowering(context, true).lower(file) }, + name = "Lateinit", + description = "Insert checks for lateinit field references" +) + +private val MoveCompanionObjectFieldsPhase = makeJvmPhase( + { context, file -> MoveCompanionObjectFieldsLowering(context).runOnFilePostfix(file) }, + name = "MoveCompanionObjectFields", + description = "Move companion object fields to static fields of companion's owner" +) + + +private val ConstAndJvmFieldPropertiesPhase = makeJvmPhase( + { context, file -> ConstAndJvmFieldPropertiesLowering(context).lower(file) }, + name = "ConstAndJvmFieldProperties", + description = "Substitute calls to const and Jvm>Field properties with const/field access" +) + + +private val PropertiesPhase = makeJvmPhase( + { context, file -> PropertiesLowering(context).lower(file) }, + name = "Properties", + description = "move fields and accessors for properties to their classes" +) + + +private val AnnotationPhase = makeJvmPhase( + { _, file -> AnnotationLowering().lower(file) }, + name = "Annotation", + description = "Remove constructors from annotation classes" +) + +private val DefaultArgumentStubPhase = makeJvmPhase( + { context, file -> DefaultArgumentStubGenerator(context, false).lower(file) }, + name = "DefaultArgumentsStubGenerator", + description = "Generate synthetic stubs for functions with default parameter values" +) + +private val InterfacePhase = makeJvmPhase( + { context, file -> InterfaceLowering(context).lower(file) }, + name = "Interface", + description = "Move default implementations of interface members to DefaultImpls class" +) + +private val InterfaceDelegationPhase = makeJvmPhase( + { context, file -> InterfaceDelegationLowering(context).lower(file) }, + name = "InterfaceDelegation", + description = "Delegate calls to interface members with default implementations to DefaultImpls" +) + +private val SharedVariablesPhase = makeJvmPhase( + { context, file -> SharedVariablesLowering(context).lower(file) }, + name = "SharedVariables", + description = "Transform shared variables" +) + +private val LocalDeclarationsPhase = makeJvmPhase( + { context, data -> + LocalDeclarationsLowering(context, object : LocalNameProvider { + override fun localName(descriptor: DeclarationDescriptor): String = + NameUtils.sanitizeAsJavaIdentifier(super.localName(descriptor)) + }, Visibilities.PUBLIC, true).lower(data) + }, + name = "JvmLocalDeclarations", + description = "Move local declarations to classes", + prerequisite = setOf(SharedVariablesPhase) +) + +private val CallableReferencePhase = makeJvmPhase( + { context, file -> CallableReferenceLowering(context).lower(file) }, + name = "CallableReference", + description = "Handle callable references" +) + +private val FunctionNVarargInvokePhase = makeJvmPhase( + { context, file -> FunctionNVarargInvokeLowering(context).lower(file) }, + name = "FunctionNVarargInvoke", + description = "Handle invoke functions with large number of arguments" +) + + +private val InnerClassesPhase = makeJvmPhase( + { context, file -> InnerClassesLowering(context).lower(file) }, + name = "InnerClasses", + description = "Move inner classes to toplevel" +) + +private val InnerClassConstructorCallsPhase = makeJvmPhase( + { context, file -> InnerClassConstructorCallsLowering(context).lower(file) }, + name = "InnerClassConstructorCalls", + description = "Handle constructor calls for inner classes" +) + + +private val EnumClassPhase = makeJvmPhase( + { context, file -> EnumClassLowering(context).lower(file) }, + name = "EnumClass", + description = "Handle enum classes" +) + + +private val ObjectClassPhase = makeJvmPhase( + { context, file -> ObjectClassLowering(context).lower(file) }, + name = "ObjectClass", + description = "Handle object classes" +) + +private val InitializersPhase = makeJvmPhase( + { context, file -> InitializersLowering(context, JvmLoweredDeclarationOrigin.CLASS_STATIC_INITIALIZER, true).lower(file) }, + name = "Initializers", + description = "Handle initializer statements" +) + + +private val SingletonReferencesPhase = makeJvmPhase( + { context, file -> SingletonReferencesLowering(context).lower(file) }, + name = "SingletonReferences", + description = "Handle singleton references" +) + + +private val SyntheticAccessorPhase = makeJvmPhase( + { context, file -> SyntheticAccessorLowering(context).lower(file) }, + name = "SyntheticAccessor", + description = "Introduce synthetic accessors", + prerequisite = setOf(ObjectClassPhase) +) + +private val BridgePhase = makeJvmPhase( + { context, file -> BridgeLowering(context).lower(file) }, + name = "Bridge", + description = "Generate bridges" +) + + +private val JvmOverloadsAnnotationPhase = makeJvmPhase( + { context, file -> JvmOverloadsAnnotationLowering(context).lower(file) }, + name = "JvmOverloadsAnnotation", + description = "Handle JvmOverloads annotations" +) + + +private val JvmStaticAnnotationPhase = makeJvmPhase( + { context, file -> JvmStaticAnnotationLowering(context).lower(file) }, + name = "JvmStaticAnnotation", + description = "Handle JvmStatic annotations" +) + + +private val StaticDefaultFunctionPhase = makeJvmPhase( + { _, file -> StaticDefaultFunctionLowering().lower(file) }, + name = "StaticDefaultFunction", + description = "Generate static functions for default parameters" +) + + +private val TailrecPhase = makeJvmPhase( + { context, file -> TailrecLowering(context).lower(file) }, + name = "Tailrec", + description = "Handle tailrec calls" +) + + +private val ToArrayPhase = makeJvmPhase( + { context, file -> ToArrayLowering(context).lower(file) }, + name = "ToArray", + description = "Handle toArray functions" +) + +object IrFileEndPhase : CompilerPhase { + override val name = "IrFileEnd" + override val description = "State at end of IrFile lowering" + override val prerequisite = emptySet() + override fun invoke(context: BackendContext, input: IrFile) = input +} + +val jvmPhases = listOf( + IrFileStartPhase, + + JvmCoercionToUnitPhase, + FileClassPhase, + KCallableNamePropertyPhase, + + LateinitPhase, + + MoveCompanionObjectFieldsPhase, + ConstAndJvmFieldPropertiesPhase, + PropertiesPhase, + AnnotationPhase, + + DefaultArgumentStubPhase, + + InterfacePhase, + InterfaceDelegationPhase, + SharedVariablesPhase, + + makePatchParentsPhase(1), + + LocalDeclarationsPhase, + CallableReferencePhase, + FunctionNVarargInvokePhase, + + InnerClassesPhase, + InnerClassConstructorCallsPhase, + + makePatchParentsPhase(2), + + EnumClassPhase, + ObjectClassPhase, + InitializersPhase, + SingletonReferencesPhase, + SyntheticAccessorPhase, + BridgePhase, + JvmOverloadsAnnotationPhase, + JvmStaticAnnotationPhase, + StaticDefaultFunctionPhase, + + TailrecPhase, + ToArrayPhase, + + makePatchParentsPhase(3), + + IrFileEndPhase +) diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmPhaseRunner.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmPhaseRunner.kt new file mode 100644 index 00000000000..d8b9bb87180 --- /dev/null +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmPhaseRunner.kt @@ -0,0 +1,19 @@ +/* + * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.backend.jvm + +import org.jetbrains.kotlin.backend.common.DefaultIrPhaseRunner +import org.jetbrains.kotlin.ir.declarations.IrFile +import org.jetbrains.kotlin.ir.declarations.name + +object JvmPhaseRunner : DefaultIrPhaseRunner() { + override val startPhaseMarker = IrFileStartPhase + override val endPhaseMarker = IrFileEndPhase + + override fun phases(context: JvmBackendContext) = context.phases + override fun elementName(input: IrFile) = input.name + override fun configuration(context: JvmBackendContext) = context.state.configuration +} \ No newline at end of file diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/AnnotationLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/AnnotationLowering.kt index e6921e3e4dc..a6526ad3bd4 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/AnnotationLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/AnnotationLowering.kt @@ -12,12 +12,6 @@ import org.jetbrains.kotlin.ir.declarations.IrClass import org.jetbrains.kotlin.ir.declarations.IrConstructor import org.jetbrains.kotlin.ir.util.isAnnotationClass -val AnnotationPhase = makePhase( - ::AnnotationLowering, - name = "Annotation", - description = "Remove constructors from annotation classes" -) - class AnnotationLowering() : ClassLoweringPass { constructor(@Suppress("UNUSED_PARAMETER") context: BackendContext) : this() diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/BridgeLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/BridgeLowering.kt index 8187ed4f898..f8090981e03 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/BridgeLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/BridgeLowering.kt @@ -60,12 +60,6 @@ import org.jetbrains.org.objectweb.asm.Opcodes.* import org.jetbrains.org.objectweb.asm.Type import org.jetbrains.org.objectweb.asm.commons.Method -val BridgePhase = makePhase( - ::BridgeLowering, - name = "Bridge", - description = "Generate bridges" -) - class BridgeLowering(val context: JvmBackendContext) : ClassLoweringPass { private val state = context.state diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/CallableReferenceLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/CallableReferenceLowering.kt index 9b4798ebb58..7536e6b56bc 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/CallableReferenceLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/CallableReferenceLowering.kt @@ -60,12 +60,6 @@ import org.jetbrains.kotlin.types.Variance import org.jetbrains.org.objectweb.asm.Opcodes import org.jetbrains.org.objectweb.asm.Type -val CallableReferencePhase = makePhase( - ::CallableReferenceLowering, - name = "CallableReference", - description = "Handle callable references" -) - //Hack implementation to support CR java types in lower class CrIrType(val type: Type) : IrType { override val annotations = emptyList() diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/ConstAndJvmFieldPropertiesLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/ConstAndJvmFieldPropertiesLowering.kt index db987aa9629..e8689db0a22 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/ConstAndJvmFieldPropertiesLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/ConstAndJvmFieldPropertiesLowering.kt @@ -22,12 +22,6 @@ import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid import org.jetbrains.kotlin.load.java.JvmAbi.JVM_FIELD_ANNOTATION_FQ_NAME import org.jetbrains.kotlin.synthetic.SyntheticJavaPropertyDescriptor -val ConstAndJvmFieldPropertiesPhase = makePhase( - ::ConstAndJvmFieldPropertiesLowering, - name = "ConstAndJvmFieldProperties", - description = "Substitute calls to const and Jvm>Field properties with const/field access" -) - class ConstAndJvmFieldPropertiesLowering(val context: CommonBackendContext) : IrElementTransformerVoid(), FileLoweringPass { override fun lower(irFile: IrFile) { irFile.transformChildrenVoid(this) diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/EnumClassLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/EnumClassLowering.kt index eb91dbfcdda..e89031fcecc 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/EnumClassLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/EnumClassLowering.kt @@ -33,12 +33,6 @@ import org.jetbrains.kotlin.types.* import org.jetbrains.org.objectweb.asm.Opcodes import java.util.* -val EnumClassPhase = makePhase( - ::EnumClassLowering, - name = "EnumClass", - description = "Handle enum classes" -) - class EnumClassLowering(val context: JvmBackendContext) : ClassLoweringPass { override fun lower(irClass: IrClass) { if (!irClass.isEnumClass) return diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/FileClassLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/FileClassLowering.kt index 44a35beae86..4148967835d 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/FileClassLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/FileClassLowering.kt @@ -34,12 +34,6 @@ import org.jetbrains.kotlin.psi2ir.PsiSourceManager import org.jetbrains.kotlin.resolve.source.KotlinSourceElement import java.util.* -val FileClassPhase = makePhase( - ::FileClassLowering, - name = "FileClass", - description = "Put file level function and property declaration into a class" -) - class FileClassLowering(val context: JvmBackendContext) : FileLoweringPass { override fun lower(irFile: IrFile) { val classes = ArrayList() diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/FunctionNVarargInvokeLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/FunctionNVarargInvokeLowering.kt index 42e42dff0b2..32080b5e992 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/FunctionNVarargInvokeLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/FunctionNVarargInvokeLowering.kt @@ -30,12 +30,6 @@ import org.jetbrains.kotlin.ir.util.findDeclaration import org.jetbrains.kotlin.ir.util.isSubclassOf import org.jetbrains.kotlin.name.Name -val FunctionNVarargInvokePhase = makePhase( - ::FunctionNVarargInvokeLowering, - name = "FunctionNVarargInvoke", - description = "Handle invoke functions with large number of arguments" -) - class FunctionNVarargInvokeLowering(var context: JvmBackendContext) : ClassLoweringPass { override fun lower(irClass: IrClass) { diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/InterfaceDelegationLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/InterfaceDelegationLowering.kt index f86e9e64cbd..572327f410c 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/InterfaceDelegationLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/InterfaceDelegationLowering.kt @@ -29,12 +29,6 @@ import org.jetbrains.kotlin.ir.util.createParameterDeclarations import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid -val InterfaceDelegationPhase = makePhase( - ::InterfaceDelegationLowering, - name = "InterfaceDelegation", - description = "Delegate calls to interface members with default implementations to DefaultImpls" -) - class InterfaceDelegationLowering(val context: JvmBackendContext) : IrElementTransformerVoid(), ClassLoweringPass { val state: GenerationState = context.state diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/InterfaceLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/InterfaceLowering.kt index 6085fdebd9c..024d697f543 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/InterfaceLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/InterfaceLowering.kt @@ -28,12 +28,6 @@ import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.types.KotlinType import org.jetbrains.org.objectweb.asm.Opcodes -val InterfacePhase = makePhase( - ::InterfaceLowering, - name = "Interface", - description = "Move default implementations of interface members to DefaultImpls class" -) - class InterfaceLowering(val context: JvmBackendContext) : IrElementTransformerVoid(), ClassLoweringPass { val state = context.state diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmCoercionToUnitPatcher.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmCoercionToUnitPatcher.kt index 82df444f1c3..af75e063867 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmCoercionToUnitPatcher.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmCoercionToUnitPatcher.kt @@ -17,12 +17,6 @@ import org.jetbrains.kotlin.ir.util.TypeTranslator import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid import org.jetbrains.kotlin.psi2ir.transformations.InsertImplicitCasts -val JvmCoercionToUnitPhase = makePhase( - ::JvmCoercionToUnitPatcher, - name = "JvmCoercionToUnit", - description = "Insert conversions to unit after IrCalls where needed" -) - class JvmCoercionToUnitPatcher(val context: JvmBackendContext) : InsertImplicitCasts( context.builtIns, context.irBuiltIns, diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmOverloadsAnnotationLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmOverloadsAnnotationLowering.kt index 6b40047dcf6..28682170366 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmOverloadsAnnotationLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmOverloadsAnnotationLowering.kt @@ -35,12 +35,6 @@ import org.jetbrains.kotlin.ir.util.deepCopyWithSymbols import org.jetbrains.kotlin.resolve.calls.components.hasDefaultValue import org.jetbrains.kotlin.resolve.jvm.annotations.findJvmOverloadsAnnotation -val JvmOverloadsAnnotationPhase = makePhase( - ::JvmOverloadsAnnotationLowering, - name = "JvmOverloadsAnnotation", - description = "Handle JvmOverloads annotations" -) - class JvmOverloadsAnnotationLowering(val context: JvmBackendContext) : ClassLoweringPass { override fun lower(irClass: IrClass) { diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmStaticAnnotationLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmStaticAnnotationLowering.kt index 18fa5a0c280..f45b56fe11a 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmStaticAnnotationLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmStaticAnnotationLowering.kt @@ -36,12 +36,6 @@ import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.annotations.JVM_STATIC_ANNOTATION_FQ_NAME import org.jetbrains.org.objectweb.asm.Opcodes -val JvmStaticAnnotationPhase = makePhase( - ::JvmStaticAnnotationLowering, - name = "JvmStaticAnnotation", - description = "Handle JvmStatic annotations" -) - /* * For @JvmStatic functions within companion objects of classes, we synthesize proxy static functions that redirect * to the actual implementation. diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/MoveCompanionObjectFieldsLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/MoveCompanionObjectFieldsLowering.kt index 45997c4d54e..e45085a35d6 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/MoveCompanionObjectFieldsLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/MoveCompanionObjectFieldsLowering.kt @@ -33,12 +33,6 @@ import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid import org.jetbrains.kotlin.load.java.JvmAbi.JVM_FIELD_ANNOTATION_FQ_NAME import org.jetbrains.kotlin.name.Name -val MoveCompanionObjectFieldsPhase = makePhase( - ::MoveCompanionObjectFieldsLowering, - name = "MoveCompanionObjectFields", - description = "Move companion object fields to static fields of companion's owner" -) - class MoveCompanionObjectFieldsLowering(val context: CommonBackendContext) : ClassLoweringPass { override fun lower(irClass: IrClass) { val fieldReplacementMap = mutableMapOf() diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/ObjectClassLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/ObjectClassLowering.kt index a5eece17f13..69bff5c9b01 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/ObjectClassLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/ObjectClassLowering.kt @@ -25,12 +25,6 @@ import org.jetbrains.kotlin.ir.types.IrType import org.jetbrains.kotlin.ir.util.defaultType import org.jetbrains.kotlin.ir.util.isObject -val ObjectClassPhase = makePhase( - ::ObjectClassLowering, - name = "ObjectClass", - description = "Handle object classes" -) - class ObjectClassLowering(val context: JvmBackendContext) : IrElementTransformerVoidWithContext(), FileLoweringPass { private var pendingTransformations = mutableListOf>() diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/SingletonReferencesLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/SingletonReferencesLowering.kt index 800881e2643..e727b83ff21 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/SingletonReferencesLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/SingletonReferencesLowering.kt @@ -16,12 +16,6 @@ import org.jetbrains.kotlin.ir.expressions.impl.IrGetFieldImpl import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid -val SingletonReferencesPhase = makePhase( - ::SingletonReferencesLowering, - name = "SingletonReferences", - description = "Handle singleton references" -) - class SingletonReferencesLowering(val context: JvmBackendContext) : BodyLoweringPass, IrElementTransformerVoid() { override fun lower(irBody: IrBody) { irBody.transformChildrenVoid(this) diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/StaticDefaultFunctionLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/StaticDefaultFunctionLowering.kt index f468765169a..c20025a21e7 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/StaticDefaultFunctionLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/StaticDefaultFunctionLowering.kt @@ -27,12 +27,6 @@ import org.jetbrains.kotlin.ir.declarations.IrClass import org.jetbrains.kotlin.ir.declarations.IrFunction import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid -val StaticDefaultFunctionPhase = makePhase( - ::StaticDefaultFunctionLowering, - name = "StaticDefaultFunction", - description = "Generate static functions for default parameters" -) - class StaticDefaultFunctionLowering() : IrElementTransformerVoid(), ClassLoweringPass { constructor(@Suppress("UNUSED_PARAMETER") context: BackendContext) : this() diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/SyntheticAccessorLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/SyntheticAccessorLowering.kt index 470266b448f..20ff576603f 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/SyntheticAccessorLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/SyntheticAccessorLowering.kt @@ -37,13 +37,6 @@ import org.jetbrains.kotlin.load.java.JvmAbi import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.DescriptorUtils -val SyntheticAccessorPhase = makePhase( - ::SyntheticAccessorLowering, - name = "SyntheticAccessor", - description = "Introduce synthetic accessors", - prerequisite = setOf(ObjectClassPhase) -) - class SyntheticAccessorLowering(val context: JvmBackendContext) : IrElementTransformerVoidWithContext(), FileLoweringPass { private val pendingTransformations = mutableListOf>() private val inlinedLambdasCollector = InlinedLambdasCollector() diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/ToArrayLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/ToArrayLowering.kt index 670d1bb5ced..fc5c392af0d 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/ToArrayLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/ToArrayLowering.kt @@ -43,12 +43,6 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns import org.jetbrains.kotlin.resolve.descriptorUtil.getAllSuperclassesWithoutAny import org.jetbrains.kotlin.types.Variance -val ToArrayPhase = makePhase( - ::ToArrayLowering, - name = "ToArray", - description = "Handle toArray functions" -) - class ToArrayLowering(private val context: JvmBackendContext) : ClassLoweringPass { override fun lower(irClass: IrClass) {