azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add constructor parameter for compileTimeConstant (can be used in annotation)

Browse Source
This commit is contained in:
Natalia Ukhorskaya
2014-01-23 15:40:11 +04:00
parent fd3f852a93
commit 3f429116e5
37 changed files with 276 additions and 175 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TraceBasedJavaResolverCache.java
+3 -2
View File
@@ -90,11 +90,12 @@ public class TraceBasedJavaResolverCache implements JavaResolverCache {
PsiField psiField = ((JavaFieldImpl) field).getPsi(); PsiField psiField = ((JavaFieldImpl) field).getPsi();
trace.record(VARIABLE, psiField, descriptor); trace.record(VARIABLE, psiField, descriptor);
if (AnnotationUtils.isPropertyCompileTimeConstant(descriptor)) { if (!descriptor.isVar()) {
PsiExpression initializer = psiField.getInitializer(); PsiExpression initializer = psiField.getInitializer();
Object evaluatedExpression = JavaConstantExpressionEvaluator.computeConstantExpression(initializer, false); Object evaluatedExpression = JavaConstantExpressionEvaluator.computeConstantExpression(initializer, false);
if (evaluatedExpression != null) { if (evaluatedExpression != null) {
CompileTimeConstant<?> constant = JavaAnnotationArgumentResolver.resolveCompileTimeConstantValue(evaluatedExpression, descriptor.getType()); CompileTimeConstant<?> constant = JavaAnnotationArgumentResolver.
resolveCompileTimeConstantValue(evaluatedExpression, AnnotationUtils.isPropertyCompileTimeConstant(descriptor), descriptor.getType());
if (constant != null) { if (constant != null) {
trace.record(COMPILE_TIME_INITIALIZER, descriptor, constant); trace.record(COMPILE_TIME_INITIALIZER, descriptor, constant);
} }
compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java
+6 -2
View File
@@ -555,8 +555,12 @@ public class JetControlFlowProcessor {
} }
boolean conditionIsTrueConstant = false; boolean conditionIsTrueConstant = false;
if (condition instanceof JetConstantExpression && condition.getNode().getElementType() == JetNodeTypes.BOOLEAN_CONSTANT) { if (condition instanceof JetConstantExpression && condition.getNode().getElementType() == JetNodeTypes.BOOLEAN_CONSTANT) {
if (BooleanValue.TRUE == ConstantExpressionEvaluator.object$.evaluate(condition, trace, KotlinBuiltIns.getInstance().getBooleanType())) { CompileTimeConstant<?> compileTimeConstant = ConstantExpressionEvaluator.object$.evaluate(condition, trace, KotlinBuiltIns.getInstance().getBooleanType());
conditionIsTrueConstant = true; if (compileTimeConstant instanceof BooleanValue) {
Boolean value = ((BooleanValue) compileTimeConstant).getValue();
if (Boolean.TRUE.equals(value)) {
conditionIsTrueConstant = true;
}
} }
} }
if (!conditionIsTrueConstant) { if (!conditionIsTrueConstant) {
compiler/frontend/src/org/jetbrains/jet/lang/evaluate/ConstantExpressionEvaluator.kt
+52 -47
View File
@@ -74,9 +74,9 @@ public class ConstantExpressionEvaluator private (val trace: BindingTrace) : Jet
return createStringConstant(this@ConstantExpressionEvaluator.evaluate(expression, KotlinBuiltIns.getInstance().getStringType())) return createStringConstant(this@ConstantExpressionEvaluator.evaluate(expression, KotlinBuiltIns.getInstance().getStringType()))
} }
override fun visitLiteralStringTemplateEntry(entry: JetLiteralStringTemplateEntry, data: Nothing?) = StringValue(entry.getText()) override fun visitLiteralStringTemplateEntry(entry: JetLiteralStringTemplateEntry, data: Nothing?) = StringValue(entry.getText(), true)
override fun visitEscapeStringTemplateEntry(entry: JetEscapeStringTemplateEntry, data: Nothing?) = StringValue(entry.getUnescapedValue()) override fun visitEscapeStringTemplateEntry(entry: JetEscapeStringTemplateEntry, data: Nothing?) = StringValue(entry.getUnescapedValue(), true)
} }
override fun visitConstantExpression(expression: JetConstantExpression, expectedType: JetType?): CompileTimeConstant<*>? { override fun visitConstantExpression(expression: JetConstantExpression, expectedType: JetType?): CompileTimeConstant<*>? {
@@ -123,6 +123,7 @@ public class ConstantExpressionEvaluator private (val trace: BindingTrace) : Jet
override fun visitStringTemplateExpression(expression: JetStringTemplateExpression, expectedType: JetType?): CompileTimeConstant<*>? { override fun visitStringTemplateExpression(expression: JetStringTemplateExpression, expectedType: JetType?): CompileTimeConstant<*>? {
val sb = StringBuilder() val sb = StringBuilder()
var interupted = false var interupted = false
var canBeUsedInAnnotation = true
for (entry in expression.getEntries()) { for (entry in expression.getEntries()) {
val constant = stringExpressionEvaluator.evaluate(entry) val constant = stringExpressionEvaluator.evaluate(entry)
if (constant == null) { if (constant == null) {
@@ -130,10 +131,11 @@ public class ConstantExpressionEvaluator private (val trace: BindingTrace) : Jet
break break
} }
else { else {
if (!constant.canBeUsedInAnnotations()) canBeUsedInAnnotation = false
sb.append(constant.getValue()) sb.append(constant.getValue())
} }
} }
return if (!interupted) createCompileTimeConstant(sb.toString(), expression, expectedType) else null return if (!interupted) createCompileTimeConstant(sb.toString(), expression, expectedType, true, canBeUsedInAnnotation) else null
} }
override fun visitBinaryExpression(expression: JetBinaryExpression, expectedType: JetType?): CompileTimeConstant<*>? { override fun visitBinaryExpression(expression: JetBinaryExpression, expectedType: JetType?): CompileTimeConstant<*>? {
@@ -198,13 +200,15 @@ public class ConstantExpressionEvaluator private (val trace: BindingTrace) : Jet
val result = evaluateBinaryAndCheck(argumentForReceiver, argumentForParameter, resultingDescriptorName.asString(), callExpression) val result = evaluateBinaryAndCheck(argumentForReceiver, argumentForParameter, resultingDescriptorName.asString(), callExpression)
val canBeUsedInAnnotation = canBeUsedInAnnotation(argumentForReceiver.expression) && canBeUsedInAnnotation(argumentForParameter.expression)
val context = EvaluatorContext(canBeUsedInAnnotation)
return when(resultingDescriptorName) { return when(resultingDescriptorName) {
OperatorConventions.COMPARE_TO -> createCompileTimeConstantForCompareTo(result, callExpression) OperatorConventions.COMPARE_TO -> createCompileTimeConstantForCompareTo(result, callExpression, context)
OperatorConventions.EQUALS -> createCompileTimeConstantForEquals(result, callExpression) OperatorConventions.EQUALS -> createCompileTimeConstantForEquals(result, callExpression, context)
else -> { else -> {
val areArgumentsPure = trace.get(BindingContext.IS_PURE_CONSTANT_EXPRESSION, argumentForReceiver.expression) ?: false && val areArgumentsPure = trace.get(BindingContext.IS_PURE_CONSTANT_EXPRESSION, argumentForReceiver.expression) ?: false &&
trace.get(BindingContext.IS_PURE_CONSTANT_EXPRESSION, argumentForParameter.expression) ?: false trace.get(BindingContext.IS_PURE_CONSTANT_EXPRESSION, argumentForParameter.expression) ?: false
val canBeUsedInAnnotation = canBeUsedInAnnotation(argumentForReceiver.expression) && canBeUsedInAnnotation(argumentForParameter.expression)
createCompileTimeConstant(result, fullExpression, expectedType, areArgumentsPure, canBeUsedInAnnotation) createCompileTimeConstant(result, fullExpression, expectedType, areArgumentsPure, canBeUsedInAnnotation)
} }
} }
@@ -339,7 +343,7 @@ public class ConstantExpressionEvaluator private (val trace: BindingTrace) : Jet
val varargType = resultingDescriptor.getValueParameters().first?.getVarargElementType()!! val varargType = resultingDescriptor.getValueParameters().first?.getVarargElementType()!!
val arguments = call.getValueArguments().values().flatMap { resolveArguments(it.getArguments(), varargType) } val arguments = call.getValueArguments().values().flatMap { resolveArguments(it.getArguments(), varargType) }
return ArrayValue(arguments, resultingDescriptor.getReturnType()!!) return ArrayValue(arguments, resultingDescriptor.getReturnType()!!, true)
} }
// Ann() // Ann()
@@ -355,7 +359,7 @@ public class ConstantExpressionEvaluator private (val trace: BindingTrace) : Jet
// javaClass() // javaClass()
if (AnnotationUtils.isJavaClassMethodCall(call)) { if (AnnotationUtils.isJavaClassMethodCall(call)) {
return JavaClassValue(resultingDescriptor.getReturnType()) return JavaClassValue(resultingDescriptor.getReturnType()!!)
} }
return null return null
@@ -366,9 +370,9 @@ public class ConstantExpressionEvaluator private (val trace: BindingTrace) : Jet
for (argument in valueArguments) { for (argument in valueArguments) {
val argumentExpression = argument.getArgumentExpression() val argumentExpression = argument.getArgumentExpression()
if (argumentExpression != null) { if (argumentExpression != null) {
val constant = evaluate(argumentExpression, expectedType) val compileTimeConstant = evaluate(argumentExpression, expectedType)
if (constant != null) { if (compileTimeConstant != null) {
constants.add(constant) constants.add(compileTimeConstant)
} }
} }
} }
@@ -420,14 +424,13 @@ public class ConstantExpressionEvaluator private (val trace: BindingTrace) : Jet
} }
fun createCompileTimeConstant(value: Any?, expression: JetExpression, expectedType: JetType?, isPure: Boolean = true, canBeUsedInAnnotation: Boolean = true): CompileTimeConstant<*>? { fun createCompileTimeConstant(value: Any?, expression: JetExpression, expectedType: JetType?, isPure: Boolean = true, canBeUsedInAnnotation: Boolean = true): CompileTimeConstant<*>? {
val c = EvaluatorContext(canBeUsedInAnnotation)
val compileTimeConstant = val compileTimeConstant =
if (isPure) { if (isPure) {
trace.record(BindingContext.IS_PURE_CONSTANT_EXPRESSION, expression, true) trace.record(BindingContext.IS_PURE_CONSTANT_EXPRESSION, expression, true)
createCompileTimeConstant(value, expectedType ?: TypeUtils.NO_EXPECTED_TYPE) createCompileTimeConstant(value, c, expectedType ?: TypeUtils.NO_EXPECTED_TYPE)
} }
else createCompileTimeConstant(value) else createCompileTimeConstant(value, c)
compileTimeConstant?.setCanBeUsedInAnnotations(canBeUsedInAnnotation)
return compileTimeConstant return compileTimeConstant
} }
@@ -450,7 +453,7 @@ public fun recordCompileTimeValueForInitializerIfNeeded(
} }
public fun IntegerValueTypeConstant.createCompileTimeConstantWithType(expectedType: JetType): CompileTimeConstant<*>? public fun IntegerValueTypeConstant.createCompileTimeConstantWithType(expectedType: JetType): CompileTimeConstant<*>?
= createCompileTimeConstant(getValue(expectedType)) = createCompileTimeConstant(getValue(expectedType), EvaluatorContext(canBeUsedInAnnotations()))
private fun hasLongSuffix(text: String) = text.endsWith('l') || text.endsWith('L') private fun hasLongSuffix(text: String) = text.endsWith('l') || text.endsWith('L')
@@ -507,16 +510,16 @@ private fun parseBoolean(text: String): Boolean {
} }
private fun createCompileTimeConstantForEquals(result: Any?, operationReference: JetExpression): CompileTimeConstant<*>? { private fun createCompileTimeConstantForEquals(result: Any?, operationReference: JetExpression, context: EvaluatorContext): CompileTimeConstant<*>? {
if (result is Boolean) { if (result is Boolean) {
assert(operationReference is JetSimpleNameExpression, "This method should be called only for equals operations") assert(operationReference is JetSimpleNameExpression, "This method should be called only for equals operations")
val operationToken = (operationReference as JetSimpleNameExpression).getReferencedNameElementType() val operationToken = (operationReference as JetSimpleNameExpression).getReferencedNameElementType()
return when (operationToken) { return when (operationToken) {
JetTokens.EQEQ -> BooleanValue.valueOf(result) JetTokens.EQEQ -> BooleanValue(result, context.canBeUsedInAnnotation)
JetTokens.EXCLEQ -> BooleanValue.valueOf(!result) JetTokens.EXCLEQ -> BooleanValue(!result, context.canBeUsedInAnnotation)
JetTokens.IDENTIFIER -> { JetTokens.IDENTIFIER -> {
assert ((operationReference as JetSimpleNameExpression).getReferencedNameAsName() == OperatorConventions.EQUALS, "This method should be called only for equals operations") assert ((operationReference as JetSimpleNameExpression).getReferencedNameAsName() == OperatorConventions.EQUALS, "This method should be called only for equals operations")
return BooleanValue.valueOf(result) return BooleanValue(result, context.canBeUsedInAnnotation)
} }
else -> throw IllegalStateException("Unknown equals operation token: $operationToken ${operationReference.getText()}") else -> throw IllegalStateException("Unknown equals operation token: $operationToken ${operationReference.getText()}")
} }
@@ -524,18 +527,18 @@ private fun createCompileTimeConstantForEquals(result: Any?, operationReference:
return null return null
} }
private fun createCompileTimeConstantForCompareTo(result: Any?, operationReference: JetExpression): CompileTimeConstant<*>? { private fun createCompileTimeConstantForCompareTo(result: Any?, operationReference: JetExpression, context: EvaluatorContext): CompileTimeConstant<*>? {
if (result is Int) { if (result is Int) {
assert(operationReference is JetSimpleNameExpression, "This method should be called only for compareTo operations") assert(operationReference is JetSimpleNameExpression, "This method should be called only for compareTo operations")
val operationToken = (operationReference as JetSimpleNameExpression).getReferencedNameElementType() val operationToken = (operationReference as JetSimpleNameExpression).getReferencedNameElementType()
return when (operationToken) { return when (operationToken) {
JetTokens.LT -> BooleanValue.valueOf(result < 0) JetTokens.LT -> BooleanValue(result < 0, context.canBeUsedInAnnotation)
JetTokens.LTEQ -> BooleanValue.valueOf(result <= 0) JetTokens.LTEQ -> BooleanValue(result <= 0, context.canBeUsedInAnnotation)
JetTokens.GT -> BooleanValue.valueOf(result > 0) JetTokens.GT -> BooleanValue(result > 0, context.canBeUsedInAnnotation)
JetTokens.GTEQ -> BooleanValue.valueOf(result >= 0) JetTokens.GTEQ -> BooleanValue(result >= 0, context.canBeUsedInAnnotation)
JetTokens.IDENTIFIER -> { JetTokens.IDENTIFIER -> {
assert ((operationReference as JetSimpleNameExpression).getReferencedNameAsName() == OperatorConventions.COMPARE_TO, "This method should be called only for compareTo operations") assert ((operationReference as JetSimpleNameExpression).getReferencedNameAsName() == OperatorConventions.COMPARE_TO, "This method should be called only for compareTo operations")
return IntValue(result) return IntValue(result, context.canBeUsedInAnnotation)
} }
else -> throw IllegalStateException("Unknown compareTo operation token: $operationToken") else -> throw IllegalStateException("Unknown compareTo operation token: $operationToken")
} }
@@ -545,33 +548,33 @@ private fun createCompileTimeConstantForCompareTo(result: Any?, operationReferen
private fun createStringConstant(value: CompileTimeConstant<*>?): StringValue? { private fun createStringConstant(value: CompileTimeConstant<*>?): StringValue? {
return when (value) { return when (value) {
is IntegerValueTypeConstant -> StringValue(value.getValue(TypeUtils.NO_EXPECTED_TYPE).toString()) is IntegerValueTypeConstant -> StringValue(value.getValue(TypeUtils.NO_EXPECTED_TYPE).toString(), value.canBeUsedInAnnotations())
is StringValue -> value is StringValue -> value
is IntValue, is ByteValue, is ShortValue, is LongValue, is IntValue, is ByteValue, is ShortValue, is LongValue,
is CharValue, is CharValue,
is DoubleValue, is FloatValue, is DoubleValue, is FloatValue,
is BooleanValue, is BooleanValue,
is NullValue -> StringValue(value.getValue().toString()) is NullValue -> StringValue(value.getValue().toString(), value.canBeUsedInAnnotations())
else -> null else -> null
} }
} }
private fun createCompileTimeConstant(value: Any?, expectedType: JetType? = null): CompileTimeConstant<*>? { private fun createCompileTimeConstant(value: Any?, c: EvaluatorContext, expectedType: JetType? = null): CompileTimeConstant<*>? {
if (expectedType == null) { if (expectedType == null) {
when(value) { when(value) {
is Byte -> return ByteValue(value) is Byte -> return ByteValue(value, c.canBeUsedInAnnotation)
is Short -> return ShortValue(value) is Short -> return ShortValue(value, c.canBeUsedInAnnotation)
is Int -> return IntValue(value) is Int -> return IntValue(value, c.canBeUsedInAnnotation)
is Long -> return LongValue(value) is Long -> return LongValue(value, c.canBeUsedInAnnotation)
} }
} }
return when(value) { return when(value) {
is Byte, is Short, is Int, is Long -> getIntegerValue((value as Number).toLong(), expectedType) is Byte, is Short, is Int, is Long -> getIntegerValue((value as Number).toLong(), c, expectedType)
is Char -> CharValue(value) is Char -> CharValue(value, c.canBeUsedInAnnotation)
is Float -> FloatValue(value) is Float -> FloatValue(value, c.canBeUsedInAnnotation)
is Double -> DoubleValue(value) is Double -> DoubleValue(value, c.canBeUsedInAnnotation)
is Boolean -> BooleanValue.valueOf(value) is Boolean -> BooleanValue(value, c.canBeUsedInAnnotation)
is String -> StringValue(value) is String -> StringValue(value, c.canBeUsedInAnnotation)
else -> null else -> null
} }
} }
@@ -579,29 +582,29 @@ private fun createCompileTimeConstant(value: Any?, expectedType: JetType? = null
fun isIntegerType(value: Any?) = value is Byte || value is Short || value is Int || value is Long fun isIntegerType(value: Any?) = value is Byte || value is Short || value is Int || value is Long
private fun getIntegerValue(value: Long, expectedType: JetType): CompileTimeConstant<*>? { private fun getIntegerValue(value: Long, c: EvaluatorContext, expectedType: JetType): CompileTimeConstant<*>? {
fun defaultIntegerValue(value: Long) = when (value) { fun defaultIntegerValue(value: Long) = when (value) {
value.toInt().toLong() -> IntValue(value.toInt()) value.toInt().toLong() -> IntValue(value.toInt(), c.canBeUsedInAnnotation)
else -> LongValue(value) else -> LongValue(value, c.canBeUsedInAnnotation)
} }
if (CompileTimeConstantChecker.noExpectedTypeOrError(expectedType)) { if (CompileTimeConstantChecker.noExpectedTypeOrError(expectedType)) {
return IntegerValueTypeConstant(value) return IntegerValueTypeConstant(value, c.canBeUsedInAnnotation)
} }
val builtIns = KotlinBuiltIns.getInstance() val builtIns = KotlinBuiltIns.getInstance()
return when (TypeUtils.makeNotNullable(expectedType)) { return when (TypeUtils.makeNotNullable(expectedType)) {
builtIns.getLongType() -> LongValue(value) builtIns.getLongType() -> LongValue(value, c.canBeUsedInAnnotation)
builtIns.getShortType() -> when (value) { builtIns.getShortType() -> when (value) {
value.toShort().toLong() -> ShortValue(value.toShort()) value.toShort().toLong() -> ShortValue(value.toShort(), c.canBeUsedInAnnotation)
else -> defaultIntegerValue(value) else -> defaultIntegerValue(value)
} }
builtIns.getByteType() -> when (value) { builtIns.getByteType() -> when (value) {
value.toByte().toLong() -> ByteValue(value.toByte()) value.toByte().toLong() -> ByteValue(value.toByte(), c.canBeUsedInAnnotation)
else -> defaultIntegerValue(value) else -> defaultIntegerValue(value)
} }
builtIns.getCharType() -> IntValue(value.toInt()) builtIns.getCharType() -> IntValue(value.toInt(), c.canBeUsedInAnnotation)
else -> defaultIntegerValue(value) else -> defaultIntegerValue(value)
} }
} }
@@ -633,6 +636,8 @@ private fun getCompileTimeType(c: JetType): CompileTimeType<out Any>? {
} }
} }
private class EvaluatorContext(val canBeUsedInAnnotation: Boolean)
private class CompileTimeType<T> private class CompileTimeType<T>
private val BYTE = CompileTimeType<Byte>() private val BYTE = CompileTimeType<Byte>()
compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java
+1 -1
View File
@@ -227,7 +227,7 @@ public class AnnotationResolver {
if (arrayType == null) { if (arrayType == null) {
arrayType = KotlinBuiltIns.getInstance().getArrayType(varargElementType); arrayType = KotlinBuiltIns.getInstance().getArrayType(varargElementType);
} }
annotationDescriptor.setValueArgument(parameterDescriptor, new ArrayValue(constants, arrayType)); annotationDescriptor.setValueArgument(parameterDescriptor, new ArrayValue(constants, arrayType, true));
} }
else { else {
for (CompileTimeConstant<?> constant : constants) { for (CompileTimeConstant<?> constant : constants) {
compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/CompileTimeConstantChecker.java
+3 -3
View File
@@ -167,7 +167,7 @@ public class CompileTimeConstantChecker {
if (text.charAt(0) != '\\') { if (text.charAt(0) != '\\') {
// No escape // No escape
if (text.length() == 1) { if (text.length() == 1) {
return new CharValue(text.charAt(0)); return new CharValue(text.charAt(0), true);
} }
return createErrorValue(TOO_MANY_CHARACTERS_IN_CHARACTER_LITERAL.on(expression, expression)); return createErrorValue(TOO_MANY_CHARACTERS_IN_CHARACTER_LITERAL.on(expression, expression));
} }
@@ -190,13 +190,13 @@ public class CompileTimeConstantChecker {
if (escaped == null) { if (escaped == null) {
return illegalEscape(expression); return illegalEscape(expression);
} }
return new CharValue(escaped); return new CharValue(escaped, true);
case 5: case 5:
// unicode escape // unicode escape
if (escape.charAt(0) == 'u') { if (escape.charAt(0) == 'u') {
try { try {
Integer intValue = Integer.valueOf(escape.substring(1), 16); Integer intValue = Integer.valueOf(escape.substring(1), 16);
return new CharValue((char) intValue.intValue()); return new CharValue((char) intValue.intValue(), true);
} catch (NumberFormatException e) { } catch (NumberFormatException e) {
// Will be reported below // Will be reported below
} }
compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/booleanLocalVal.kt
+6
View File
@@ -0,0 +1,6 @@
annotation class Ann(vararg val i: Boolean)
fun foo() {
val bool1 = true
[Ann(<!ANNOTATION_PARAMETER_MUST_BE_CONST!>bool1<!>)] val <!UNUSED_VARIABLE!>a<!> = bool1
}
compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeClassLiteral.kt → compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/classLiteral.kt
View File
compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/compareAndEquals.kt
+16
View File
@@ -0,0 +1,16 @@
// !DIAGNOSTICS: -UNUSED_VARIABLE
annotation class Ann(vararg val i: Boolean)
fun foo() {
val a1 = 1 > 2
val a2 = 1 == 2
val a3 = a1 == a2
val a4 = a1 > a2
[Ann(
<!ANNOTATION_PARAMETER_MUST_BE_CONST!>a1<!>,
<!ANNOTATION_PARAMETER_MUST_BE_CONST!>a2<!>,
<!ANNOTATION_PARAMETER_MUST_BE_CONST!>a3<!>,
<!ANNOTATION_PARAMETER_MUST_BE_CONST!>a1 > a2<!>,
<!ANNOTATION_PARAMETER_MUST_BE_CONST!>a1 == a2<!>
)] val b = 1
}
compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeEnumConst.kt → compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/enumConst.kt
View File
compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/javaProperties.kt
+25
View File
@@ -0,0 +1,25 @@
// FILE: Test.java
public class Test {
public static int i1 = 1;
public static final int i2 = 1;
public static final int i3 = i1;
public static final int i4 = i2;
public static int i5 = i1;
public static int i6 = i2;
public final int i7 = 1;
}
// FILE: a.kt
annotation class Ann(vararg val i: Int)
Ann(
<!ANNOTATION_PARAMETER_MUST_BE_CONST!>Test.i1<!>,
Test.i2,
<!ANNOTATION_PARAMETER_MUST_BE_CONST!>Test.i3<!>,
Test.i4,
<!ANNOTATION_PARAMETER_MUST_BE_CONST!>Test.i5<!>,
<!ANNOTATION_PARAMETER_MUST_BE_CONST!>Test.i6<!>,
<!ANNOTATION_PARAMETER_MUST_BE_CONST!>Test().i7<!>
)
class A
compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/kotlinProperties.kt
+18
View File
@@ -0,0 +1,18 @@
annotation class Ann(vararg val i: Int)
Ann(
<!ANNOTATION_PARAMETER_MUST_BE_CONST!>i1<!>,
i2,
<!ANNOTATION_PARAMETER_MUST_BE_CONST!>i3<!>,
i4,
<!ANNOTATION_PARAMETER_MUST_BE_CONST!>i5<!>,
<!ANNOTATION_PARAMETER_MUST_BE_CONST!>i6<!>
)
class Test
var i1 = 1 // var
val i2 = 1 // val
val i3 = i1 // val with var in initializer
val i4 = i2 // val with val in initializer
var i5 = i1 // var with var in initializer
var i6 = i2 // var with val in initializer
compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant.kt → compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/simple.kt
View File
compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/strings.kt
+28
View File
@@ -0,0 +1,28 @@
// !DIAGNOSTICS: -UNUSED_VARIABLE
annotation class Ann(vararg val i: String)
val topLevel = "topLevel"
fun foo() {
val a1 = "a"
val a2 = "b"
val a3 = a1 + a2
val a4 = 1
val a5 = 1.0
[Ann(
<!ANNOTATION_PARAMETER_MUST_BE_CONST!>a1<!>,
<!ANNOTATION_PARAMETER_MUST_BE_CONST!>a2<!>,
<!ANNOTATION_PARAMETER_MUST_BE_CONST!>a3<!>,
"$topLevel",
<!ANNOTATION_PARAMETER_MUST_BE_CONST!>"$a1"<!>,
<!ANNOTATION_PARAMETER_MUST_BE_CONST!>"$a1 $topLevel"<!>,
<!ANNOTATION_PARAMETER_MUST_BE_CONST!>"$a4"<!>,
<!ANNOTATION_PARAMETER_MUST_BE_CONST!>"$a5"<!>,
<!ANNOTATION_PARAMETER_MUST_BE_CONST!>a1 + a2<!>,
<!ANNOTATION_PARAMETER_MUST_BE_CONST!>"a" + a2<!>,
"a" + topLevel,
<!ANNOTATION_PARAMETER_MUST_BE_CONST!>"a" + a4<!>
)] val b = 1
}
compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstantVararg.kt → compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/vararg.kt
View File
compiler/testData/diagnostics/tests/evaluate/intOverflowWithJavaProperties.kt
+14
View File
@@ -0,0 +1,14 @@
// FILE: Test.java
public class Test {
public static int i1 = Integer.MAX_VALUE;
public static final int i2 = Integer.MAX_VALUE;
public final int i3 = Integer.MAX_VALUE;
public int i4 = Integer.MAX_VALUE;
}
// FILE: A.kt
val a1: Int = Test.i1 + 1
val a2: Int = <!INTEGER_OVERFLOW!>Test.i2 + 1<!>
val a3: Int = <!INTEGER_OVERFLOW!>Test().i3 + 1<!>
val a4: Int = Test().i4 + 1
compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java
+50 -20
View File
@@ -551,26 +551,6 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
doTest("compiler/testData/diagnostics/tests/annotations/annotationModifier.kt"); doTest("compiler/testData/diagnostics/tests/annotations/annotationModifier.kt");
} }
@TestMetadata("annotationParameterMustBeClassLiteral.kt")
public void testAnnotationParameterMustBeClassLiteral() throws Exception {
doTest("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeClassLiteral.kt");
}
@TestMetadata("annotationParameterMustBeConstant.kt")
public void testAnnotationParameterMustBeConstant() throws Exception {
doTest("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant.kt");
}
@TestMetadata("annotationParameterMustBeConstantVararg.kt")
public void testAnnotationParameterMustBeConstantVararg() throws Exception {
doTest("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstantVararg.kt");
}
@TestMetadata("annotationParameterMustBeEnumConst.kt")
public void testAnnotationParameterMustBeEnumConst() throws Exception {
doTest("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeEnumConst.kt");
}
@TestMetadata("AnnotationsForClasses.kt") @TestMetadata("AnnotationsForClasses.kt")
public void testAnnotationsForClasses() throws Exception { public void testAnnotationsForClasses() throws Exception {
doTest("compiler/testData/diagnostics/tests/annotations/AnnotationsForClasses.kt"); doTest("compiler/testData/diagnostics/tests/annotations/AnnotationsForClasses.kt");
@@ -662,6 +642,51 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
doTest("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/array.kt"); doTest("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/array.kt");
} }
@TestMetadata("booleanLocalVal.kt")
public void testBooleanLocalVal() throws Exception {
doTest("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/booleanLocalVal.kt");
}
@TestMetadata("classLiteral.kt")
public void testClassLiteral() throws Exception {
doTest("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/classLiteral.kt");
}
@TestMetadata("compareAndEquals.kt")
public void testCompareAndEquals() throws Exception {
doTest("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/compareAndEquals.kt");
}
@TestMetadata("enumConst.kt")
public void testEnumConst() throws Exception {
doTest("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/enumConst.kt");
}
@TestMetadata("javaProperties.kt")
public void testJavaProperties() throws Exception {
doTest("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/javaProperties.kt");
}
@TestMetadata("kotlinProperties.kt")
public void testKotlinProperties() throws Exception {
doTest("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/kotlinProperties.kt");
}
@TestMetadata("simple.kt")
public void testSimple() throws Exception {
doTest("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/simple.kt");
}
@TestMetadata("strings.kt")
public void testStrings() throws Exception {
doTest("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/strings.kt");
}
@TestMetadata("vararg.kt")
public void testVararg() throws Exception {
doTest("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/vararg.kt");
}
} }
public static Test innerSuite() { public static Test innerSuite() {
@@ -2879,6 +2904,11 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
doTest("compiler/testData/diagnostics/tests/evaluate/intOverflow.kt"); doTest("compiler/testData/diagnostics/tests/evaluate/intOverflow.kt");
} }
@TestMetadata("intOverflowWithJavaProperties.kt")
public void testIntOverflowWithJavaProperties() throws Exception {
doTest("compiler/testData/diagnostics/tests/evaluate/intOverflowWithJavaProperties.kt");
}
@TestMetadata("integer.kt") @TestMetadata("integer.kt")
public void testInteger() throws Exception { public void testInteger() throws Exception {
doTest("compiler/testData/diagnostics/tests/evaluate/integer.kt"); doTest("compiler/testData/diagnostics/tests/evaluate/integer.kt");
core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt
+2 -2
View File
@@ -94,7 +94,7 @@ class LazyJavaAnnotationDescriptor(
private fun resolveAnnotationArgument(argument: JavaAnnotationArgument?): CompileTimeConstant<*>? { private fun resolveAnnotationArgument(argument: JavaAnnotationArgument?): CompileTimeConstant<*>? {
return when (argument) { return when (argument) {
is JavaLiteralAnnotationArgument -> JavaAnnotationArgumentResolver.resolveCompileTimeConstantValue(argument.getValue(), null) is JavaLiteralAnnotationArgument -> JavaAnnotationArgumentResolver.resolveCompileTimeConstantValue(argument.getValue(), true, null)
is JavaReferenceAnnotationArgument -> resolveFromReference(argument.resolve()) is JavaReferenceAnnotationArgument -> resolveFromReference(argument.resolve())
is JavaArrayAnnotationArgument -> resolveFromArray(argument.getName() ?: DEFAULT_ANNOTATION_MEMBER_NAME, argument.getElements()) is JavaArrayAnnotationArgument -> resolveFromArray(argument.getName() ?: DEFAULT_ANNOTATION_MEMBER_NAME, argument.getElements())
is JavaAnnotationAsAnnotationArgument -> resolveFromAnnotation(argument.getAnnotation()) is JavaAnnotationAsAnnotationArgument -> resolveFromAnnotation(argument.getAnnotation())
@@ -123,7 +123,7 @@ class LazyJavaAnnotationDescriptor(
val values = elements.map { val values = elements.map {
argument -> resolveAnnotationArgument(argument) ?: NullValue.NULL argument -> resolveAnnotationArgument(argument) ?: NullValue.NULL
} }
return ArrayValue(values, valueParameter.getType()) return ArrayValue(values, valueParameter.getType(), true)
} }
private fun resolveFromReference(element: JavaElement?): CompileTimeConstant<*>? { private fun resolveFromReference(element: JavaElement?): CompileTimeConstant<*>? {
core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/mapping/JavaToKotlinClassMap.java
+1 -1
View File
@@ -111,7 +111,7 @@ public class JavaToKotlinClassMap extends JavaToKotlinClassMapBuilder implements
ValueParameterDescriptor value = DescriptorResolverUtils.getAnnotationParameterByName( ValueParameterDescriptor value = DescriptorResolverUtils.getAnnotationParameterByName(
JavaAnnotationResolver.DEFAULT_ANNOTATION_MEMBER_NAME, annotationClass); JavaAnnotationResolver.DEFAULT_ANNOTATION_MEMBER_NAME, annotationClass);
assert value != null : "jet.deprecated must have one parameter called value"; assert value != null : "jet.deprecated must have one parameter called value";
annotation.setValueArgument(value, new StringValue("Deprecated in Java")); annotation.setValueArgument(value, new StringValue("Deprecated in Java", true));
return annotation; return annotation;
} }
core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaAnnotationArgumentResolver.java
+15 -15
View File
@@ -70,7 +70,7 @@ public final class JavaAnnotationArgumentResolver {
@NotNull PostponedTasks postponedTasks @NotNull PostponedTasks postponedTasks
) { ) {
if (argument instanceof JavaLiteralAnnotationArgument) { if (argument instanceof JavaLiteralAnnotationArgument) {
return resolveCompileTimeConstantValue(((JavaLiteralAnnotationArgument) argument).getValue(), null); return resolveCompileTimeConstantValue(((JavaLiteralAnnotationArgument) argument).getValue(), true, null);
} }
// Enum // Enum
else if (argument instanceof JavaReferenceAnnotationArgument) { else if (argument instanceof JavaReferenceAnnotationArgument) {
@@ -124,7 +124,7 @@ public final class JavaAnnotationArgumentResolver {
values.add(value == null ? NullValue.NULL : value); values.add(value == null ? NullValue.NULL : value);
} }
return new ArrayValue(values, valueParameter.getType()); return new ArrayValue(values, valueParameter.getType(), true);
} }
@Nullable @Nullable
@@ -167,44 +167,44 @@ public final class JavaAnnotationArgumentResolver {
} }
@Nullable @Nullable
public static CompileTimeConstant<?> resolveCompileTimeConstantValue(@Nullable Object value, @Nullable JetType expectedType) { public static CompileTimeConstant<?> resolveCompileTimeConstantValue(@Nullable Object value, boolean canBeUseInAnnotation, @Nullable JetType expectedType) {
if (value instanceof String) { if (value instanceof String) {
return new StringValue((String) value); return new StringValue((String) value, canBeUseInAnnotation);
} }
else if (value instanceof Byte) { else if (value instanceof Byte) {
return new ByteValue((Byte) value); return new ByteValue((Byte) value, canBeUseInAnnotation);
} }
else if (value instanceof Short) { else if (value instanceof Short) {
return new ShortValue((Short) value); return new ShortValue((Short) value, canBeUseInAnnotation);
} }
else if (value instanceof Character) { else if (value instanceof Character) {
return new CharValue((Character) value); return new CharValue((Character) value, canBeUseInAnnotation);
} }
else if (value instanceof Integer) { else if (value instanceof Integer) {
KotlinBuiltIns builtIns = KotlinBuiltIns.getInstance(); KotlinBuiltIns builtIns = KotlinBuiltIns.getInstance();
Integer integer = (Integer) value; Integer integer = (Integer) value;
if (builtIns.getShortType().equals(expectedType)) { if (builtIns.getShortType().equals(expectedType)) {
return new ShortValue(integer.shortValue()); return new ShortValue(integer.shortValue(), canBeUseInAnnotation);
} }
else if (builtIns.getByteType().equals(expectedType)) { else if (builtIns.getByteType().equals(expectedType)) {
return new ByteValue(integer.byteValue()); return new ByteValue(integer.byteValue(), canBeUseInAnnotation);
} }
else if (builtIns.getCharType().equals(expectedType)) { else if (builtIns.getCharType().equals(expectedType)) {
return new CharValue((char) integer.intValue()); return new CharValue((char) integer.intValue(), canBeUseInAnnotation);
} }
return new IntValue(integer); return new IntValue(integer, canBeUseInAnnotation);
} }
else if (value instanceof Long) { else if (value instanceof Long) {
return new LongValue((Long) value); return new LongValue((Long) value, canBeUseInAnnotation);
} }
else if (value instanceof Float) { else if (value instanceof Float) {
return new FloatValue((Float) value); return new FloatValue((Float) value, canBeUseInAnnotation);
} }
else if (value instanceof Double) { else if (value instanceof Double) {
return new DoubleValue((Double) value); return new DoubleValue((Double) value, canBeUseInAnnotation);
} }
else if (value instanceof Boolean) { else if (value instanceof Boolean) {
return BooleanValue.valueOf((Boolean) value); return new BooleanValue((Boolean) value, canBeUseInAnnotation);
} }
else if (value == null) { else if (value == null) {
return NullValue.NULL; return NullValue.NULL;
core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorDeserializer.java
+1 -1
View File
@@ -171,7 +171,7 @@ public class AnnotationDescriptorDeserializer implements AnnotationDeserializer
@Override @Override
public void visit(@Nullable Name name, @Nullable Object value) { public void visit(@Nullable Name name, @Nullable Object value) {
if (name != null) { if (name != null) {
CompileTimeConstant<?> argument = JavaAnnotationArgumentResolver.resolveCompileTimeConstantValue(value, null); CompileTimeConstant<?> argument = JavaAnnotationArgumentResolver.resolveCompileTimeConstantValue(value, true, null);
setArgumentValueByName(name, argument != null ? argument : ErrorValue.create("Unsupported annotation argument: " + name)); setArgumentValueByName(name, argument != null ? argument : ErrorValue.create("Unsupported annotation argument: " + name));
} }
} }
core/descriptors/src/org/jetbrains/jet/lang/resolve/constants/AnnotationValue.java
+1 -1
View File
@@ -25,7 +25,7 @@ import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
public class AnnotationValue extends CompileTimeConstant<AnnotationDescriptor> { public class AnnotationValue extends CompileTimeConstant<AnnotationDescriptor> {
public AnnotationValue(@NotNull AnnotationDescriptor value) { public AnnotationValue(@NotNull AnnotationDescriptor value) {
super(value); super(value, true);
} }
@NotNull @NotNull
core/descriptors/src/org/jetbrains/jet/lang/resolve/constants/ArrayValue.java
+2 -2
View File
@@ -27,8 +27,8 @@ public class ArrayValue extends CompileTimeConstant<List<CompileTimeConstant<?>>
private final JetType type; private final JetType type;
public ArrayValue(@NotNull List<CompileTimeConstant<?>> value, @NotNull JetType type) { public ArrayValue(@NotNull List<CompileTimeConstant<?>> value, @NotNull JetType type, boolean canBeUsedInAnnotations) {
super(value); super(value, canBeUsedInAnnotations);
this.type = type; this.type = type;
} }
core/descriptors/src/org/jetbrains/jet/lang/resolve/constants/BooleanValue.java
+2 -10
View File
@@ -23,16 +23,8 @@ import org.jetbrains.jet.lang.types.JetType;
public class BooleanValue extends CompileTimeConstant<Boolean> { public class BooleanValue extends CompileTimeConstant<Boolean> {
public static final BooleanValue FALSE = new BooleanValue(false); public BooleanValue(boolean value, boolean canBeUseInAnnotation) {
public static final BooleanValue TRUE = new BooleanValue(true); super(value, canBeUseInAnnotation);
private BooleanValue(boolean value) {
super(value);
}
@NotNull
public static BooleanValue valueOf(boolean value) {
return value ? TRUE : FALSE;
} }
@NotNull @NotNull
core/descriptors/src/org/jetbrains/jet/lang/resolve/constants/ByteValue.java
+3 -12
View File
@@ -16,24 +16,15 @@
package org.jetbrains.jet.lang.resolve.constants; package org.jetbrains.jet.lang.resolve.constants;
import com.google.common.base.Function;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationArgumentVisitor; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationArgumentVisitor;
import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
public class ByteValue extends CompileTimeConstant<Byte> { public class ByteValue extends CompileTimeConstant<Byte> {
public static final Function<Long, ByteValue> CREATE = new Function<Long, ByteValue>() {
@Override
public ByteValue apply(@Nullable Long input) {
assert input != null;
return new ByteValue(input.byteValue());
}
};
public ByteValue(byte value) { public ByteValue(byte value, boolean canBeUsedInAnnotations) {
super(value); super(value, canBeUsedInAnnotations);
} }
@NotNull @NotNull
core/descriptors/src/org/jetbrains/jet/lang/resolve/constants/CharValue.java
+2 -2
View File
@@ -23,8 +23,8 @@ import org.jetbrains.jet.lang.types.JetType;
public class CharValue extends CompileTimeConstant<Character> { public class CharValue extends CompileTimeConstant<Character> {
public CharValue(char value) { public CharValue(char value, boolean canBeUsedInAnnotations) {
super(value); super(value, canBeUsedInAnnotations);
} }
@NotNull @NotNull
core/descriptors/src/org/jetbrains/jet/lang/resolve/constants/CompileTimeConstant.java
+3 -6
View File
@@ -24,20 +24,17 @@ import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
public abstract class CompileTimeConstant<T> { public abstract class CompileTimeConstant<T> {
protected final T value; protected final T value;
private boolean canBeUsedInAnnotations = true; private final boolean canBeUsedInAnnotations;
protected CompileTimeConstant(T value) { protected CompileTimeConstant(T value, boolean canBeUsedInAnnotations) {
this.value = value; this.value = value;
this.canBeUsedInAnnotations = canBeUsedInAnnotations;
} }
public boolean canBeUsedInAnnotations() { public boolean canBeUsedInAnnotations() {
return canBeUsedInAnnotations; return canBeUsedInAnnotations;
} }
public void setCanBeUsedInAnnotations(boolean canBeUsedInAnnotations) {
this.canBeUsedInAnnotations = canBeUsedInAnnotations;
}
@Nullable @Nullable
public T getValue() { public T getValue() {
return value; return value;
core/descriptors/src/org/jetbrains/jet/lang/resolve/constants/DoubleValue.java
+2 -2
View File
@@ -23,8 +23,8 @@ import org.jetbrains.jet.lang.types.JetType;
public class DoubleValue extends CompileTimeConstant<Double> { public class DoubleValue extends CompileTimeConstant<Double> {
public DoubleValue(double value) { public DoubleValue(double value, boolean canBeUsedInAnnotations) {
super(value); super(value, canBeUsedInAnnotations);
} }
@NotNull @NotNull
core/descriptors/src/org/jetbrains/jet/lang/resolve/constants/EnumValue.java
+1 -1
View File
@@ -25,7 +25,7 @@ import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
public class EnumValue extends CompileTimeConstant<ClassDescriptor> { public class EnumValue extends CompileTimeConstant<ClassDescriptor> {
public EnumValue(@NotNull ClassDescriptor value) { public EnumValue(@NotNull ClassDescriptor value) {
super(value); super(value, true);
} }
@NotNull @NotNull
core/descriptors/src/org/jetbrains/jet/lang/resolve/constants/ErrorValue.java
+1 -1
View File
@@ -25,7 +25,7 @@ import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
public abstract class ErrorValue extends CompileTimeConstant<Void> { public abstract class ErrorValue extends CompileTimeConstant<Void> {
public ErrorValue() { public ErrorValue() {
super(null); super(null, true);
} }
@Override @Override
core/descriptors/src/org/jetbrains/jet/lang/resolve/constants/FloatValue.java
+2 -2
View File
@@ -23,8 +23,8 @@ import org.jetbrains.jet.lang.types.JetType;
public class FloatValue extends CompileTimeConstant<Float> { public class FloatValue extends CompileTimeConstant<Float> {
public FloatValue(float value) { public FloatValue(float value, boolean canBeUsedInAnnotations) {
super(value); super(value, canBeUsedInAnnotations);
} }
@NotNull @NotNull
core/descriptors/src/org/jetbrains/jet/lang/resolve/constants/IntValue.java
+3 -12
View File
@@ -16,24 +16,15 @@
package org.jetbrains.jet.lang.resolve.constants; package org.jetbrains.jet.lang.resolve.constants;
import com.google.common.base.Function;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationArgumentVisitor; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationArgumentVisitor;
import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
public class IntValue extends CompileTimeConstant<Integer> { public class IntValue extends CompileTimeConstant<Integer> {
public static final Function<Long, IntValue> CREATE = new Function<Long, IntValue>() {
@Override
public IntValue apply(@Nullable Long input) {
assert input != null;
return new IntValue(input.intValue());
}
};
public IntValue(int value) { public IntValue(int value, boolean canBeUsedInAnnotations) {
super(value); super(value, canBeUsedInAnnotations);
} }
@NotNull @NotNull
core/descriptors/src/org/jetbrains/jet/lang/resolve/constants/IntegerValueTypeConstant.java
+2 -2
View File
@@ -30,8 +30,8 @@ public class IntegerValueTypeConstant extends CompileTimeConstant<Number> {
private final IntegerValueTypeConstructor typeConstructor; private final IntegerValueTypeConstructor typeConstructor;
public IntegerValueTypeConstant(@NotNull Number value) { public IntegerValueTypeConstant(@NotNull Number value, boolean canBeUsedInAnnotations) {
super(value); super(value, canBeUsedInAnnotations);
this.typeConstructor = new IntegerValueTypeConstructor(value.longValue()); this.typeConstructor = new IntegerValueTypeConstructor(value.longValue());
} }
core/descriptors/src/org/jetbrains/jet/lang/resolve/constants/JavaClassValue.java
+2 -2
View File
@@ -23,8 +23,8 @@ import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
public class JavaClassValue extends CompileTimeConstant<JetType> { public class JavaClassValue extends CompileTimeConstant<JetType> {
public JavaClassValue(JetType value) { public JavaClassValue(@NotNull JetType value) {
super(value); super(value, true);
} }
@NotNull @NotNull
core/descriptors/src/org/jetbrains/jet/lang/resolve/constants/LongValue.java
+3 -11
View File
@@ -16,23 +16,15 @@
package org.jetbrains.jet.lang.resolve.constants; package org.jetbrains.jet.lang.resolve.constants;
import com.google.common.base.Function;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationArgumentVisitor; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationArgumentVisitor;
import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
public class LongValue extends CompileTimeConstant<Long> { public class LongValue extends CompileTimeConstant<Long> {
public static final Function<Long, LongValue> CREATE = new Function<Long, LongValue>() {
@Override
public LongValue apply(@Nullable Long input) {
return new LongValue(input);
}
};
public LongValue(long value) { public LongValue(long value, boolean canBeUsedInAnnotations) {
super(value); super(value, canBeUsedInAnnotations);
} }
@NotNull @NotNull
core/descriptors/src/org/jetbrains/jet/lang/resolve/constants/NullValue.java
+1 -1
View File
@@ -26,7 +26,7 @@ public class NullValue extends CompileTimeConstant<Void> {
public static final NullValue NULL = new NullValue(); public static final NullValue NULL = new NullValue();
private NullValue() { private NullValue() {
super(null); super(null, false);
} }
@NotNull @NotNull
core/descriptors/src/org/jetbrains/jet/lang/resolve/constants/ShortValue.java
+3 -12
View File
@@ -16,24 +16,15 @@
package org.jetbrains.jet.lang.resolve.constants; package org.jetbrains.jet.lang.resolve.constants;
import com.google.common.base.Function;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationArgumentVisitor; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationArgumentVisitor;
import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
public class ShortValue extends CompileTimeConstant<Short> { public class ShortValue extends CompileTimeConstant<Short> {
public static final Function<Long, ShortValue> CREATE = new Function<Long, ShortValue>() {
@Override
public ShortValue apply(@Nullable Long input) {
assert input != null;
return new ShortValue(input.shortValue());
}
};
public ShortValue(short value) { public ShortValue(short value, boolean canBeUsedInAnnotations) {
super(value); super(value, canBeUsedInAnnotations);
} }
@NotNull @NotNull
core/descriptors/src/org/jetbrains/jet/lang/resolve/constants/StringValue.java
+2 -2
View File
@@ -24,8 +24,8 @@ import org.jetbrains.jet.lang.types.JetType;
public class StringValue extends CompileTimeConstant<String> { public class StringValue extends CompileTimeConstant<String> {
public StringValue(String value) { public StringValue(String value, boolean canBeUsedInAnnotations) {
super(value); super(value, canBeUsedInAnnotations);
} }
@NotNull @NotNull