Make IntegerValueTypeConstant implements CompileTimeValue<Number>. getValue() method for it is now deprecated - getValue(expectedType) should be used

2014-01-16 15:33:23 +04:00
parent a71e062504
commit 694db27da0
9 changed files with 98 additions and 74 deletions
@@ -386,43 +386,34 @@ public class ConstantExpressionEvaluator private (val trace: BindingTrace) : Jet
    }

    private fun createOperationArgument(expression: JetExpression, expressionType: JetType, compileTimeType: CompileTimeType<*>): OperationArgument? {
-        val evaluationResult = evaluate(expression, expressionType)?.getValue()
-        if (evaluationResult == null) return null
+        val evaluatedConstant = evaluate(expression, expressionType)
+        if (evaluatedConstant == null) return null

-        if (evaluationResult is IntegerValueTypeConstructor) {
-            val evaluationResultWithNewType = evaluationResult.getValueForNumberType(expressionType)
-            if (evaluationResultWithNewType != null) {
-                return OperationArgument(evaluationResultWithNewType, compileTimeType, expression)
-            }
+        if (evaluatedConstant is IntegerValueTypeConstant) {
+            val evaluationResultWithNewType = evaluatedConstant.getValue(expressionType)
+            return OperationArgument(evaluationResultWithNewType, compileTimeType, expression)
        }

+        val evaluationResult = evaluatedConstant.getValue()
+        if (evaluationResult == null) return null
+
        return OperationArgument(evaluationResult, compileTimeType, expression)
    }

    fun createCompileTimeConstant(value: Any?, expression: JetExpression, expectedType: JetType?, isPure: Boolean = true): CompileTimeConstant<*>? {
        if (isPure) {
-            val compileTimeConstant = createConvertibleCompileTimeConstant(value, expectedType)
+            val compileTimeConstant = createCompileTimeConstant(value, expectedType ?: TypeUtils.NO_EXPECTED_TYPE)
            trace.record(BindingContext.IS_PURE_CONSTANT_EXPRESSION, expression, true)
            return compileTimeConstant
        }

-        val compileTimeConstant = createUnconvertibleCompileTimeConstant(value)
+        val compileTimeConstant = createCompileTimeConstant(value)
        return compileTimeConstant
    }
 }

-public fun IntegerValueTypeConstructor.getValueForNumberType(expectedType: JetType): Any? {
-    val valueWithNewType = this.getCompileTimeConstantForNumberType(expectedType)
-    if (valueWithNewType != null) {
-        return valueWithNewType.getValue()
-    }
-    return null
-}
-
-public fun IntegerValueTypeConstructor.getCompileTimeConstantForNumberType(expectedType: JetType): CompileTimeConstant<*>? {
-    val defaultType = TypeUtils.getPrimitiveNumberType(this, expectedType)
-    return createConvertibleCompileTimeConstant(this.getValue(), defaultType)
-}
+public fun IntegerValueTypeConstant.createCompileTimeConstantWithType(expectedType: JetType): CompileTimeConstant<*>?
+        = createCompileTimeConstant(getValue(expectedType))

 private fun hasLongSuffix(text: String) = text.endsWith('l') || text.endsWith('L')

@@ -515,25 +506,9 @@ private fun createCompileTimeConstantForCompareTo(result: Any?, operationReferen
    return null
 }

