From c855b5c889e14ba81475bba71bd342b2ac727270 Mon Sep 17 00:00:00 2001 From: Dmitry Petrov Date: Wed, 5 Jul 2017 18:02:18 +0300 Subject: [PATCH] Extract SimpleBoundedValue class --- .../range/ComparableRangeLiteralRangeValue.kt | 22 +------ .../PrimitiveNumberRangeLiteralRangeValue.kt | 30 ++-------- .../kotlin/codegen/range/RangeValue.kt | 5 +- .../codegen/range/SimpleBoundedValue.kt | 58 +++++++++++++++++++ 4 files changed, 68 insertions(+), 47 deletions(-) create mode 100644 compiler/backend/src/org/jetbrains/kotlin/codegen/range/SimpleBoundedValue.kt diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/range/ComparableRangeLiteralRangeValue.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/range/ComparableRangeLiteralRangeValue.kt index ecba3122666..75cbc362eea 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/range/ComparableRangeLiteralRangeValue.kt +++ b/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 -) : 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) } \ No newline at end of file diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/range/PrimitiveNumberRangeLiteralRangeValue.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/range/PrimitiveNumberRangeLiteralRangeValue.kt index ec26da9878e..d41c04bfd6a 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/range/PrimitiveNumberRangeLiteralRangeValue.kt +++ b/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 -): 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) } \ No newline at end of file diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/range/RangeValue.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/range/RangeValue.kt index 46ffa7710db..c12d11c65dc 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/range/RangeValue.kt +++ b/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) } } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/range/SimpleBoundedValue.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/range/SimpleBoundedValue.kt new file mode 100644 index 00000000000..9a37658d292 --- /dev/null +++ b/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, + private val lowBound: StackValue, + override val isLowInclusive: Boolean, + private val highBound: StackValue, + override val isHighInclusive: Boolean +): BoundedValue { + constructor( + codegen: ExpressionCodegen, + rangeCall: ResolvedCall, + 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) + } +} \ No newline at end of file