From 3d1f2c25e2cb414a6591fece225364ca45cfac2b Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Wed, 5 Feb 2014 09:30:35 +0100 Subject: [PATCH] resolveCompileTimeConstantValue() rewritten to Kotlin --- .../resolver/TraceBasedJavaResolverCache.java | 9 ++-- .../LazyJavaAnnotationDescriptor.kt | 3 +- .../resolver/CompileTimeConstantResolver.kt | 45 +++++++++++++++++ .../JavaAnnotationArgumentResolver.java | 50 +------------------ .../AnnotationDescriptorDeserializer.java | 4 +- 5 files changed, 55 insertions(+), 56 deletions(-) create mode 100644 core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/CompileTimeConstantResolver.kt diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TraceBasedJavaResolverCache.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TraceBasedJavaResolverCache.java index e1171ffa78c..2b073e48ae4 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TraceBasedJavaResolverCache.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TraceBasedJavaResolverCache.java @@ -25,9 +25,9 @@ import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.ConstructorDescriptor; import org.jetbrains.jet.lang.descriptors.PropertyDescriptor; import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor; -import org.jetbrains.jet.lang.resolve.CompileTimeConstantUtils; import org.jetbrains.jet.lang.resolve.BindingContextUtils; import org.jetbrains.jet.lang.resolve.BindingTrace; +import org.jetbrains.jet.lang.resolve.CompileTimeConstantUtils; import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant; import org.jetbrains.jet.lang.resolve.java.structure.JavaClass; import org.jetbrains.jet.lang.resolve.java.structure.JavaElement; @@ -94,9 +94,10 @@ public class TraceBasedJavaResolverCache implements JavaResolverCache { PsiExpression initializer = psiField.getInitializer(); Object evaluatedExpression = JavaConstantExpressionEvaluator.computeConstantExpression(initializer, false); if (evaluatedExpression != null) { - CompileTimeConstant constant = JavaAnnotationArgumentResolver. - resolveCompileTimeConstantValue(evaluatedExpression, CompileTimeConstantUtils - .isPropertyCompileTimeConstant(descriptor), descriptor.getType()); + CompileTimeConstant constant = + ResolverPackage.resolveCompileTimeConstantValue(evaluatedExpression, + CompileTimeConstantUtils.isPropertyCompileTimeConstant(descriptor), + descriptor.getType()); if (constant != null) { trace.record(COMPILE_TIME_INITIALIZER, descriptor, constant); } diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt index f63d6b4886f..81597f8ebc5 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt @@ -34,6 +34,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver import org.jetbrains.jet.renderer.DescriptorRenderer import org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap import org.jetbrains.jet.lang.types.TypeUtils +import org.jetbrains.jet.lang.resolve.java.resolver.resolveCompileTimeConstantValue private object DEPRECATED_IN_JAVA : JavaLiteralAnnotationArgument { override fun getName(): Name? = null @@ -94,7 +95,7 @@ class LazyJavaAnnotationDescriptor( private fun resolveAnnotationArgument(argument: JavaAnnotationArgument?): CompileTimeConstant<*>? { return when (argument) { - is JavaLiteralAnnotationArgument -> JavaAnnotationArgumentResolver.resolveCompileTimeConstantValue(argument.getValue(), true, null) + is JavaLiteralAnnotationArgument -> resolveCompileTimeConstantValue(argument.getValue(), true, null) is JavaReferenceAnnotationArgument -> resolveFromReference(argument.resolve()) is JavaArrayAnnotationArgument -> resolveFromArray(argument.getName() ?: DEFAULT_ANNOTATION_MEMBER_NAME, argument.getElements()) is JavaAnnotationAsAnnotationArgument -> resolveFromAnnotation(argument.getAnnotation()) diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/CompileTimeConstantResolver.kt b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/CompileTimeConstantResolver.kt new file mode 100644 index 00000000000..4b10bc4b230 --- /dev/null +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/CompileTimeConstantResolver.kt @@ -0,0 +1,45 @@ +/* + * Copyright 2010-2014 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.lang.resolve.java.resolver + +import org.jetbrains.jet.lang.resolve.constants.* +import org.jetbrains.jet.lang.types.JetType +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns + +fun resolveCompileTimeConstantValue(value: Any?, canBeUsedInAnnotations: Boolean, expectedType: JetType?): CompileTimeConstant<*>? { + return when (value) { + is String -> StringValue(value, canBeUsedInAnnotations) + is Byte -> ByteValue(value, canBeUsedInAnnotations, false) + is Short -> ShortValue(value, canBeUsedInAnnotations, false) + is Char -> CharValue(value, canBeUsedInAnnotations, false) + is Int -> { + val builtIns = KotlinBuiltIns.getInstance() + when (expectedType) { + builtIns.getShortType() -> ShortValue(value.toShort(), canBeUsedInAnnotations, false) + builtIns.getByteType() -> ByteValue(value.toByte(), canBeUsedInAnnotations, false) + builtIns.getCharType() -> CharValue(value.toChar(), canBeUsedInAnnotations, false) + else -> IntValue(value, canBeUsedInAnnotations, false) + } + } + is Long -> LongValue(value, canBeUsedInAnnotations, false) + is Float -> FloatValue(value, canBeUsedInAnnotations) + is Double -> DoubleValue(value, canBeUsedInAnnotations) + is Boolean -> BooleanValue(value, canBeUsedInAnnotations) + null -> NullValue.NULL + else -> null + } +} \ No newline at end of file diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaAnnotationArgumentResolver.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaAnnotationArgumentResolver.java index f27c6178ece..d6f93836768 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaAnnotationArgumentResolver.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaAnnotationArgumentResolver.java @@ -23,7 +23,6 @@ import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor; import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.resolve.constants.*; -import org.jetbrains.jet.lang.resolve.constants.StringValue; import org.jetbrains.jet.lang.resolve.java.structure.*; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; @@ -31,7 +30,6 @@ import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.JetTypeImpl; import org.jetbrains.jet.lang.types.TypeProjectionImpl; import org.jetbrains.jet.lang.types.TypeUtils; -import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import javax.inject.Inject; import java.util.ArrayList; @@ -70,7 +68,7 @@ public final class JavaAnnotationArgumentResolver { @NotNull PostponedTasks postponedTasks ) { if (argument instanceof JavaLiteralAnnotationArgument) { - return resolveCompileTimeConstantValue(((JavaLiteralAnnotationArgument) argument).getValue(), true, null); + return ResolverPackage.resolveCompileTimeConstantValue(((JavaLiteralAnnotationArgument) argument).getValue(), true, null); } // Enum else if (argument instanceof JavaReferenceAnnotationArgument) { @@ -165,50 +163,4 @@ public final class JavaAnnotationArgumentResolver { return new JavaClassValue(javaClassType); } - - @Nullable - public static CompileTimeConstant resolveCompileTimeConstantValue(@Nullable Object value, boolean canBeUseInAnnotation, @Nullable JetType expectedType) { - if (value instanceof String) { - return new StringValue((String) value, canBeUseInAnnotation); - } - else if (value instanceof Byte) { - return new ByteValue((Byte) value, canBeUseInAnnotation, false); - } - else if (value instanceof Short) { - return new ShortValue((Short) value, canBeUseInAnnotation, false); - } - else if (value instanceof Character) { - return new CharValue((Character) value, canBeUseInAnnotation, false); - } - else if (value instanceof Integer) { - KotlinBuiltIns builtIns = KotlinBuiltIns.getInstance(); - Integer integer = (Integer) value; - if (builtIns.getShortType().equals(expectedType)) { - return new ShortValue(integer.shortValue(), canBeUseInAnnotation, false); - } - else if (builtIns.getByteType().equals(expectedType)) { - return new ByteValue(integer.byteValue(), canBeUseInAnnotation, false); - } - else if (builtIns.getCharType().equals(expectedType)) { - return new CharValue((char) integer.intValue(), canBeUseInAnnotation, false); - } - return new IntValue(integer, canBeUseInAnnotation, false); - } - else if (value instanceof Long) { - return new LongValue((Long) value, canBeUseInAnnotation, false); - } - else if (value instanceof Float) { - return new FloatValue((Float) value, canBeUseInAnnotation); - } - else if (value instanceof Double) { - return new DoubleValue((Double) value, canBeUseInAnnotation); - } - else if (value instanceof Boolean) { - return new BooleanValue((Boolean) value, canBeUseInAnnotation); - } - else if (value == null) { - return NullValue.NULL; - } - return null; - } } diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorDeserializer.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorDeserializer.java index 59baabb6b0b..3839577e4cb 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorDeserializer.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorDeserializer.java @@ -38,8 +38,8 @@ import org.jetbrains.jet.lang.resolve.java.JvmClassName; import org.jetbrains.jet.lang.resolve.java.PackageClassUtils; import org.jetbrains.jet.lang.resolve.java.resolver.DescriptorResolverUtils; import org.jetbrains.jet.lang.resolve.java.resolver.ErrorReporter; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationArgumentResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.ResolverPackage; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.types.ErrorUtils; @@ -171,7 +171,7 @@ public class AnnotationDescriptorDeserializer implements AnnotationDeserializer @Override public void visit(@Nullable Name name, @Nullable Object value) { if (name != null) { - CompileTimeConstant argument = JavaAnnotationArgumentResolver.resolveCompileTimeConstantValue(value, true, null); + CompileTimeConstant argument = ResolverPackage.resolveCompileTimeConstantValue(value, true, null); setArgumentValueByName(name, argument != null ? argument : ErrorValue.create("Unsupported annotation argument: " + name)); } }