-private fun createUnconvertibleCompileTimeConstant(value: Any?): CompileTimeConstant<*>? {
-    return when(value) {
-        null -> null
-        is Byte -> ByteValue(value)
-        is Short -> ShortValue(value)
-        is Int -> IntValue(value)
-        is Long -> LongValue(value)
-        is Char -> CharValue(value)
-        is Float -> FloatValue(value)
-        is Double -> DoubleValue(value)
-        is Boolean -> BooleanValue.valueOf(value)
-        else -> null
-    }
-}
-
 private fun createStringConstant(value: CompileTimeConstant<*>?): StringValue? {
    return when (value) {
-        null -> null
-        is IntegerValueTypeConstant -> createStringConstant(value.getValue()!!.getCompileTimeConstantForNumberType(TypeUtils.NO_EXPECTED_TYPE))
+        is IntegerValueTypeConstant -> StringValue(value.getValue(TypeUtils.NO_EXPECTED_TYPE).toString())
        is StringValue -> value
        is IntValue, is ByteValue, is ShortValue, is LongValue,
        is CharValue,
@@ -543,10 +518,22 @@ private fun createStringConstant(value: CompileTimeConstant<*>?): StringValue? {
    }
 }

-private fun createConvertibleCompileTimeConstant(value: Any?, expectedType: JetType?): CompileTimeConstant<*>? {
+private fun createCompileTimeConstant(value: Any?, expectedType: JetType? = null): CompileTimeConstant<*>? {
    return when(value) {
-        null -> null
-        is Byte, is Short, is Int, is Long-> getIntegerValue((value as Number).toLong(), expectedType ?: TypeUtils.NO_EXPECTED_TYPE)
+        is Byte, is Short, is Int, is Long -> {
+            return if (expectedType == null) {
+                when(value) {
+                    is Byte -> ByteValue(value)
+                    is Short -> ShortValue(value)
+                    is Int -> IntValue(value)
+                    is Long -> LongValue(value)
+                    else -> throw IllegalArgumentException("All cases should be catched: $value")
+                }
+            }
+            else {
+                getIntegerValue((value as Number).toLong(), expectedType)
+            }
+        }
        is Char -> CharValue(value)
        is Float -> FloatValue(value)
        is Double -> DoubleValue(value)
@@ -556,6 +543,7 @@ private fun createConvertibleCompileTimeConstant(value: Any?, expectedType: JetT
    }
 }

+
 fun isIntegerType(value: Any?) = value is Byte || value is Short || value is Int || value is Long

 private fun getIntegerValue(value: Long, expectedType: JetType): CompileTimeConstant<*>? {
@@ -249,8 +249,7 @@ public class AnnotationResolver {
            if (argumentExpression != null) {
                CompileTimeConstant<?> constant = ConstantExpressionEvaluator.object$.evaluate(argumentExpression, trace, expectedType);
                if (constant instanceof IntegerValueTypeConstant) {
-                    IntegerValueTypeConstructor typeConstructor = ((IntegerValueTypeConstant) constant).getValue();
-                    JetType defaultType = getPrimitiveNumberType(typeConstructor, expectedType);
+                    JetType defaultType = ((IntegerValueTypeConstant) constant).getType(expectedType);
                    ArgumentTypeResolver.updateNumberType(defaultType, argumentExpression, trace);
                }
                if (constant != null) {
@@ -713,7 +713,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
    ) {
        JetType expressionType = value.getType(KotlinBuiltIns.getInstance());
        if (value instanceof IntegerValueTypeConstant && context.contextDependency == INDEPENDENT) {
-            expressionType = getPrimitiveNumberType(((IntegerValueTypeConstant) value).getValue(), context.expectedType);
+            expressionType = ((IntegerValueTypeConstant) value).getType(context.expectedType);
            ArgumentTypeResolver.updateNumberType(expressionType, expression, context.trace);
        }

@@ -171,7 +171,7 @@ public class DataFlowUtils {
        if (expression instanceof JetConstantExpression) {
            CompileTimeConstant<?> value = ConstantExpressionEvaluator.object$.evaluate(expression, trace, expectedType);
            if (value instanceof IntegerValueTypeConstant) {
-                value = EvaluatePackage.getCompileTimeConstantForNumberType(((IntegerValueTypeConstant) value).getValue(), expectedType);
+                value = EvaluatePackage.createCompileTimeConstantWithType((IntegerValueTypeConstant) value, expectedType);
            }
            new CompileTimeConstantChecker(trace, true).checkConstantExpressionType(value, (JetConstantExpression) expression, expectedType);
            return expressionType;