Use InContinuousRangeExpressionGenerator for primitive range intrinsics

compiler/backend/src/org/jetbrains/kotlin/codegen/RangeCodegenUtil.kt

@@ -191,19 +191,24 @@ private fun isTopLevelInPackage(descriptor: DeclarationDescriptor, name: String,
     return packageName == packageFqName
 }
 
-fun getAsmRangeElementTypeForPrimitiveRange(rangeCallee: CallableDescriptor): Type {
+fun getAsmRangeElementTypeForPrimitiveRangeOrProgression(rangeCallee: CallableDescriptor): Type {
     val rangeType = rangeCallee.returnType!!
 
     getPrimitiveRangeElementType(rangeType)?.let {
         return AsmTypes.valueTypeForPrimitive(it)
     }
 
-    val floatingPointElementType = getClosedFloatingPointRangeElementType(rangeType) ?:
+    getPrimitiveProgressionElementType(rangeType)?.let {
-                                   throw AssertionError("Unexpected range type: $rangeType")
+        return AsmTypes.valueTypeForPrimitive(it)
-
-    return when {
-        KotlinBuiltIns.isDouble(floatingPointElementType) -> Type.DOUBLE_TYPE
-        KotlinBuiltIns.isFloat(floatingPointElementType) -> Type.FLOAT_TYPE
-        else -> throw AssertionError("Unexpected ClosedFloatingPointRange element type: $floatingPointElementType")
     }
+
+    getClosedFloatingPointRangeElementType(rangeType)?.let {
+        when {
+            KotlinBuiltIns.isDouble(it) -> return Type.DOUBLE_TYPE
+            KotlinBuiltIns.isFloat(it) -> return Type.FLOAT_TYPE
+            else -> {}
+        }
+    }
+
+    throw AssertionError("Unexpected range type: $rangeType")
 }

compiler/backend/src/org/jetbrains/kotlin/codegen/codegenUtil.kt

@@ -413,4 +413,10 @@ fun extractReificationArgument(type: KotlinType): Pair<TypeParameterDescriptor,
 }
 
 fun unwrapInitialSignatureDescriptor(function: FunctionDescriptor): FunctionDescriptor =
-        function.initialSignatureDescriptor ?: function
+        function.initialSignatureDescriptor ?: function
+
+fun ExpressionCodegen.generateCallReceiver(rangeCall: ResolvedCall<out CallableDescriptor>): StackValue =
+        generateReceiverValue(rangeCall.extensionReceiver ?: rangeCall.dispatchReceiver!!, false)
+
+fun ExpressionCodegen.generateCallSingleArgument(rangeCall: ResolvedCall<out CallableDescriptor>): StackValue =
+        gen(ExpressionCodegen.getSingleArgumentExpression(rangeCall)!!)

compiler/backend/src/org/jetbrains/kotlin/codegen/range/ArrayIndicesRangeValue.kt

@@ -17,17 +17,38 @@
 package org.jetbrains.kotlin.codegen.range
 
 import org.jetbrains.kotlin.codegen.ExpressionCodegen
+import org.jetbrains.kotlin.codegen.StackValue
+import org.jetbrains.kotlin.codegen.generateCallReceiver
+import org.jetbrains.kotlin.codegen.range.comparison.getComparisonGeneratorForPrimitiveType
 import org.jetbrains.kotlin.codegen.range.forLoop.ForInArrayIndicesRangeLoopGenerator
-import org.jetbrains.kotlin.codegen.range.inExpression.InArrayIndicesGenerator
+import org.jetbrains.kotlin.codegen.range.inExpression.InContinuousRangeExpressionGenerator
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.psi.KtForExpression
 import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
+import org.jetbrains.kotlin.types.KotlinType
+import org.jetbrains.org.objectweb.asm.Type
+
+class ArrayIndicesRangeValue(
+        codegen: ExpressionCodegen,
+        rangeCall: ResolvedCall<out CallableDescriptor>
+): PrimitiveNumberRangeIntrinsicRangeValue(rangeCall) {
+    private val comparisonGenerator = getComparisonGeneratorForPrimitiveType(asmElementType)
+    private val expectedReceiverType: KotlinType = ExpressionCodegen.getExpectedReceiverType(rangeCall)
+
+    private val boundedValue =
+            SimpleBoundedValue(
+                    codegen, rangeCall,
+                    lowBound = StackValue.constant(0, asmElementType),
+                    highBound = StackValue.operation(Type.INT_TYPE) { v ->
+                        codegen.generateCallReceiver(rangeCall).put(codegen.asmType(expectedReceiverType), v)
+                        v.arraylength()
+                    }
+            )
 
-class ArrayIndicesRangeValue(rangeCall: ResolvedCall<out CallableDescriptor>): PrimitiveNumberRangeIntrinsicRangeValue(rangeCall) {
     override fun createForLoopGenerator(codegen: ExpressionCodegen, forExpression: KtForExpression) =
             ForInArrayIndicesRangeLoopGenerator(codegen, forExpression, rangeCall)
 
     override fun createIntrinsicInExpressionGenerator(codegen: ExpressionCodegen, operatorReference: KtSimpleNameExpression) =
-            InArrayIndicesGenerator(codegen, operatorReference, rangeCall)
+            InContinuousRangeExpressionGenerator(operatorReference, boundedValue, comparisonGenerator)
 }

compiler/backend/src/org/jetbrains/kotlin/codegen/range/CharSequenceIndicesRangeValue.kt

@@ -17,17 +17,38 @@
 package org.jetbrains.kotlin.codegen.range
 
 import org.jetbrains.kotlin.codegen.ExpressionCodegen
+import org.jetbrains.kotlin.codegen.StackValue
+import org.jetbrains.kotlin.codegen.generateCallReceiver
+import org.jetbrains.kotlin.codegen.range.comparison.getComparisonGeneratorForPrimitiveType
 import org.jetbrains.kotlin.codegen.range.forLoop.ForInCharSequenceIndicesRangeLoopGenerator
-import org.jetbrains.kotlin.codegen.range.inExpression.InCharSequenceIndicesGenerator
+import org.jetbrains.kotlin.codegen.range.inExpression.InContinuousRangeExpressionGenerator
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.psi.KtForExpression
 import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
+import org.jetbrains.kotlin.types.KotlinType
+import org.jetbrains.org.objectweb.asm.Type
+
+class CharSequenceIndicesRangeValue(
+        codegen: ExpressionCodegen,
+        rangeCall: ResolvedCall<out CallableDescriptor>
+): PrimitiveNumberRangeIntrinsicRangeValue(rangeCall) {
+    private val comparisonGenerator = getComparisonGeneratorForPrimitiveType(asmElementType)
+    private val expectedReceiverType: KotlinType = ExpressionCodegen.getExpectedReceiverType(rangeCall)
+
+    private val boundedValue =
+            SimpleBoundedValue(
+                    codegen, rangeCall,
+                    lowBound = StackValue.constant(0, asmElementType),
+                    highBound = StackValue.operation(Type.INT_TYPE) { v ->
+                        codegen.generateCallReceiver(rangeCall).put(codegen.asmType(expectedReceiverType), v)
+                        v.invokeinterface("java/lang/CharSequence", "length", "()I")
+                    }
+            )
 
-class CharSequenceIndicesRangeValue(rangeCall: ResolvedCall<out CallableDescriptor>): PrimitiveNumberRangeIntrinsicRangeValue(rangeCall) {
     override fun createForLoopGenerator(codegen: ExpressionCodegen, forExpression: KtForExpression) =
             ForInCharSequenceIndicesRangeLoopGenerator(codegen, forExpression, rangeCall)
 
     override fun createIntrinsicInExpressionGenerator(codegen: ExpressionCodegen, operatorReference: KtSimpleNameExpression) =
-            InCharSequenceIndicesGenerator(codegen, operatorReference, rangeCall)
+            InContinuousRangeExpressionGenerator(operatorReference, boundedValue, comparisonGenerator)
 }

compiler/backend/src/org/jetbrains/kotlin/codegen/range/CollectionIndicesRangeValue.kt

@@ -17,17 +17,38 @@
 package org.jetbrains.kotlin.codegen.range
 
 import org.jetbrains.kotlin.codegen.ExpressionCodegen
+import org.jetbrains.kotlin.codegen.StackValue
+import org.jetbrains.kotlin.codegen.generateCallReceiver
+import org.jetbrains.kotlin.codegen.range.comparison.getComparisonGeneratorForPrimitiveType
 import org.jetbrains.kotlin.codegen.range.forLoop.ForInCollectionIndicesRangeLoopGenerator
-import org.jetbrains.kotlin.codegen.range.inExpression.InCollectionIndicesGenerator
+import org.jetbrains.kotlin.codegen.range.inExpression.InContinuousRangeExpressionGenerator
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.psi.KtForExpression
 import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
+import org.jetbrains.kotlin.types.KotlinType
+import org.jetbrains.org.objectweb.asm.Type
+
+class CollectionIndicesRangeValue(
+        codegen: ExpressionCodegen,
+        rangeCall: ResolvedCall<out CallableDescriptor>
+): PrimitiveNumberRangeIntrinsicRangeValue(rangeCall) {
+    private val comparisonGenerator = getComparisonGeneratorForPrimitiveType(asmElementType)
+    private val expectedReceiverType: KotlinType = ExpressionCodegen.getExpectedReceiverType(rangeCall)
+
+    private val boundedValue =
+            SimpleBoundedValue(
+                    codegen, rangeCall,
+                    lowBound = StackValue.constant(0, asmElementType),
+                    highBound = StackValue.operation(Type.INT_TYPE) { v ->
+                        codegen.generateCallReceiver(rangeCall).put(codegen.asmType(expectedReceiverType), v)
+                        v.invokeinterface("java/util/Collection", "size", "()I")
+                    }
+            )
 
-class CollectionIndicesRangeValue(rangeCall: ResolvedCall<out CallableDescriptor>): PrimitiveNumberRangeIntrinsicRangeValue(rangeCall) {
     override fun createForLoopGenerator(codegen: ExpressionCodegen, forExpression: KtForExpression) =
             ForInCollectionIndicesRangeLoopGenerator(codegen, forExpression, rangeCall)
 
     override fun createIntrinsicInExpressionGenerator(codegen: ExpressionCodegen, operatorReference: KtSimpleNameExpression) =
-            InCollectionIndicesGenerator(codegen, operatorReference, rangeCall)
+            InContinuousRangeExpressionGenerator(operatorReference, boundedValue, comparisonGenerator)
 }

compiler/backend/src/org/jetbrains/kotlin/codegen/range/ComparableRangeLiteralRangeValue.kt

@@ -32,10 +32,10 @@ import org.jetbrains.org.objectweb.asm.Type
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
 
 class ComparableRangeLiteralRangeValue(
-        private val codegen: ExpressionCodegen,
+        codegen: ExpressionCodegen,
         rangeCall: ResolvedCall<out CallableDescriptor>
 ) : CallIntrinsicRangeValue(rangeCall) {
-    private val boundedValue = SimpleBoundedValue(codegen, rangeCall, isLowInclusive = true, isHighInclusive = true)
+    private val boundedValue = SimpleBoundedValue(codegen, rangeCall)
 
     override fun createForLoopGenerator(codegen: ExpressionCodegen, forExpression: KtForExpression) =
             IteratorForLoopGenerator(codegen, forExpression)

compiler/backend/src/org/jetbrains/kotlin/codegen/range/DownToProgressionRangeValue.kt

@@ -17,17 +17,32 @@
 package org.jetbrains.kotlin.codegen.range
 
 import org.jetbrains.kotlin.codegen.ExpressionCodegen
+import org.jetbrains.kotlin.codegen.generateCallReceiver
+import org.jetbrains.kotlin.codegen.generateCallSingleArgument
+import org.jetbrains.kotlin.codegen.range.comparison.getComparisonGeneratorForPrimitiveType
 import org.jetbrains.kotlin.codegen.range.forLoop.ForInDownToProgressionLoopGenerator
-import org.jetbrains.kotlin.codegen.range.inExpression.InPrimitiveNumberDownToGenerator
+import org.jetbrains.kotlin.codegen.range.inExpression.InContinuousRangeExpressionGenerator
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.psi.KtForExpression
 import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 
-class DownToProgressionRangeValue(rangeCall: ResolvedCall<out CallableDescriptor>): PrimitiveNumberRangeIntrinsicRangeValue(rangeCall) {
+class DownToProgressionRangeValue(
+        codegen: ExpressionCodegen,
+        rangeCall: ResolvedCall<out CallableDescriptor>
+): PrimitiveNumberRangeIntrinsicRangeValue(rangeCall) {
+    private val comparisonGenerator = getComparisonGeneratorForPrimitiveType(asmElementType)
+
+    private val boundedValue =
+            SimpleBoundedValue(
+                    codegen, rangeCall,
+                    lowBound = codegen.generateCallSingleArgument(rangeCall),
+                    highBound = codegen.generateCallReceiver(rangeCall)
+            )
+
     override fun createForLoopGenerator(codegen: ExpressionCodegen, forExpression: KtForExpression) =
             ForInDownToProgressionLoopGenerator(codegen, forExpression, rangeCall)
 
     override fun createIntrinsicInExpressionGenerator(codegen: ExpressionCodegen, operatorReference: KtSimpleNameExpression) =
-            InPrimitiveNumberDownToGenerator(codegen, operatorReference, rangeCall)
+            InContinuousRangeExpressionGenerator(operatorReference, boundedValue, comparisonGenerator)
 }

compiler/backend/src/org/jetbrains/kotlin/codegen/range/PrimitiveNumberRangeIntrinsicRangeValue.kt

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.codegen.range
 
+import org.jetbrains.kotlin.codegen.getAsmRangeElementTypeForPrimitiveRangeOrProgression
 import org.jetbrains.kotlin.codegen.isClosedFloatingPointRangeContains
 import org.jetbrains.kotlin.codegen.isIntPrimitiveRangeExtensionForInt
 import org.jetbrains.kotlin.codegen.isPrimitiveRangeContains
@@ -23,6 +24,8 @@ import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 
 abstract class PrimitiveNumberRangeIntrinsicRangeValue(rangeCall: ResolvedCall<out CallableDescriptor>): CallIntrinsicRangeValue(rangeCall) {
+    protected val asmElementType = getAsmRangeElementTypeForPrimitiveRangeOrProgression(rangeCall.resultingDescriptor)
+
     override fun isIntrinsicInCall(resolvedCallForIn: ResolvedCall<out CallableDescriptor>) =
             resolvedCallForIn.resultingDescriptor.let {
                 isPrimitiveRangeContains(it) ||

compiler/backend/src/org/jetbrains/kotlin/codegen/range/PrimitiveNumberRangeLiteralRangeValue.kt

@@ -17,7 +17,6 @@
 package org.jetbrains.kotlin.codegen.range
 
 import org.jetbrains.kotlin.codegen.ExpressionCodegen
-import org.jetbrains.kotlin.codegen.getAsmRangeElementTypeForPrimitiveRange
 import org.jetbrains.kotlin.codegen.range.comparison.getComparisonGeneratorForPrimitiveType
 import org.jetbrains.kotlin.codegen.range.forLoop.ForInRangeLiteralLoopGenerator
 import org.jetbrains.kotlin.codegen.range.inExpression.InContinuousRangeExpressionGenerator
@@ -30,9 +29,8 @@ class PrimitiveNumberRangeLiteralRangeValue(
         codegen: ExpressionCodegen,
         rangeCall: ResolvedCall<out CallableDescriptor>
 ): PrimitiveNumberRangeIntrinsicRangeValue(rangeCall) {
-    private val asmElementType = getAsmRangeElementTypeForPrimitiveRange(rangeCall.resultingDescriptor)
     private val comparisonGenerator = getComparisonGeneratorForPrimitiveType(asmElementType)
-    private val boundedValue = SimpleBoundedValue(codegen, rangeCall, isLowInclusive = true, isHighInclusive = true)
+    private val boundedValue = SimpleBoundedValue(codegen, rangeCall)
 
     override fun createForLoopGenerator(codegen: ExpressionCodegen, forExpression: KtForExpression) =
             ForInRangeLiteralLoopGenerator(codegen, forExpression, rangeCall)

compiler/backend/src/org/jetbrains/kotlin/codegen/range/PrimitiveNumberUntilRangeValue.kt

@@ -17,17 +17,24 @@
 package org.jetbrains.kotlin.codegen.range
 
 import org.jetbrains.kotlin.codegen.ExpressionCodegen
+import org.jetbrains.kotlin.codegen.range.comparison.getComparisonGeneratorForPrimitiveType
 import org.jetbrains.kotlin.codegen.range.forLoop.ForInUntilRangeLoopGenerator
-import org.jetbrains.kotlin.codegen.range.inExpression.InPrimitiveNumberUntilGenerator
+import org.jetbrains.kotlin.codegen.range.inExpression.InContinuousRangeExpressionGenerator
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.psi.KtForExpression
 import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 
-class PrimitiveNumberUntilRangeValue(rangeCall: ResolvedCall<out CallableDescriptor>): PrimitiveNumberRangeIntrinsicRangeValue(rangeCall) {
+class PrimitiveNumberUntilRangeValue(
+        codegen: ExpressionCodegen,
+        rangeCall: ResolvedCall<out CallableDescriptor>
+): PrimitiveNumberRangeIntrinsicRangeValue(rangeCall) {
+    private val comparisonGenerator = getComparisonGeneratorForPrimitiveType(asmElementType)
+    private val boundedValue = SimpleBoundedValue(codegen, rangeCall, isLowInclusive = true, isHighInclusive = false)
+
     override fun createForLoopGenerator(codegen: ExpressionCodegen, forExpression: KtForExpression) =
             ForInUntilRangeLoopGenerator(codegen, forExpression, rangeCall)
 
     override fun createIntrinsicInExpressionGenerator(codegen: ExpressionCodegen, operatorReference: KtSimpleNameExpression) =
-            InPrimitiveNumberUntilGenerator(codegen, operatorReference, rangeCall)
+            InContinuousRangeExpressionGenerator(operatorReference, boundedValue, comparisonGenerator)
 }

compiler/backend/src/org/jetbrains/kotlin/codegen/range/RangeValues.kt

@@ -86,15 +86,15 @@ private fun ExpressionCodegen.createIntrinsifiedRangeValueOrNull(rangeCall: Reso
         isPrimitiveNumberRangeTo(rangeCallee) ->
             PrimitiveNumberRangeLiteralRangeValue(this, rangeCall)
         isPrimitiveNumberDownTo(rangeCallee) ->
-            DownToProgressionRangeValue(rangeCall)
+            DownToProgressionRangeValue(this, rangeCall)
         isPrimitiveNumberUntil(rangeCallee) ->
-            PrimitiveNumberUntilRangeValue(rangeCall)
+            PrimitiveNumberUntilRangeValue(this, rangeCall)
         isArrayOrPrimitiveArrayIndices(rangeCallee) ->
-            ArrayIndicesRangeValue(rangeCall)
+            ArrayIndicesRangeValue(this, rangeCall)
         isCollectionIndices(rangeCallee) ->
-            CollectionIndicesRangeValue(rangeCall)
+            CollectionIndicesRangeValue(this, rangeCall)
         isCharSequenceIndices(rangeCallee) ->
-            CharSequenceIndicesRangeValue(rangeCall)
+            CharSequenceIndicesRangeValue(this, rangeCall)
         isComparableRangeTo(rangeCallee) ->
             ComparableRangeLiteralRangeValue(this, rangeCall)
         else ->

compiler/backend/src/org/jetbrains/kotlin/codegen/range/SimpleBoundedValue.kt

@@ -18,6 +18,8 @@ package org.jetbrains.kotlin.codegen.range
 
 import org.jetbrains.kotlin.codegen.ExpressionCodegen
 import org.jetbrains.kotlin.codegen.StackValue
+import org.jetbrains.kotlin.codegen.generateCallReceiver
+import org.jetbrains.kotlin.codegen.generateCallSingleArgument
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.org.objectweb.asm.Type
@@ -34,17 +36,24 @@ class SimpleBoundedValue(
     constructor(
             codegen: ExpressionCodegen,
             rangeCall: ResolvedCall<out CallableDescriptor>,
-            isLowInclusive: Boolean,
+            isLowInclusive: Boolean = true,
-            isHighInclusive: Boolean
+            isHighInclusive: Boolean = true
     ) : this(
             codegen,
             rangeCall,
-            codegen.generateReceiverValue(rangeCall.extensionReceiver ?: rangeCall.dispatchReceiver!!, false),
+            codegen.generateCallReceiver(rangeCall),
             isLowInclusive,
-            codegen.gen(ExpressionCodegen.getSingleArgumentExpression(rangeCall)!!),
+            codegen.generateCallSingleArgument(rangeCall),
             isHighInclusive
     )
 
+    constructor(
+            codegen: ExpressionCodegen,
+            rangeCall: ResolvedCall<out CallableDescriptor>,
+            lowBound: StackValue,
+            highBound: StackValue
+    ) : this(codegen, rangeCall, lowBound, true, highBound, true)
+
     override val instanceType: Type = codegen.asmType(rangeCall.resultingDescriptor.returnType!!)
 
     override fun putInstance(v: InstructionAdapter, type: Type) {
@@ -55,4 +64,8 @@ class SimpleBoundedValue(
         highBound.put(type, v)
         lowBound.put(type, v)
     }
+
+    companion object {
+
+    }
 }

compiler/backend/src/org/jetbrains/kotlin/codegen/range/inExpression/AbstractInPrimitiveNumberRangeExpressionGenerator.kt

@@ -1,36 +0,0 @@
-/*
- * Copyright 2010-2017 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.codegen.range.inExpression
-
-import org.jetbrains.kotlin.codegen.ExpressionCodegen
-import org.jetbrains.kotlin.codegen.getAsmRangeElementTypeForPrimitiveRange
-import org.jetbrains.kotlin.codegen.range.comparison.*
-import org.jetbrains.kotlin.psi.KtSimpleNameExpression
-import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
-import org.jetbrains.org.objectweb.asm.Type
-
-abstract class AbstractInPrimitiveNumberRangeExpressionGenerator(
-        codegen: ExpressionCodegen,
-        operatorReference: KtSimpleNameExpression,
-        rangeCall: ResolvedCall<*>,
-        isInclusiveHighBound: Boolean
-) : AbstractInRangeWithKnownBoundsExpressionGenerator(
-        codegen, operatorReference, isInclusiveHighBound,
-        getAsmRangeElementTypeForPrimitiveRange(rangeCall.resultingDescriptor)
-) {
-    override val comparisonGenerator: ComparisonGenerator = getComparisonGeneratorForPrimitiveType(asmElementType)
-}

compiler/backend/src/org/jetbrains/kotlin/codegen/range/inExpression/AbstractInRangeWithKnownBoundsExpressionGenerator.kt

@@ -1,98 +0,0 @@
-/*
- * Copyright 2010-2017 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.codegen.range.inExpression
-
-import org.jetbrains.kotlin.codegen.*
-import org.jetbrains.kotlin.codegen.range.comparison.ComparisonGenerator
-import org.jetbrains.kotlin.lexer.KtTokens
-import org.jetbrains.kotlin.psi.KtSimpleNameExpression
-import org.jetbrains.org.objectweb.asm.Label
-import org.jetbrains.org.objectweb.asm.Opcodes
-import org.jetbrains.org.objectweb.asm.Type
-import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
-
-abstract class AbstractInRangeWithKnownBoundsExpressionGenerator(
-        val codegen: ExpressionCodegen,
-        operatorReference: KtSimpleNameExpression,
-        protected val isInclusiveHighBound: Boolean,
-        protected val asmElementType: Type
-) : InExpressionGenerator {
-    private val isNotIn = operatorReference.getReferencedNameElementType() == KtTokens.NOT_IN
-
-    protected abstract fun genLowBound(): StackValue
-    protected abstract fun genHighBound(): StackValue
-
-    protected abstract val comparisonGenerator: ComparisonGenerator
-
-    override fun generate(argument: StackValue): BranchedValue =
-            gen(argument).let { if (isNotIn) Invert(it) else it }
-
-    private fun gen(argument: StackValue): BranchedValue =
-            object : BranchedValue(argument, null, asmElementType, Opcodes.IFEQ) {
-                override fun condJump(jumpLabel: Label, v: InstructionAdapter, jumpIfFalse: Boolean) {
-                    if (jumpIfFalse) {
-                        // arg1 in low .. high
-                        // arg1 >= low && arg1 <[=] high
-                        val cmpHighLabel = Label()
-
-                        arg1.put(operandType, v)
-                        AsmUtil.dup(v, operandType)
-
-                        genLowBound().put(operandType, v)
-                        comparisonGenerator.jumpIfGreaterOrEqual(v, cmpHighLabel)
-
-                        AsmUtil.pop(v, operandType)
-                        v.goTo(jumpLabel)
-
-                        v.mark(cmpHighLabel)
-                        genHighBound().put(operandType, v)
-                        if (isInclusiveHighBound) {
-                            comparisonGenerator.jumpIfGreater(v, jumpLabel)
-                        }
-                        else {
-                            comparisonGenerator.jumpIfGreaterOrEqual(v, jumpLabel)
-                        }
-                    }
-                    else {
-                        // arg1 !in low .. high
-                        // arg1 < low || arg1 >[=] high
-                        val trueLabel1 = Label()
-                        val trueLabel2 = Label()
-
-                        arg1.put(operandType, v)
-                        AsmUtil.dup(v, operandType)
-
-                        genLowBound().put(operandType, v)
-                        comparisonGenerator.jumpIfLess(v, trueLabel1)
-
-                        genHighBound().put(operandType, v)
-                        if (isInclusiveHighBound) {
-                            comparisonGenerator.jumpIfLessOrEqual(v, jumpLabel)
-                        }
-                        else {
-                            comparisonGenerator.jumpIfLess(v, jumpLabel)
-                        }
-                        v.goTo(trueLabel2)
-
-                        v.mark(trueLabel1)
-                        AsmUtil.pop(v, operandType)
-
-                        v.mark(trueLabel2)
-                    }
-                }
-            }
-}

compiler/backend/src/org/jetbrains/kotlin/codegen/range/inExpression/InArrayIndicesGenerator.kt

@@ -1,42 +0,0 @@
-/*
- * Copyright 2010-2017 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.codegen.range.inExpression
-
-import org.jetbrains.kotlin.codegen.ExpressionCodegen
-import org.jetbrains.kotlin.codegen.StackValue
-import org.jetbrains.kotlin.psi.KtSimpleNameExpression
-import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
-import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
-import org.jetbrains.kotlin.types.KotlinType
-import org.jetbrains.org.objectweb.asm.Type
-
-class InArrayIndicesGenerator(
-        codegen: ExpressionCodegen,
-        operatorReference: KtSimpleNameExpression,
-        rangeCall: ResolvedCall<*>
-) : AbstractInPrimitiveNumberRangeExpressionGenerator(codegen, operatorReference, rangeCall, isInclusiveHighBound = false) {
-    private val receiverValue: ReceiverValue = rangeCall.extensionReceiver!!
-    private val expectedReceiverType: KotlinType = ExpressionCodegen.getExpectedReceiverType(rangeCall)
-
-    override fun genLowBound(): StackValue = StackValue.constant(0, asmElementType)
-
-    override fun genHighBound(): StackValue =
-            StackValue.operation(Type.INT_TYPE) { v ->
-                codegen.generateReceiverValue(receiverValue, false).put(codegen.asmType(expectedReceiverType), v)
-                v.arraylength()
-            }
-}

compiler/backend/src/org/jetbrains/kotlin/codegen/range/inExpression/InCharSequenceIndicesGenerator.kt

@@ -1,42 +0,0 @@
-/*
- * Copyright 2010-2017 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.codegen.range.inExpression
-
-import org.jetbrains.kotlin.codegen.ExpressionCodegen
-import org.jetbrains.kotlin.codegen.StackValue
-import org.jetbrains.kotlin.psi.KtSimpleNameExpression
-import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
-import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
-import org.jetbrains.kotlin.types.KotlinType
-import org.jetbrains.org.objectweb.asm.Type
-
-class InCharSequenceIndicesGenerator(
-        codegen: ExpressionCodegen,
-        operatorReference: KtSimpleNameExpression,
-        rangeCall: ResolvedCall<*>
-) : AbstractInPrimitiveNumberRangeExpressionGenerator(codegen, operatorReference, rangeCall, isInclusiveHighBound = false) {
-    private val receiverValue: ReceiverValue = rangeCall.extensionReceiver!!
-    private val expectedReceiverType: KotlinType = ExpressionCodegen.getExpectedReceiverType(rangeCall)
-
-    override fun genLowBound(): StackValue = StackValue.constant(0, asmElementType)
-
-    override fun genHighBound(): StackValue =
-            StackValue.operation(Type.INT_TYPE) { v ->
-                codegen.generateReceiverValue(receiverValue, false).put(codegen.asmType(expectedReceiverType), v)
-                v.invokeinterface("java/lang/CharSequence", "length", "()I")
-            }
-}

compiler/backend/src/org/jetbrains/kotlin/codegen/range/inExpression/InCollectionIndicesGenerator.kt

@@ -1,42 +0,0 @@
-/*
- * Copyright 2010-2017 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.codegen.range.inExpression
-
-import org.jetbrains.kotlin.codegen.ExpressionCodegen
-import org.jetbrains.kotlin.codegen.StackValue
-import org.jetbrains.kotlin.psi.KtSimpleNameExpression
-import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
-import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
-import org.jetbrains.kotlin.types.KotlinType
-import org.jetbrains.org.objectweb.asm.Type
-
-class InCollectionIndicesGenerator(
-        codegen: ExpressionCodegen,
-        operatorReference: KtSimpleNameExpression,
-        rangeCall: ResolvedCall<*>
-) : AbstractInPrimitiveNumberRangeExpressionGenerator(codegen, operatorReference, rangeCall, isInclusiveHighBound = false) {
-    private val receiverValue: ReceiverValue = rangeCall.extensionReceiver!!
-    private val expectedReceiverType: KotlinType = ExpressionCodegen.getExpectedReceiverType(rangeCall)
-
-    override fun genLowBound(): StackValue = StackValue.constant(0, asmElementType)
-
-    override fun genHighBound(): StackValue =
-            StackValue.operation(Type.INT_TYPE) { v ->
-                codegen.generateReceiverValue(receiverValue, false).put(codegen.asmType(expectedReceiverType), v)
-                v.invokeinterface("java/util/Collection", "size", "()I")
-            }
-}

compiler/backend/src/org/jetbrains/kotlin/codegen/range/inExpression/InPrimitiveNumberDownToGenerator.kt

@@ -1,37 +0,0 @@
-/*
- * Copyright 2010-2017 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.codegen.range.inExpression
-
-import org.jetbrains.kotlin.codegen.ExpressionCodegen
-import org.jetbrains.kotlin.codegen.StackValue
-import org.jetbrains.kotlin.psi.KtExpression
-import org.jetbrains.kotlin.psi.KtSimpleNameExpression
-import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
-import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
-
-class InPrimitiveNumberDownToGenerator(
-        codegen: ExpressionCodegen,
-        operatorReference: KtSimpleNameExpression,
-        rangeCall: ResolvedCall<*>
-) : AbstractInPrimitiveNumberRangeExpressionGenerator(codegen, operatorReference, rangeCall, isInclusiveHighBound = true) {
-    private val from: ReceiverValue = rangeCall.dispatchReceiver!!
-    private val to: KtExpression = ExpressionCodegen.getSingleArgumentExpression(rangeCall)!!
-
-    override fun genLowBound(): StackValue = codegen.gen(to)
-
-    override fun genHighBound(): StackValue = codegen.generateReceiverValue(from, false)
-}

compiler/backend/src/org/jetbrains/kotlin/codegen/range/inExpression/InPrimitiveNumberUntilGenerator.kt

@@ -1,37 +0,0 @@
-/*
- * Copyright 2010-2017 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.codegen.range.inExpression
-
-import org.jetbrains.kotlin.codegen.ExpressionCodegen
-import org.jetbrains.kotlin.codegen.StackValue
-import org.jetbrains.kotlin.psi.KtExpression
-import org.jetbrains.kotlin.psi.KtSimpleNameExpression
-import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
-import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
-
-class InPrimitiveNumberUntilGenerator(
-        codegen: ExpressionCodegen,
-        operatorReference: KtSimpleNameExpression,
-        rangeCall: ResolvedCall<*>
-) : AbstractInPrimitiveNumberRangeExpressionGenerator(codegen, operatorReference, rangeCall, isInclusiveHighBound = false) {
-    private val from: ReceiverValue = rangeCall.extensionReceiver!!
-    private val to: KtExpression = ExpressionCodegen.getSingleArgumentExpression(rangeCall)!!
-
-    override fun genLowBound(): StackValue = codegen.generateReceiverValue(from, false)
-
-    override fun genHighBound(): StackValue = codegen.gen(to)
-}

compiler/testData/codegen/bytecodeText/coercionToUnitOptimization/inRangeCheckWithConst.kt

@@ -3,5 +3,8 @@
 fun testPrimitiveArray(ints: IntArray) =
         10 in ints.indices
 
-// 0 DUP
+// We currently fail to optimize this method because of DUP_X1 instruction generated for range check.
-// 0 POP
+// TODO either don't generate DUP_X1/DUP2_X2 instructions for range checks (extra local variable + extra instructions),
+// or support DUPn_Xm instructions in PopBackwardPropagationTransformer
+// - 0 DUP
+// - 0 POP