resolveCompileTimeConstantValue() rewritten to Kotlin

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.
+                CompileTimeConstant<?> constant =
-                        resolveCompileTimeConstantValue(evaluatedExpression, CompileTimeConstantUtils
+                        ResolverPackage.resolveCompileTimeConstantValue(evaluatedExpression,
-                                .isPropertyCompileTimeConstant(descriptor), descriptor.getType());
+                                                                        CompileTimeConstantUtils.isPropertyCompileTimeConstant(descriptor),
+                                                                        descriptor.getType());
                 if (constant != null) {
                     trace.record(COMPILE_TIME_INITIALIZER, descriptor, constant);
                 }

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())

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
+    }
+}

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;
-    }
 }

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));
                 }
             }