From 14137cb0139813ea1e172a735f5c0eb77db9c33a Mon Sep 17 00:00:00 2001 From: Mark Punzalan Date: Thu, 8 Oct 2020 06:56:35 +0000 Subject: [PATCH] ForLoopsLowering: Remove `additionalNotEmptyCondition` as it is no longer used in UntilHandler. --- .../backend/common/lower/RangeContainsLowering.kt | 15 +-------------- .../backend/common/lower/loops/HeaderInfo.kt | 11 +++-------- .../backend/common/lower/loops/HeaderProcessor.kt | 5 +---- .../common/lower/loops/handlers/StepHandler.kt | 1 - 4 files changed, 5 insertions(+), 27 deletions(-) diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/RangeContainsLowering.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/RangeContainsLowering.kt index c59775538d7..942f65d1fdf 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/RangeContainsLowering.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/RangeContainsLowering.kt @@ -128,7 +128,6 @@ private class Transformer( val shouldUpperComeFirst: Boolean val useCompareTo: Boolean val isNumericRange: Boolean - val additionalNotEmptyCondition: IrExpression? val additionalStatements = mutableListOf() when (headerInfo) { @@ -181,7 +180,6 @@ private class Transformer( useCompareTo = headerInfo.progressionType is UnsignedProgressionType isUpperInclusive = headerInfo.isLastInclusive isNumericRange = true - additionalNotEmptyCondition = headerInfo.additionalNotEmptyCondition } is FloatingPointRangeHeaderInfo -> { lower = headerInfo.start @@ -190,7 +188,6 @@ private class Transformer( shouldUpperComeFirst = false useCompareTo = false isNumericRange = true - additionalNotEmptyCondition = null } is ComparableRangeInfo -> { lower = headerInfo.start @@ -199,7 +196,6 @@ private class Transformer( shouldUpperComeFirst = false useCompareTo = true isNumericRange = false - additionalNotEmptyCondition = null } else -> return null } @@ -342,16 +338,7 @@ private class Transformer( if (useLowerClauseOnLeftSide) lowerClause else upperClause, if (useLowerClauseOnLeftSide) upperClause else lowerClause, origin - ).let { - if (additionalNotEmptyCondition != null) { - // Add additional condition, currently used in `until` ranges (see UntilHandler.kt). - // NOTE: The additional condition must be on the RIGHT side of the &&, to guarantee that the expressions for the bounds - // and argument are evaluated as designed. (See big comment above on expressions with side effects and temp variables.) - context.andand(it, additionalNotEmptyCondition) - } else { - it - } - } + ) return if (additionalStatements.isEmpty()) { contains } else { diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/loops/HeaderInfo.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/loops/HeaderInfo.kt index 4e7d00a1bdf..d3ee9fa93ba 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/loops/HeaderInfo.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/loops/HeaderInfo.kt @@ -70,8 +70,7 @@ internal sealed class NumericHeaderInfo( val isLastInclusive: Boolean, val canCacheLast: Boolean, val isReversed: Boolean, - val direction: ProgressionDirection, - val additionalNotEmptyCondition: IrExpression? + val direction: ProgressionDirection ) : HeaderInfo() /** Information about a for-loop over a progression. */ @@ -84,14 +83,12 @@ internal class ProgressionHeaderInfo( isReversed: Boolean = false, canOverflow: Boolean? = null, direction: ProgressionDirection, - additionalNotEmptyCondition: IrExpression? = null, val additionalStatements: List = listOf() ) : NumericHeaderInfo( progressionType, first, last, step, isLastInclusive, canCacheLast = true, isReversed = isReversed, - direction = direction, - additionalNotEmptyCondition = additionalNotEmptyCondition + direction = direction ) { val canOverflow: Boolean by lazy { @@ -162,7 +159,6 @@ internal class ProgressionHeaderInfo( step = step.negate(), isReversed = !isReversed, direction = direction.asReversed(), - additionalNotEmptyCondition = additionalNotEmptyCondition, additionalStatements = additionalStatements ) } else { @@ -189,8 +185,7 @@ internal class IndexedGetHeaderInfo( isLastInclusive = false, canCacheLast = canCacheLast, isReversed = false, - direction = ProgressionDirection.INCREASING, - additionalNotEmptyCondition = null + direction = ProgressionDirection.INCREASING ) { // Technically one can easily iterate over an array in reverse by swapping first/last and // negating the step. However, Array.reversed() and Array.reversedArray() return a collection diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/loops/HeaderProcessor.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/loops/HeaderProcessor.kt index bd0b9c53ddf..658545d39e5 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/loops/HeaderProcessor.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/loops/HeaderProcessor.kt @@ -346,10 +346,7 @@ internal class ProgressionLoopHeader( } val loopCondition = buildLoopCondition(this@with) - // Combine with the additional "not empty" condition, if any. - val notEmptyCheck = - irIfThen(headerInfo.additionalNotEmptyCondition?.let { context.andand(it, loopCondition) } ?: loopCondition, newLoop) - LoopReplacement(newLoop, notEmptyCheck) + LoopReplacement(newLoop, irIfThen(loopCondition, newLoop)) } } diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/loops/handlers/StepHandler.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/loops/handlers/StepHandler.kt index ef79ab2d6b8..1ee3346764e 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/loops/handlers/StepHandler.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/loops/handlers/StepHandler.kt @@ -277,7 +277,6 @@ internal class StepHandler( step = finalStepExpression, isReversed = nestedInfo.isReversed, additionalStatements = additionalStatements, - additionalNotEmptyCondition = nestedInfo.additionalNotEmptyCondition, direction = nestedInfo.direction ) }