Extract SimpleBoundedValue class

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

@@ -34,9 +34,8 @@ import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
 class ComparableRangeLiteralRangeValue(
         private val codegen: ExpressionCodegen,
         rangeCall: ResolvedCall<out CallableDescriptor>
-) : CallIntrinsicRangeValue(rangeCall), BoundedValue {
-    private val from: ReceiverValue = rangeCall.extensionReceiver!!
-    private val to: KtExpression = ExpressionCodegen.getSingleArgumentExpression(rangeCall)!!
+) : CallIntrinsicRangeValue(rangeCall) {
+    private val boundedValue = SimpleBoundedValue(codegen, rangeCall, isLowInclusive = true, isHighInclusive = true)
 
     override fun createForLoopGenerator(codegen: ExpressionCodegen, forExpression: KtForExpression) =
             IteratorForLoopGenerator(codegen, forExpression)
@@ -45,20 +44,5 @@ class ComparableRangeLiteralRangeValue(
             isClosedRangeContains(resolvedCallForIn.resultingDescriptor)
 
     override fun createIntrinsicInExpressionGenerator(codegen: ExpressionCodegen, operatorReference: KtSimpleNameExpression)=
-            InContinuousRangeExpressionGenerator(operatorReference, this, ObjectComparisonGenerator)
-
-    override val instanceType: Type =
-            codegen.asmType(rangeCall.resultingDescriptor.returnType!!)
-
-    override fun putInstance(v: InstructionAdapter) {
-        codegen.invokeFunction(rangeCall.call, rangeCall, StackValue.none()).put(instanceType, v)
-    }
-
-    override fun putHighLow(v: InstructionAdapter, type: Type) {
-        codegen.gen(to).put(type, v)
-        codegen.generateReceiverValue(from, false).put(type, v)
-    }
-
-    override val isLowInclusive = true
-    override val isHighInclusive = true
+            InContinuousRangeExpressionGenerator(operatorReference, boundedValue, ObjectComparisonGenerator)
 }

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

@@ -17,46 +17,26 @@
 package org.jetbrains.kotlin.codegen.range
 
 import org.jetbrains.kotlin.codegen.ExpressionCodegen
-import org.jetbrains.kotlin.codegen.StackValue
 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
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
-import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.psi.KtForExpression
 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.org.objectweb.asm.Type
-import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
 
 class PrimitiveNumberRangeLiteralRangeValue(
-        private val codegen: ExpressionCodegen,
+        codegen: ExpressionCodegen,
         rangeCall: ResolvedCall<out CallableDescriptor>
-): PrimitiveNumberRangeIntrinsicRangeValue(rangeCall), BoundedValue {
+): PrimitiveNumberRangeIntrinsicRangeValue(rangeCall) {
     private val asmElementType = getAsmRangeElementTypeForPrimitiveRange(rangeCall.resultingDescriptor)
-    private val from: ReceiverValue = rangeCall.dispatchReceiver ?: rangeCall.extensionReceiver!!
-    private val to: KtExpression = ExpressionCodegen.getSingleArgumentExpression(rangeCall)!!
+    private val comparisonGenerator = getComparisonGeneratorForPrimitiveType(asmElementType)
+    private val boundedValue = SimpleBoundedValue(codegen, rangeCall, isLowInclusive = true, isHighInclusive = true)
 
     override fun createForLoopGenerator(codegen: ExpressionCodegen, forExpression: KtForExpression) =
             ForInRangeLiteralLoopGenerator(codegen, forExpression, rangeCall)
 
     override fun createIntrinsicInExpressionGenerator(codegen: ExpressionCodegen, operatorReference: KtSimpleNameExpression) =
-            InContinuousRangeExpressionGenerator(operatorReference, this, getComparisonGeneratorForPrimitiveType(asmElementType))
-
-    override val instanceType: Type =
-            codegen.asmType(rangeCall.resultingDescriptor.returnType!!)
-
-    override fun putInstance(v: InstructionAdapter) {
-        codegen.invokeFunction(rangeCall.call, rangeCall, StackValue.none()).put(instanceType, v)
-    }
-
-    override fun putHighLow(v: InstructionAdapter, type: Type) {
-        codegen.gen(to).put(type, v)
-        codegen.generateReceiverValue(from, false).put(type, v)
-    }
-
-    override val isLowInclusive: Boolean = true
-    override val isHighInclusive: Boolean = true
+            InContinuousRangeExpressionGenerator(operatorReference, boundedValue, comparisonGenerator)
 }

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

@@ -35,7 +35,7 @@ interface RangeValue {
 interface BoundedValue {
     val instanceType: Type
 
-    fun putInstance(v: InstructionAdapter)
+    fun putInstance(v: InstructionAdapter, type: Type)
 
     fun putHighLow(v: InstructionAdapter, type: Type)
     val isLowInclusive: Boolean
@@ -45,7 +45,6 @@ interface BoundedValue {
 fun BoundedValue.asStackValue(): StackValue =
         object : StackValue(instanceType) {
             override fun putSelector(type: Type, v: InstructionAdapter) {
-                putInstance(v)
-                StackValue.onStack(instanceType).put(type, v)
+                putInstance(v, type)
             }
         }

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

@@ -0,0 +1,58 @@
+/*
+ * 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
+
+import org.jetbrains.kotlin.codegen.ExpressionCodegen
+import org.jetbrains.kotlin.codegen.StackValue
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
+import org.jetbrains.org.objectweb.asm.Type
+import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
+
+class SimpleBoundedValue(
+        private val codegen: ExpressionCodegen,
+        private val rangeCall: ResolvedCall<out CallableDescriptor>,
+        private val lowBound: StackValue,
+        override val isLowInclusive: Boolean,
+        private val highBound: StackValue,
+        override val isHighInclusive: Boolean
+): BoundedValue {
+    constructor(
+            codegen: ExpressionCodegen,
+            rangeCall: ResolvedCall<out CallableDescriptor>,
+            isLowInclusive: Boolean,
+            isHighInclusive: Boolean
+    ) : this(
+            codegen,
+            rangeCall,
+            codegen.generateReceiverValue(rangeCall.extensionReceiver ?: rangeCall.dispatchReceiver!!, false),
+            isLowInclusive,
+            codegen.gen(ExpressionCodegen.getSingleArgumentExpression(rangeCall)!!),
+            isHighInclusive
+    )
+
+    override val instanceType: Type = codegen.asmType(rangeCall.resultingDescriptor.returnType!!)
+
+    override fun putInstance(v: InstructionAdapter, type: Type) {
+        codegen.invokeFunction(rangeCall.call, rangeCall, StackValue.none()).put(type, v)
+    }
+
+    override fun putHighLow(v: InstructionAdapter, type: Type) {
+        highBound.put(type, v)
+        lowBound.put(type, v)
+    }
+}