From c870eeac2e5da317a084e995cf94f74eb2be6c06 Mon Sep 17 00:00:00 2001 From: Dmitry Petrov Date: Wed, 28 Jun 2017 15:46:14 +0300 Subject: [PATCH] RangeCodegenUtil: convert to Kotlin + cleanup --- .../kotlin/codegen/ExpressionCodegen.java | 4 +- .../kotlin/codegen/RangeCodegenUtil.kt | 322 +++++++----------- .../optimization/boxing/BoxingInterpreter.kt | 4 +- .../boxing/ProgressionIteratorBasicValue.java | 8 +- .../kotlin/codegen/range/RangeValues.kt | 19 +- 5 files changed, 144 insertions(+), 213 deletions(-) diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java index 85eceae50e5..abc14d2666c 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java @@ -2874,8 +2874,8 @@ public class ExpressionCodegen extends KtVisitor impleme assert deparenthesized != null : "For with empty range expression"; boolean isInverted = operationReference.getReferencedNameElementType() == KtTokens.NOT_IN; return StackValue.operation(Type.BOOLEAN_TYPE, v -> { - if (RangeCodegenUtil.isPrimitiveRangeSpecializationOfType(leftValue.type, deparenthesized, bindingContext) || - RangeCodegenUtil.isPrimitiveRangeToExtension(operationReference, bindingContext)) { + if (RangeCodegenUtilKt.isPrimitiveRangeSpecializationOfType(leftValue.type, deparenthesized, bindingContext) || + RangeCodegenUtilKt.isPrimitiveRangeToExtension(operationReference, bindingContext)) { generateInPrimitiveRange(leftValue, (KtBinaryExpression) deparenthesized, isInverted); } else { diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/RangeCodegenUtil.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/RangeCodegenUtil.kt index 7662a4f0f14..1f16a9aa232 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/RangeCodegenUtil.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/RangeCodegenUtil.kt @@ -1,5 +1,5 @@ /* - * Copyright 2010-2015 JetBrains s.r.o. + * 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. @@ -14,228 +14,160 @@ * limitations under the License. */ -package org.jetbrains.kotlin.codegen; +package org.jetbrains.kotlin.codegen -import com.google.common.collect.ImmutableMap; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.kotlin.builtins.KotlinBuiltIns; -import org.jetbrains.kotlin.builtins.PrimitiveType; -import org.jetbrains.kotlin.descriptors.*; -import org.jetbrains.kotlin.lexer.KtTokens; -import org.jetbrains.kotlin.name.FqName; -import org.jetbrains.kotlin.name.FqNameUnsafe; -import org.jetbrains.kotlin.name.Name; -import org.jetbrains.kotlin.psi.*; -import org.jetbrains.kotlin.resolve.BindingContext; -import org.jetbrains.kotlin.resolve.DescriptorUtils; -import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilKt; -import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall; -import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver; -import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue; -import org.jetbrains.kotlin.types.KotlinType; -import org.jetbrains.org.objectweb.asm.Type; +import org.jetbrains.kotlin.builtins.KotlinBuiltIns +import org.jetbrains.kotlin.builtins.KotlinBuiltIns.RANGES_PACKAGE_FQ_NAME +import org.jetbrains.kotlin.builtins.PrimitiveType +import org.jetbrains.kotlin.codegen.AsmUtil.isPrimitiveNumberClassDescriptor +import org.jetbrains.kotlin.descriptors.CallableDescriptor +import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor +import org.jetbrains.kotlin.lexer.KtTokens +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.psi.KtBinaryExpression +import org.jetbrains.kotlin.psi.KtExpression +import org.jetbrains.kotlin.psi.KtSimpleNameExpression +import org.jetbrains.kotlin.resolve.BindingContext +import org.jetbrains.kotlin.resolve.DescriptorUtils +import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall +import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCallWithAssert +import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver +import org.jetbrains.kotlin.types.KotlinType +import org.jetbrains.org.objectweb.asm.Type -import java.util.Arrays; -import java.util.List; - -import static org.jetbrains.kotlin.builtins.KotlinBuiltIns.RANGES_PACKAGE_FQ_NAME; -import static org.jetbrains.kotlin.codegen.AsmUtil.isPrimitiveNumberClassDescriptor; - -public class RangeCodegenUtil { - private static final ImmutableMap RANGE_TO_ELEMENT_TYPE; - private static final ImmutableMap PROGRESSION_TO_ELEMENT_TYPE; - - @NotNull - public static List supportedRangeTypes() { - return Arrays.asList(PrimitiveType.CHAR, PrimitiveType.INT, PrimitiveType.LONG); - } - - static { - ImmutableMap.Builder rangeBuilder = ImmutableMap.builder(); - ImmutableMap.Builder progressionBuilder = ImmutableMap.builder(); - for (PrimitiveType primitiveType : supportedRangeTypes()) { - FqName rangeClassFqName = RANGES_PACKAGE_FQ_NAME.child(Name.identifier(primitiveType.getTypeName() + "Range")); - FqName progressionClassFqName = RANGES_PACKAGE_FQ_NAME.child(Name.identifier(primitiveType.getTypeName() + "Progression")); - rangeBuilder.put(rangeClassFqName, primitiveType); - progressionBuilder.put(progressionClassFqName, primitiveType); +private val RANGE_TO_ELEMENT_TYPE: Map = + supportedRangeTypes().associateBy { + RANGES_PACKAGE_FQ_NAME.child(Name.identifier(it.typeName.toString() + "Range")) } - RANGE_TO_ELEMENT_TYPE = rangeBuilder.build(); - PROGRESSION_TO_ELEMENT_TYPE = progressionBuilder.build(); - } - private RangeCodegenUtil() {} +private val PROGRESSION_TO_ELEMENT_TYPE: Map = + supportedRangeTypes().associateBy { + RANGES_PACKAGE_FQ_NAME.child(Name.identifier(it.typeName.toString() + "Progression")) + } - public static boolean isRange(KotlinType rangeType) { - return !rangeType.isMarkedNullable() && getPrimitiveRangeElementType(rangeType) != null; - } +fun supportedRangeTypes() = + listOf(PrimitiveType.CHAR, PrimitiveType.INT, PrimitiveType.LONG) - public static boolean isProgression(KotlinType rangeType) { - return !rangeType.isMarkedNullable() && getPrimitiveProgressionElementType(rangeType) != null; - } +fun isRange(rangeType: KotlinType) = + !rangeType.isMarkedNullable && getPrimitiveRangeElementType(rangeType) != null - @Nullable - private static PrimitiveType getPrimitiveRangeElementType(KotlinType rangeType) { - return getPrimitiveRangeOrProgressionElementType(rangeType, RANGE_TO_ELEMENT_TYPE); - } +fun isProgression(rangeType: KotlinType) = + !rangeType.isMarkedNullable && getPrimitiveProgressionElementType(rangeType) != null - @Nullable - private static PrimitiveType getPrimitiveProgressionElementType(KotlinType rangeType) { - return getPrimitiveRangeOrProgressionElementType(rangeType, PROGRESSION_TO_ELEMENT_TYPE); - } +private fun getPrimitiveRangeElementType(rangeType: KotlinType) = + getPrimitiveRangeOrProgressionElementType(rangeType, RANGE_TO_ELEMENT_TYPE) - @Nullable - private static PrimitiveType getPrimitiveRangeOrProgressionElementType( - @NotNull KotlinType rangeOrProgression, - @NotNull ImmutableMap map - ) { - ClassifierDescriptor declarationDescriptor = rangeOrProgression.getConstructor().getDeclarationDescriptor(); - if (declarationDescriptor == null) return null; - FqNameUnsafe fqName = DescriptorUtils.getFqName(declarationDescriptor); - if (!fqName.isSafe()) return null; - return map.get(fqName.toSafe()); - } +private fun getPrimitiveProgressionElementType(rangeType: KotlinType) = + getPrimitiveRangeOrProgressionElementType(rangeType, PROGRESSION_TO_ELEMENT_TYPE) - @Nullable - public static PrimitiveType getPrimitiveRangeOrProgressionElementType(@NotNull FqName rangeOrProgressionName) { - PrimitiveType result = RANGE_TO_ELEMENT_TYPE.get(rangeOrProgressionName); - return result != null ? result : PROGRESSION_TO_ELEMENT_TYPE.get(rangeOrProgressionName); - } +private fun getPrimitiveRangeOrProgressionElementType( + rangeOrProgression: KotlinType, + map: Map +): PrimitiveType? { + val declarationDescriptor = rangeOrProgression.constructor.declarationDescriptor ?: return null + val fqName = DescriptorUtils.getFqName(declarationDescriptor).takeIf { it.isSafe } ?: return null + return map[fqName.toSafe()] +} - public static boolean isRangeOrProgression(@NotNull FqName className) { - return getPrimitiveRangeOrProgressionElementType(className) != null; - } +fun getPrimitiveRangeOrProgressionElementType(rangeOrProgressionName: FqName): PrimitiveType? = + RANGE_TO_ELEMENT_TYPE[rangeOrProgressionName] ?: + PROGRESSION_TO_ELEMENT_TYPE[rangeOrProgressionName] - public static boolean isPrimitiveNumberRangeTo(CallableDescriptor rangeTo) { - if (!"rangeTo".equals(rangeTo.getName().asString())) return false; +fun isRangeOrProgression(className: FqName) = + getPrimitiveRangeOrProgressionElementType(className) != null - if (!isPrimitiveNumberClassDescriptor(rangeTo.getContainingDeclaration())) return false; +fun isPrimitiveNumberRangeTo(rangeTo: CallableDescriptor) = + "rangeTo" == rangeTo.name.asString() && + isPrimitiveNumberClassDescriptor(rangeTo.containingDeclaration) - return true; - } +private fun isPrimitiveRangeToExtension(descriptor: CallableDescriptor): Boolean { + if (!isTopLevelInPackage(descriptor, "rangeTo", "kotlin.ranges")) return false - private static boolean isPrimitiveRangeToExtension(@NotNull CallableDescriptor descriptor) { - if (!isTopLevelInPackage(descriptor, "rangeTo", "kotlin.ranges")) return false; + val extensionReceiver = descriptor.extensionReceiverParameter ?: return false + return KotlinBuiltIns.isPrimitiveType(extensionReceiver.type) +} - ReceiverParameterDescriptor extensionReceiver = descriptor.getExtensionReceiverParameter(); - if (extensionReceiver == null) return false; +fun isPrimitiveNumberDownTo(descriptor: CallableDescriptor): Boolean { + if (!isTopLevelInPackage(descriptor, "downTo", "kotlin.ranges")) return false - return KotlinBuiltIns.isPrimitiveType(extensionReceiver.getType()); - } + val extensionReceiver = descriptor.extensionReceiverParameter ?: return false + val extensionReceiverClassifier = extensionReceiver.type.constructor.declarationDescriptor + return isPrimitiveNumberClassDescriptor(extensionReceiverClassifier) +} - public static boolean isPrimitiveNumberDownTo(@NotNull CallableDescriptor descriptor) { - if (!isTopLevelInPackage(descriptor, "downTo", "kotlin.ranges")) return false; +fun isPrimitiveNumberUntil(descriptor: CallableDescriptor): Boolean { + if (!isTopLevelInPackage(descriptor, "until", "kotlin.ranges")) return false - ReceiverParameterDescriptor extensionReceiver = descriptor.getExtensionReceiverParameter(); - if (extensionReceiver == null) return false; - ClassifierDescriptor extensionReceiverClassifier = extensionReceiver.getType().getConstructor().getDeclarationDescriptor(); - if (!isPrimitiveNumberClassDescriptor(extensionReceiverClassifier)) return false; + val extensionReceiver = descriptor.extensionReceiverParameter ?: return false + val extensionReceiverClassifier = extensionReceiver.type.constructor.declarationDescriptor + return isPrimitiveNumberClassDescriptor(extensionReceiverClassifier) +} - return true; - } +fun isArrayOrPrimitiveArrayIndices(descriptor: CallableDescriptor): Boolean { + if (!isTopLevelInPackage(descriptor, "indices", "kotlin.collections")) return false - public static boolean isPrimitiveNumberUntil(@NotNull CallableDescriptor descriptor) { - if (!isTopLevelInPackage(descriptor, "until", "kotlin.ranges")) return false; + val extensionReceiver = descriptor.extensionReceiverParameter ?: return false + val extensionReceiverType = extensionReceiver.type + return KotlinBuiltIns.isArray(extensionReceiverType) || KotlinBuiltIns.isPrimitiveArray(extensionReceiverType) +} - ReceiverParameterDescriptor extensionReceiver = descriptor.getExtensionReceiverParameter(); - if (extensionReceiver == null) return false; - ClassifierDescriptor extensionReceiverClassifier = extensionReceiver.getType().getConstructor().getDeclarationDescriptor(); - if (!isPrimitiveNumberClassDescriptor(extensionReceiverClassifier)) return false; +fun isCollectionIndices(descriptor: CallableDescriptor): Boolean { + if (!isTopLevelInPackage(descriptor, "indices", "kotlin.collections")) return false - return true; - } + val extensionReceiver = descriptor.extensionReceiverParameter ?: return false + val extensionReceiverType = extensionReceiver.type + return KotlinBuiltIns.isCollectionOrNullableCollection(extensionReceiverType) +} - public static boolean isArrayOrPrimitiveArrayIndices(@NotNull CallableDescriptor descriptor) { - if (!isTopLevelInPackage(descriptor, "indices", "kotlin.collections")) return false; +fun isCharSequenceIndices(descriptor: CallableDescriptor): Boolean { + if (!isTopLevelInPackage(descriptor, "indices", "kotlin.text")) return false - ReceiverParameterDescriptor extensionReceiver = descriptor.getExtensionReceiverParameter(); - if (extensionReceiver == null) return false; - KotlinType extensionReceiverType = extensionReceiver.getType(); - if (!KotlinBuiltIns.isArray(extensionReceiverType) && !KotlinBuiltIns.isPrimitiveArray(extensionReceiverType)) return false; + val extensionReceiver = descriptor.extensionReceiverParameter ?: return false + val extensionReceiverType = extensionReceiver.type + return KotlinBuiltIns.isCharSequenceOrNullableCharSequence(extensionReceiverType) +} - return true; - } - - public static boolean isCollectionIndices(@NotNull CallableDescriptor descriptor) { - if (!isTopLevelInPackage(descriptor, "indices", "kotlin.collections")) return false; - - ReceiverParameterDescriptor extensionReceiver = descriptor.getExtensionReceiverParameter(); - if (extensionReceiver == null) return false; - KotlinType extensionReceiverType = extensionReceiver.getType(); - if (!KotlinBuiltIns.isCollectionOrNullableCollection(extensionReceiverType)) return false; - - return true; - } - - public static boolean isCharSequenceIndices(@NotNull CallableDescriptor descriptor) { - if (!isTopLevelInPackage(descriptor, "indices", "kotlin.text")) return false; - - ReceiverParameterDescriptor extensionReceiver = descriptor.getExtensionReceiverParameter(); - if (extensionReceiver == null) return false; - KotlinType extensionReceiverType = extensionReceiver.getType(); - if (!KotlinBuiltIns.isCharSequenceOrNullableCharSequence(extensionReceiverType)) return false; - - return true; - } - - public static boolean isPrimitiveRangeToExtension(@NotNull KtSimpleNameExpression operationReference, @NotNull BindingContext bindingContext) { - ResolvedCall resolvedCall = CallUtilKt - .getResolvedCallWithAssert(operationReference, bindingContext); - ReceiverValue receiver = resolvedCall.getDispatchReceiver(); - - /* - * Range is optimizable if - * 'in' receiver is expression 'rangeTo' from stdlib package - * and its argument has same primitive type as generic range parameter. - * For non-matching primitive types (e.g. int in double range) - * dispatch receiver will be null, because extension method will be called. - */ - if (!(receiver instanceof ExpressionReceiver)) return false; - ExpressionReceiver e = (ExpressionReceiver) receiver; - - ResolvedCall resolvedReceiver = - CallUtilKt.getResolvedCall(e.getExpression(), bindingContext); - if (resolvedReceiver == null) return false; - - return isPrimitiveRangeToExtension(resolvedReceiver.getResultingDescriptor()); - } +fun isPrimitiveRangeToExtension(operationReference: KtSimpleNameExpression, bindingContext: BindingContext): Boolean { + val resolvedCall = operationReference.getResolvedCallWithAssert(bindingContext) + val receiver = resolvedCall.dispatchReceiver as? ExpressionReceiver ?: return false /* - * Checks whether for expression 'x in a..b' a..b is primitive integral range - * with same type as x. + * Range is optimizable if + * receiver is a call for 'rangeTo' from stdlib package + * and its argument has same primitive type as generic range parameter. + * For non-matching primitive types (e.g. int in double range) + * dispatch receiver will be null, because extension method will be called. */ - public static boolean isPrimitiveRangeSpecializationOfType( - @NotNull Type argumentType, - @NotNull KtExpression rangeExpression, - @NotNull BindingContext bindingContext - ) { - if (rangeExpression instanceof KtBinaryExpression && - ((KtBinaryExpression) rangeExpression).getOperationReference().getReferencedNameElementType() == KtTokens.RANGE) { - KotlinType kotlinType = bindingContext.getType(rangeExpression); - assert kotlinType != null; - DeclarationDescriptor descriptor = kotlinType.getConstructor().getDeclarationDescriptor(); - if (descriptor != null) { - FqNameUnsafe fqName = DescriptorUtils.getFqName(descriptor); - if (fqName.equals(KotlinBuiltIns.FQ_NAMES.longRange)) { - return argumentType == Type.LONG_TYPE; - } - if (fqName.equals(KotlinBuiltIns.FQ_NAMES.charRange) || fqName.equals(KotlinBuiltIns.FQ_NAMES.intRange)) { - return AsmUtil.isIntPrimitive(argumentType); - } - } - } - return false; - } - - private static boolean isTopLevelInPackage(@NotNull CallableDescriptor descriptor, @NotNull String name, @NotNull String packageName) { - if (!name.equals(descriptor.getName().asString())) return false; - - DeclarationDescriptor containingDeclaration = descriptor.getContainingDeclaration(); - if (!(containingDeclaration instanceof PackageFragmentDescriptor)) return false; - String packageFqName = ((PackageFragmentDescriptor) containingDeclaration).getFqName().asString(); - if (!packageName.equals(packageFqName)) return false; - - return true; - } + val resolvedReceiver = receiver.expression.getResolvedCall(bindingContext) ?: return false + return isPrimitiveRangeToExtension(resolvedReceiver.resultingDescriptor) +} + +/* + * Checks whether for expression 'x in a..b' a..b is primitive integral range + * with same type as x. + */ +fun isPrimitiveRangeSpecializationOfType( + argumentType: Type, + rangeExpression: KtExpression, + bindingContext: BindingContext +): Boolean { + if (rangeExpression is KtBinaryExpression && rangeExpression.operationReference.getReferencedNameElementType() === KtTokens.RANGE) { + val kotlinType = bindingContext.getType(rangeExpression)!! + val descriptor = kotlinType.constructor.declarationDescriptor ?: return false + val fqName = DescriptorUtils.getFqName(descriptor) + return (fqName == KotlinBuiltIns.FQ_NAMES.longRange && argumentType === Type.LONG_TYPE) || + (fqName == KotlinBuiltIns.FQ_NAMES.charRange || fqName == KotlinBuiltIns.FQ_NAMES.intRange) && AsmUtil.isIntPrimitive(argumentType) + } + + return false +} + +private fun isTopLevelInPackage(descriptor: CallableDescriptor, name: String, packageName: String): Boolean { + if (name != descriptor.name.asString()) return false + + val containingDeclaration = descriptor.containingDeclaration as? PackageFragmentDescriptor ?: return false + val packageFqName = containingDeclaration.fqName.asString() + return packageName == packageFqName } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/BoxingInterpreter.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/BoxingInterpreter.kt index f7411fea30f..b264e25486d 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/BoxingInterpreter.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/BoxingInterpreter.kt @@ -18,8 +18,8 @@ package org.jetbrains.kotlin.codegen.optimization.boxing import com.google.common.collect.ImmutableSet import org.jetbrains.kotlin.codegen.AsmUtil -import org.jetbrains.kotlin.codegen.RangeCodegenUtil import org.jetbrains.kotlin.codegen.intrinsics.IntrinsicMethods +import org.jetbrains.kotlin.codegen.isRangeOrProgression import org.jetbrains.kotlin.codegen.optimization.common.OptimizationBasicInterpreter import org.jetbrains.kotlin.codegen.optimization.common.StrictBasicValue import org.jetbrains.kotlin.name.FqName @@ -213,7 +213,7 @@ fun AbstractInsnNode.isIteratorMethodCallOfProgression(values: List) } fun isProgressionClass(type: Type) = - RangeCodegenUtil.isRangeOrProgression(buildFqNameByInternal(type.internalName)) + isRangeOrProgression(buildFqNameByInternal(type.internalName)) fun AbstractInsnNode.isAreEqualIntrinsicForSameTypedBoxedValues(values: List) = isAreEqualIntrinsic() && areSameTypedBoxedValues(values) diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/ProgressionIteratorBasicValue.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/ProgressionIteratorBasicValue.java index f27a1f24f06..00c629c27c0 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/ProgressionIteratorBasicValue.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/ProgressionIteratorBasicValue.java @@ -20,7 +20,7 @@ import com.google.common.collect.ImmutableMap; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.builtins.PrimitiveType; -import org.jetbrains.kotlin.codegen.RangeCodegenUtil; +import org.jetbrains.kotlin.codegen.RangeCodegenUtilKt; import org.jetbrains.kotlin.codegen.intrinsics.IteratorNext; import org.jetbrains.kotlin.codegen.optimization.common.StrictBasicValue; import org.jetbrains.kotlin.name.FqName; @@ -32,7 +32,7 @@ public class ProgressionIteratorBasicValue extends StrictBasicValue { private final static ImmutableMap VALUES_TYPENAME_TO_TYPE; static { ImmutableMap.Builder builder = ImmutableMap.builder(); - for (PrimitiveType primitiveType : RangeCodegenUtil.supportedRangeTypes()) { + for (PrimitiveType primitiveType : RangeCodegenUtilKt.supportedRangeTypes()) { builder.put(primitiveType.getTypeName().asString(), Type.getType(JvmPrimitiveType.get(primitiveType).getDesc())); } VALUES_TYPENAME_TO_TYPE = builder.build(); @@ -41,7 +41,7 @@ public class ProgressionIteratorBasicValue extends StrictBasicValue { private static final ImmutableMap ITERATOR_VALUE_BY_ELEMENT_PRIMITIVE_TYPE; static { ImmutableMap.Builder builder = ImmutableMap.builder(); - for (PrimitiveType elementType : RangeCodegenUtil.supportedRangeTypes()) { + for (PrimitiveType elementType : RangeCodegenUtilKt.supportedRangeTypes()) { builder.put(elementType, new ProgressionIteratorBasicValue(elementType.getTypeName().asString())); } ITERATOR_VALUE_BY_ELEMENT_PRIMITIVE_TYPE = builder.build(); @@ -67,7 +67,7 @@ public class ProgressionIteratorBasicValue extends StrictBasicValue { @Nullable public static ProgressionIteratorBasicValue byProgressionClassType(@NotNull Type progressionClassType) { FqName classFqName = new FqName(progressionClassType.getClassName()); - PrimitiveType elementType = RangeCodegenUtil.getPrimitiveRangeOrProgressionElementType(classFqName); + PrimitiveType elementType = RangeCodegenUtilKt.getPrimitiveRangeOrProgressionElementType(classFqName); return ITERATOR_VALUE_BY_ELEMENT_PRIMITIVE_TYPE.get(elementType); } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/range/RangeValues.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/range/RangeValues.kt index 6f4766d2292..efa8493dbef 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/range/RangeValues.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/range/RangeValues.kt @@ -17,8 +17,7 @@ package org.jetbrains.kotlin.codegen.range import org.jetbrains.kotlin.builtins.KotlinBuiltIns -import org.jetbrains.kotlin.codegen.ExpressionCodegen -import org.jetbrains.kotlin.codegen.RangeCodegenUtil +import org.jetbrains.kotlin.codegen.* import org.jetbrains.kotlin.descriptors.CallableDescriptor import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.psi.* @@ -42,9 +41,9 @@ fun ExpressionCodegen.createRangeValueForExpression(rangeExpression: KtExpressio return when { asmRangeType.sort == Type.ARRAY -> ArrayRangeValue() - RangeCodegenUtil.isRange(rangeType) -> + isRange(rangeType) -> PrimitiveRangeRangeValue() - RangeCodegenUtil.isProgression(rangeType) -> + isProgression(rangeType) -> PrimitiveProgressionRangeValue() isSubtypeOfCharSequence(rangeType, state.module.builtIns) -> CharSequenceRangeValue() @@ -84,17 +83,17 @@ private fun createIntrinsifiedRangeValueOrNull(rangeCall: ResolvedCall + isPrimitiveNumberRangeTo(rangeCallee) -> PrimitiveNumberRangeToRangeValue(rangeCall) - RangeCodegenUtil.isPrimitiveNumberDownTo(rangeCallee) -> + isPrimitiveNumberDownTo(rangeCallee) -> DownToProgressionRangeValue(rangeCall) - RangeCodegenUtil.isPrimitiveNumberUntil(rangeCallee) -> + isPrimitiveNumberUntil(rangeCallee) -> PrimitiveNumberUntilRangeValue(rangeCall) - RangeCodegenUtil.isArrayOrPrimitiveArrayIndices(rangeCallee) -> + isArrayOrPrimitiveArrayIndices(rangeCallee) -> ArrayIndicesRangeValue(rangeCall) - RangeCodegenUtil.isCollectionIndices(rangeCallee) -> + isCollectionIndices(rangeCallee) -> CollectionIndicesRangeValue(rangeCall) - RangeCodegenUtil.isCharSequenceIndices(rangeCallee) -> + isCharSequenceIndices(rangeCallee) -> CharSequenceIndicesRangeValue(rangeCall) else -> null