From bee2a69e219962fdae82316cf059ac292dfcc18b Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Wed, 7 Apr 2021 16:39:48 +0300 Subject: [PATCH] Implement new logic of approximation of integer literals in position of receiver #KT-38895 In Progress --- ...irOldFrontendDiagnosticsTestGenerated.java | 6 + .../evaluate/ConstantExpressionEvaluator.kt | 71 ++++++++--- .../BasicExpressionTypingVisitor.java | 16 ++- ...teralOperatorsResolution_newResolve.fir.kt | 116 ++++++++++++++++++ ...ewLiteralOperatorsResolution_newResolve.kt | 116 ++++++++++++++++++ ...wLiteralOperatorsResolution_newResolve.txt | 12 ++ .../test/runners/DiagnosticTestGenerated.java | 6 + .../ConstraintSystemTestData.kt | 2 +- .../resolve/constants/CompileTimeConstant.kt | 19 ++- 9 files changed, 337 insertions(+), 27 deletions(-) create mode 100644 compiler/testData/diagnostics/tests/numbers/newLiteralOperatorsResolution_newResolve.fir.kt create mode 100644 compiler/testData/diagnostics/tests/numbers/newLiteralOperatorsResolution_newResolve.kt create mode 100644 compiler/testData/diagnostics/tests/numbers/newLiteralOperatorsResolution_newResolve.txt diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java index c83afcd3996..011fac1aa16 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java +++ b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java @@ -19087,6 +19087,12 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti runTest("compiler/testData/diagnostics/tests/numbers/literalReceiverWithIntegerValueType.kt"); } + @Test + @TestMetadata("newLiteralOperatorsResolution_newResolve.kt") + public void testNewLiteralOperatorsResolution_newResolve() throws Exception { + runTest("compiler/testData/diagnostics/tests/numbers/newLiteralOperatorsResolution_newResolve.kt"); + } + @Test @TestMetadata("newLiteralOperatorsResolution_warning.kt") public void testNewLiteralOperatorsResolution_warning() throws Exception { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt index b113512816f..2a69083c66c 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt @@ -279,9 +279,10 @@ class ConstantExpressionEvaluator( fun evaluateExpression( expression: KtExpression, trace: BindingTrace, - expectedType: KotlinType? = TypeUtils.NO_EXPECTED_TYPE + expectedType: KotlinType? = TypeUtils.NO_EXPECTED_TYPE, + isIndependentContext: Boolean = false ): CompileTimeConstant<*>? { - val visitor = ConstantExpressionEvaluatorVisitor(this, trace) + val visitor = ConstantExpressionEvaluatorVisitor(this, trace, isIndependentContext) val constant = visitor.evaluate(expression, expectedType) ?: return null checkExperimentalityOfConstantLiteral(expression, constant, expectedType, trace) @@ -369,10 +370,12 @@ private val DIVISION_OPERATION_NAMES = private class ConstantExpressionEvaluatorVisitor( private val constantExpressionEvaluator: ConstantExpressionEvaluator, - private val trace: BindingTrace + private val trace: BindingTrace, + private val isIndependentContext: Boolean ) : KtVisitor?, KotlinType>() { private val languageVersionSettings = constantExpressionEvaluator.languageVersionSettings private val builtIns = constantExpressionEvaluator.module.builtIns + private val defaultValueForDontCreateIntegerLiteralType = languageVersionSettings.supportsFeature(LanguageFeature.ApproximateIntegerLiteralTypesInReceiverPosition) fun evaluate(expression: KtExpression, expectedType: KotlinType?): CompileTimeConstant<*>? { val recordedCompileTimeConstant = ConstantExpressionEvaluator.getPossiblyErrorConstant(expression, trace.bindingContext) @@ -472,7 +475,8 @@ private class ConstantExpressionEvaluatorVisitor( isUnsignedLongNumberLiteral = isUnsignedLong, usesVariableAsConstant = false, usesNonConstValAsConstant = false, - isConvertableConstVal = false + isConvertableConstVal = false, + dontCreateILT = defaultValueForDontCreateIntegerLiteralType && isIndependentContext ) ) } @@ -522,7 +526,8 @@ private class ConstantExpressionEvaluatorVisitor( canBeUsedInAnnotation = canBeUsedInAnnotation, usesVariableAsConstant = usesVariableAsConstant, usesNonConstValAsConstant = usesNonConstantVariableAsConstant, - isConvertableConstVal = false + isConvertableConstVal = false, + dontCreateILT = false ) ) else null @@ -586,7 +591,8 @@ private class ConstantExpressionEvaluatorVisitor( isUnsignedLongNumberLiteral = false, usesVariableAsConstant = leftConstant.usesVariableAsConstant || rightConstant.usesVariableAsConstant, usesNonConstValAsConstant = leftConstant.usesNonConstValAsConstant || rightConstant.usesNonConstValAsConstant, - isConvertableConstVal = false + isConvertableConstVal = false, + dontCreateILT = false ) ) } else { @@ -605,7 +611,8 @@ private class ConstantExpressionEvaluatorVisitor( private fun evaluateCall( callExpression: KtExpression, receiverExpression: KtExpression, - expectedType: KotlinType? + expectedType: KotlinType?, + isUnaryPlusMinus: Boolean = false ): CompileTimeConstant<*>? { val resolvedCall = callExpression.getResolvedCall(trace.bindingContext) ?: return null if (!KotlinBuiltIns.isUnderKotlinPackage(resolvedCall.resultingDescriptor)) return null @@ -632,9 +639,12 @@ private class ConstantExpressionEvaluatorVisitor( CompileTimeConstant.Parameters( canBeUsedInAnnotation, !isNumberConversionMethod && isArgumentPure, - false, false, - usesVariableAsConstant, usesNonConstValAsConstant, - false + isUnsignedNumberLiteral = false, + isUnsignedLongNumberLiteral = false, + usesVariableAsConstant, + usesNonConstValAsConstant, + isConvertableConstVal = false, + dontCreateILT = !isUnaryPlusMinus && defaultValueForDontCreateIntegerLiteralType && !hasIntegerLiteralType(receiverExpression) ) ) } else if (argumentsEntrySet.size == 1) { @@ -667,7 +677,14 @@ private class ConstantExpressionEvaluatorVisitor( val usesNonConstValAsConstant = usesNonConstValAsConstant(argumentForReceiver.expression) || usesNonConstValAsConstant(argumentForParameter.expression) val parameters = CompileTimeConstant.Parameters( - canBeUsedInAnnotation, areArgumentsPure, false, false, usesVariableAsConstant, usesNonConstValAsConstant, false + canBeUsedInAnnotation, + areArgumentsPure, + isUnsignedNumberLiteral = false, + isUnsignedLongNumberLiteral = false, + usesVariableAsConstant, + usesNonConstValAsConstant, + isConvertableConstVal = false, + dontCreateILT = defaultValueForDontCreateIntegerLiteralType && !hasIntegerLiteralType(receiverExpression) ) return when (resultingDescriptorName) { OperatorNameConventions.COMPARE_TO -> createCompileTimeConstantForCompareTo(result, callExpression)?.wrap(parameters) @@ -693,6 +710,9 @@ private class ConstantExpressionEvaluatorVisitor( private fun isPureConstant(expression: KtExpression) = ConstantExpressionEvaluator.getConstant(expression, trace.bindingContext)?.isPure ?: false + private fun hasIntegerLiteralType(expression: KtExpression): Boolean = + ConstantExpressionEvaluator.getConstant(expression, trace.bindingContext)?.hasIntegerLiteralType ?: false + private fun evaluateUnaryAndCheck(receiver: OperationArgument, name: String, callExpression: KtExpression): Any? { return evaluateUnaryAndCheck(name, receiver.ctcType, receiver.value) { trace.report(Errors.INTEGER_OVERFLOW.on(callExpression.getStrictParentOfType() ?: callExpression)) @@ -716,8 +736,13 @@ private class ConstantExpressionEvaluatorVisitor( override fun visitUnaryExpression(expression: KtUnaryExpression, expectedType: KotlinType?): CompileTimeConstant<*>? { val leftExpression = expression.baseExpression ?: return null - - return evaluateCall(expression.operationReference, leftExpression, expectedType) + val tokenType = expression.operationToken + return evaluateCall( + expression.operationReference, + leftExpression, + expectedType, + isUnaryPlusMinus = tokenType == KtTokens.PLUS || tokenType == KtTokens.MINUS + ) } override fun visitSimpleNameExpression(expression: KtSimpleNameExpression, expectedType: KotlinType?): CompileTimeConstant<*>? { @@ -747,7 +772,8 @@ private class ConstantExpressionEvaluatorVisitor( isUnsignedLongNumberLiteral = false, usesVariableAsConstant = true, usesNonConstValAsConstant = !callableDescriptor.isConst, - isConvertableConstVal = isConvertableConstVal + isConvertableConstVal = isConvertableConstVal, + dontCreateILT = true ) ) } @@ -981,7 +1007,7 @@ private class ConstantExpressionEvaluatorVisitor( value: Long, parameters: CompileTimeConstant.Parameters, expectedType: KotlinType - ): CompileTimeConstant<*>? { + ): CompileTimeConstant<*> { if (parameters.isUnsignedNumberLiteral && !checkAccessibilityOfUnsignedTypes()) { return UnsignedErrorValueTypeConstant(value, parameters) } @@ -991,7 +1017,9 @@ private class ConstantExpressionEvaluatorVisitor( } if (TypeUtils.noExpectedType(expectedType) || expectedType.isError) { - return createIntegerValueTypeConstant( + return if (parameters.dontCreateILT) { + value.createSimpleIntCompileTimeConst(parameters) + } else createIntegerValueTypeConstant( value, constantExpressionEvaluator.module, parameters, @@ -1005,6 +1033,11 @@ private class ConstantExpressionEvaluatorVisitor( return integerValue.wrap(parameters) } + return value.createSimpleIntCompileTimeConst(parameters) + } + + private fun Long.createSimpleIntCompileTimeConst(parameters: CompileTimeConstant.Parameters): TypedCompileTimeConstant<*> { + val value = this return if (parameters.isUnsignedNumberLiteral) { when (value) { value.toInt().fromUIntToLong() -> UIntValue(value.toInt()) @@ -1035,7 +1068,8 @@ private class ConstantExpressionEvaluatorVisitor( isUnsignedLong: Boolean = false, usesVariableAsConstant: Boolean = false, usesNonConstValAsConstant: Boolean = false, - isConvertableConstVal: Boolean = false + isConvertableConstVal: Boolean = false, + dontCreateILT: Boolean = false ): TypedCompileTimeConstant = wrap( CompileTimeConstant.Parameters( @@ -1045,7 +1079,8 @@ private class ConstantExpressionEvaluatorVisitor( isUnsignedLong, usesVariableAsConstant, usesNonConstValAsConstant, - isConvertableConstVal + isConvertableConstVal, + dontCreateILT ) ) } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java index fd5c9a4ee78..055504cbee4 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java @@ -172,7 +172,9 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { KotlinTypeInfo typeInfo = callExpressionResolver.getSimpleNameExpressionTypeInfo(expression, null, null, context); checkNull(expression, context, typeInfo.getType()); - components.constantExpressionEvaluator.evaluateExpression(expression, context.trace, context.expectedType); + components.constantExpressionEvaluator.evaluateExpression( + expression, context.trace, context.expectedType, evaluateIntegerConstantInIndependentMode(context) + ); return components.dataFlowAnalyzer.checkType(typeInfo, expression, context); // TODO : Extensions to this } @@ -207,7 +209,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { } CompileTimeConstant compileTimeConstant = components.constantExpressionEvaluator.evaluateExpression( - expression, context.trace, context.expectedType + expression, context.trace, context.expectedType, evaluateIntegerConstantInIndependentMode(context) ); if (compileTimeConstant instanceof UnsignedErrorValueTypeConstant) { @@ -793,7 +795,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { } CompileTimeConstant value = components.constantExpressionEvaluator.evaluateExpression( - expression, contextWithExpectedType.trace, contextWithExpectedType.expectedType + expression, contextWithExpectedType.trace, contextWithExpectedType.expectedType, evaluateIntegerConstantInIndependentMode(context) ); if (value != null) { return components.dataFlowAnalyzer.createCompileTimeConstantTypeInfo(value, expression, contextWithExpectedType); @@ -1086,7 +1088,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { result = TypeInfoFactoryKt.noTypeInfo(context); } CompileTimeConstant value = components.constantExpressionEvaluator.evaluateExpression( - expression, contextWithExpectedType.trace, contextWithExpectedType.expectedType + expression, contextWithExpectedType.trace, contextWithExpectedType.expectedType, evaluateIntegerConstantInIndependentMode(context) ); if (value != null) { return components.dataFlowAnalyzer.createCompileTimeConstantTypeInfo(value, expression, contextWithExpectedType); @@ -1595,7 +1597,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { for (KtStringTemplateEntry entry : expression.getEntries()) { entry.accept(visitor); } - components.constantExpressionEvaluator.evaluateExpression(expression, context.trace, contextWithExpectedType.expectedType); + components.constantExpressionEvaluator.evaluateExpression(expression, context.trace, contextWithExpectedType.expectedType, evaluateIntegerConstantInIndependentMode(context)); return components.dataFlowAnalyzer.checkType(visitor.typeInfo.replaceType(components.builtIns.getStringType()), expression, contextWithExpectedType); @@ -1798,4 +1800,8 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { return BindingContextUtils.getRecordedTypeInfo(expression, context.trace.getBindingContext()); } } + + private boolean evaluateIntegerConstantInIndependentMode(ExpressionTypingContext context) { + return context.contextDependency == INDEPENDENT && context.languageVersionSettings.supportsFeature(LanguageFeature.ApproximateIntegerLiteralTypesInReceiverPosition); + } } diff --git a/compiler/testData/diagnostics/tests/numbers/newLiteralOperatorsResolution_newResolve.fir.kt b/compiler/testData/diagnostics/tests/numbers/newLiteralOperatorsResolution_newResolve.fir.kt new file mode 100644 index 00000000000..554cbb4ca2c --- /dev/null +++ b/compiler/testData/diagnostics/tests/numbers/newLiteralOperatorsResolution_newResolve.fir.kt @@ -0,0 +1,116 @@ +// LANGUAGE: +ApproximateIntegerLiteralTypesInReceiverPosition +// WITH_STDLIB +// ISSUE: KT-38895 + +fun takeByte(b: Byte) {} +fun takeInt(b: Int) {} +fun takeLong(b: Long) {} + +fun testByteBinaryOperators() { + takeByte(2 + 1) + takeByte(2 - 1) + takeByte(2 * 1) + takeByte(2 / 1) + takeByte(2 % 1) + + takeByte(2.plus(1)) + takeByte(2.minus(1)) + takeByte(2.times(1)) + takeByte(2.div(1)) + takeByte(2.rem(1)) + takeByte(2 shl 1) + takeByte(2 shr 1) + takeByte(2 ushr 1) + + takeByte(2 and 1) + takeByte(2 or 1) + takeByte(2 xor 1) +} + +fun testByteUnaryOperators() { + // No mismatch + takeByte(+1) + takeByte(-1) + + // Mismatch + takeByte(2.unaryPlus()) + takeByte(2.unaryMinus()) + takeByte(2.inv()) + takeByte(1.inc()) + takeByte(1.dec()) +} + +fun testLongBinaryOperators() { + takeLong(2 + 1) + takeLong(2 - 1) + takeLong(2 * 1) + takeLong(2 / 1) + takeLong(2 % 1) + + takeLong(2.plus(1)) + takeLong(2.minus(1)) + takeLong(2.times(1)) + takeLong(2.div(1)) + takeLong(2.rem(1)) + takeLong(2 shl 1) + takeLong(2 shr 1) + takeLong(2 ushr 1) + + takeLong(2 and 1) + takeLong(2 or 1) + takeLong(2 xor 1) + + // positive + takeLong(2 * 100000000000) +} + +fun testLongUnaryOperators() { + // No mismatch + takeLong(+1) + takeLong(-1) + + // Mismatch + takeLong(2.unaryPlus()) + takeLong(2.unaryMinus()) + takeLong(2.inv()) + takeLong(1.inc()) + takeLong(1.dec()) +} + +fun testIntBinaryOperators() { + takeInt(2 + 1) + takeInt(2 - 1) + takeInt(2 * 1) + takeInt(2 / 1) + takeInt(2 % 1) + + takeInt(2.plus(1)) + takeInt(2.minus(1)) + takeInt(2.times(1)) + takeInt(2.div(1)) + takeInt(2.rem(1)) + takeInt(2 shl 1) + takeInt(2 shr 1) + takeInt(2 ushr 1) + + takeInt(2 and 1) + takeInt(2 or 1) + takeInt(2 xor 1) +} + +fun testIntUnaryOperators() { + takeInt(+1) + takeInt(-1) + + takeInt(2.unaryPlus()) + takeInt(2.unaryMinus()) + takeInt(2.inv()) + takeInt(1.inc()) + takeInt(1.dec()) +} + +fun testNoOperators() { + takeByte(1) + takeInt(1) + takeLong(1) +} diff --git a/compiler/testData/diagnostics/tests/numbers/newLiteralOperatorsResolution_newResolve.kt b/compiler/testData/diagnostics/tests/numbers/newLiteralOperatorsResolution_newResolve.kt new file mode 100644 index 00000000000..436e0fd0740 --- /dev/null +++ b/compiler/testData/diagnostics/tests/numbers/newLiteralOperatorsResolution_newResolve.kt @@ -0,0 +1,116 @@ +// LANGUAGE: +ApproximateIntegerLiteralTypesInReceiverPosition +// WITH_STDLIB +// ISSUE: KT-38895 + +fun takeByte(b: Byte) {} +fun takeInt(b: Int) {} +fun takeLong(b: Long) {} + +fun testByteBinaryOperators() { + takeByte(2 + 1) + takeByte(2 - 1) + takeByte(2 * 1) + takeByte(2 / 1) + takeByte(2 % 1) + + takeByte(2.plus(1)) + takeByte(2.minus(1)) + takeByte(2.times(1)) + takeByte(2.div(1)) + takeByte(2.rem(1)) + takeByte(2 shl 1) + takeByte(2 shr 1) + takeByte(2 ushr 1) + + takeByte(2 and 1) + takeByte(2 or 1) + takeByte(2 xor 1) +} + +fun testByteUnaryOperators() { + // No mismatch + takeByte(+1) + takeByte(-1) + + // Mismatch + takeByte(2.unaryPlus()) + takeByte(2.unaryMinus()) + takeByte(2.inv()) + takeByte(1.inc()) + takeByte(1.dec()) +} + +fun testLongBinaryOperators() { + takeLong(2 + 1) + takeLong(2 - 1) + takeLong(2 * 1) + takeLong(2 / 1) + takeLong(2 % 1) + + takeLong(2.plus(1)) + takeLong(2.minus(1)) + takeLong(2.times(1)) + takeLong(2.div(1)) + takeLong(2.rem(1)) + takeLong(2 shl 1) + takeLong(2 shr 1) + takeLong(2 ushr 1) + + takeLong(2 and 1) + takeLong(2 or 1) + takeLong(2 xor 1) + + // positive + takeLong(2 * 100000000000) +} + +fun testLongUnaryOperators() { + // No mismatch + takeLong(+1) + takeLong(-1) + + // Mismatch + takeLong(2.unaryPlus()) + takeLong(2.unaryMinus()) + takeLong(2.inv()) + takeLong(1.inc()) + takeLong(1.dec()) +} + +fun testIntBinaryOperators() { + takeInt(2 + 1) + takeInt(2 - 1) + takeInt(2 * 1) + takeInt(2 / 1) + takeInt(2 % 1) + + takeInt(2.plus(1)) + takeInt(2.minus(1)) + takeInt(2.times(1)) + takeInt(2.div(1)) + takeInt(2.rem(1)) + takeInt(2 shl 1) + takeInt(2 shr 1) + takeInt(2 ushr 1) + + takeInt(2 and 1) + takeInt(2 or 1) + takeInt(2 xor 1) +} + +fun testIntUnaryOperators() { + takeInt(+1) + takeInt(-1) + + takeInt(2.unaryPlus()) + takeInt(2.unaryMinus()) + takeInt(2.inv()) + takeInt(1.inc()) + takeInt(1.dec()) +} + +fun testNoOperators() { + takeByte(1) + takeInt(1) + takeLong(1) +} diff --git a/compiler/testData/diagnostics/tests/numbers/newLiteralOperatorsResolution_newResolve.txt b/compiler/testData/diagnostics/tests/numbers/newLiteralOperatorsResolution_newResolve.txt new file mode 100644 index 00000000000..40c7f607706 --- /dev/null +++ b/compiler/testData/diagnostics/tests/numbers/newLiteralOperatorsResolution_newResolve.txt @@ -0,0 +1,12 @@ +package + +public fun takeByte(/*0*/ b: kotlin.Byte): kotlin.Unit +public fun takeInt(/*0*/ b: kotlin.Int): kotlin.Unit +public fun takeLong(/*0*/ b: kotlin.Long): kotlin.Unit +public fun testByteBinaryOperators(): kotlin.Unit +public fun testByteUnaryOperators(): kotlin.Unit +public fun testIntBinaryOperators(): kotlin.Unit +public fun testIntUnaryOperators(): kotlin.Unit +public fun testLongBinaryOperators(): kotlin.Unit +public fun testLongUnaryOperators(): kotlin.Unit +public fun testNoOperators(): kotlin.Unit diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java index 677b0fb815f..793776c06b2 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java @@ -19093,6 +19093,12 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { runTest("compiler/testData/diagnostics/tests/numbers/literalReceiverWithIntegerValueType.kt"); } + @Test + @TestMetadata("newLiteralOperatorsResolution_newResolve.kt") + public void testNewLiteralOperatorsResolution_newResolve() throws Exception { + runTest("compiler/testData/diagnostics/tests/numbers/newLiteralOperatorsResolution_newResolve.kt"); + } + @Test @TestMetadata("newLiteralOperatorsResolution_warning.kt") public void testNewLiteralOperatorsResolution_warning() throws Exception { diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/resolve/constraintSystem/ConstraintSystemTestData.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/resolve/constraintSystem/ConstraintSystemTestData.kt index 954d371dd11..409264e2516 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/resolve/constraintSystem/ConstraintSystemTestData.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/resolve/constraintSystem/ConstraintSystemTestData.kt @@ -65,7 +65,7 @@ class ConstraintSystemTestData( val matcher = INTEGER_VALUE_TYPE_PATTERN.matcher(name) if (matcher.find()) { val number = matcher.group(1)!! - val parameters = CompileTimeConstant.Parameters(false, false, false, false, false, false, false) + val parameters = CompileTimeConstant.Parameters(false, false, false, false, false, false, false, false) return KotlinTypeFactory.simpleTypeWithNonTrivialMemberScope( Annotations.EMPTY, IntegerValueTypeConstructor(number.toLong(), functionFoo.module, parameters), diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstant.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstant.kt index c7cbd72620f..6d04ae75b8d 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstant.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstant.kt @@ -46,6 +46,8 @@ interface CompileTimeConstant { val isUnsignedNumberLiteral: Boolean get() = parameters.isUnsignedNumberLiteral + val hasIntegerLiteralType: Boolean + data class Parameters( val canBeUsedInAnnotation: Boolean, val isPure: Boolean, @@ -56,7 +58,8 @@ interface CompileTimeConstant { val usesVariableAsConstant: Boolean, val usesNonConstValAsConstant: Boolean, // `isConvertableConstVal` means that this is `const val` that has `ImplicitIntegerCoercion` annotation - val isConvertableConstVal: Boolean + val isConvertableConstVal: Boolean, + val dontCreateILT: Boolean ) override fun equals(other: Any?): Boolean @@ -90,6 +93,9 @@ class TypedCompileTimeConstant( result = 31 * result + type.hashCode() return result } + + override val hasIntegerLiteralType: Boolean + get() = false } fun createIntegerValueTypeConstant( @@ -120,6 +126,9 @@ class UnsignedErrorValueTypeConstant( override fun equals(other: Any?) = other is UnsignedErrorValueTypeConstant && value == other.value override fun hashCode() = value.hashCode() + + override val hasIntegerLiteralType: Boolean + get() = false } class IntegerValueTypeConstant( @@ -139,7 +148,8 @@ class IntegerValueTypeConstant( isUnsignedLongNumberLiteral = parameters.isUnsignedLongNumberLiteral, usesVariableAsConstant = parameters.usesVariableAsConstant, usesNonConstValAsConstant = parameters.usesNonConstValAsConstant, - isConvertableConstVal = parameters.isConvertableConstVal + isConvertableConstVal = parameters.isConvertableConstVal, + dontCreateILT = false ) return IntegerValueTypeConstant(value, module, newParameters, newInferenceEnabled, convertedFromSigned = true) @@ -153,7 +163,8 @@ class IntegerValueTypeConstant( isUnsignedLongNumberLiteral = parameters.isUnsignedLongNumberLiteral, usesVariableAsConstant = parameters.usesVariableAsConstant, usesNonConstValAsConstant = parameters.usesNonConstValAsConstant, - isConvertableConstVal = parameters.isConvertableConstVal + isConvertableConstVal = parameters.isConvertableConstVal, + dontCreateILT = false ) return IntegerValueTypeConstant(value, module, newParameters, newInferenceEnabled, convertedFromSigned = true) @@ -202,4 +213,6 @@ class IntegerValueTypeConstant( override fun hashCode() = 31 * value.hashCode() + parameters.hashCode() + override val hasIntegerLiteralType: Boolean + get() = true }