Split CompileTimeConstant into two entities

1. ConstantValue
	* just holds some value and its type
	* implementations for concrete constants
2. CompileTimeConstant
	* is only produced by ConstantExpressionEvaluator
	* has additional flags (canBeUsedInAnnotation etc)
	* has two implementations TypedCompileTimeConstant containing a constant value
		and IntegerValueConstant which does not have exact type
	* can be converted to ConstantValue

Adjustt usages to use ConstantValue if flags are not needed
Add tests for some uncovered cases

compiler/tests/org/jetbrains/kotlin/jvm/compiler/ExpectedLoadErrorsUtil.java

@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.load.java.JavaBindingContext;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
 import org.jetbrains.kotlin.resolve.BindingContext;
-import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
+import org.jetbrains.kotlin.resolve.constants.ConstantValue;
 import org.jetbrains.kotlin.resolve.scopes.JetScope;
 
 import java.util.*;
@@ -84,7 +84,7 @@ public class ExpectedLoadErrorsUtil {
                 if (annotation == null) return null;
 
                 // we expect exactly one annotation argument
-                CompileTimeConstant<?> argument = annotation.getAllValueArguments().values().iterator().next();
+                ConstantValue<?> argument = annotation.getAllValueArguments().values().iterator().next();
 
                 String error = (String) argument.getValue();
                 //noinspection ConstantConditions

compiler/tests/org/jetbrains/kotlin/resolve/annotation/AnnotationDescriptorResolveTest.java

@@ -21,7 +21,7 @@ import java.io.IOException;
 public class AnnotationDescriptorResolveTest extends AbstractAnnotationDescriptorResolveTest {
     public void testIntAnnotation() throws IOException {
         String content = getContent("AnnInt(1)");
-        String expectedAnnotation = "AnnInt(a = IntegerValueType(1))";
+        String expectedAnnotation = "AnnInt(a = 1)";
         doTest(content, expectedAnnotation);
     }
 
@@ -51,13 +51,13 @@ public class AnnotationDescriptorResolveTest extends AbstractAnnotationDescripto
 
     public void testIntArrayAnnotation() throws IOException {
         String content = getContent("AnnIntArray(intArray(1, 2))");
-        String expectedAnnotation = "AnnIntArray(a = {IntegerValueType(1), IntegerValueType(2)})";
+        String expectedAnnotation = "AnnIntArray(a = {1, 2})";
         doTest(content, expectedAnnotation);
     }
 
     public void testIntArrayVarargAnnotation() throws IOException {
         String content = getContent("AnnIntVararg(1, 2)");
-        String expectedAnnotation = "AnnIntVararg(a = {IntegerValueType(1), IntegerValueType(2)})";
+        String expectedAnnotation = "AnnIntVararg(a = {1, 2})";
         doTest(content, expectedAnnotation);
     }
 
@@ -81,7 +81,7 @@ public class AnnotationDescriptorResolveTest extends AbstractAnnotationDescripto
 
     public void testAnnotationAnnotation() throws Exception {
         String content = getContent("AnnAnn(AnnInt(1))");
-        String expectedAnnotation = "AnnAnn(a = AnnInt(a = IntegerValueType(1)))";
+        String expectedAnnotation = "AnnAnn(a = AnnInt(a = 1))";
         doTest(content, expectedAnnotation);
     }
 

compiler/tests/org/jetbrains/kotlin/resolve/constants/evaluate/AbstractEvaluateExpressionTest.kt

@@ -18,9 +18,12 @@ package org.jetbrains.kotlin.resolve.constants.evaluate
 
 import com.intellij.openapi.util.io.FileUtil
 import org.jetbrains.kotlin.descriptors.VariableDescriptor
+import org.jetbrains.kotlin.psi.JetProperty
 import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.DelegatingBindingTrace
+import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.resolve.annotation.AbstractAnnotationDescriptorResolveTest
-import org.jetbrains.kotlin.resolve.constants.IntegerValueConstant
+import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant
 import org.jetbrains.kotlin.resolve.constants.StringValue
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
 import org.jetbrains.kotlin.test.JetTestUtils
@@ -47,12 +50,7 @@ public abstract class AbstractEvaluateExpressionTest : AbstractAnnotationDescrip
     fun doIsPureTest(path: String) {
         doTest(path) {
             property, context ->
-            val compileTimeConstant = property.getCompileTimeInitializer()
-            if (compileTimeConstant is IntegerValueConstant) {
-                compileTimeConstant.isPure().toString()
-            } else {
-                "null"
-            }
+            evaluateInitializer(context, property)?.isPure.toString()
         }
     }
 
@@ -60,15 +58,20 @@ public abstract class AbstractEvaluateExpressionTest : AbstractAnnotationDescrip
     fun doUsesVariableAsConstantTest(path: String) {
         doTest(path) {
             property, context ->
-            val compileTimeConstant = property.getCompileTimeInitializer()
-            if (compileTimeConstant == null) {
-                "null"
-            } else {
-                compileTimeConstant.usesVariableAsConstant().toString()
-            }
+            evaluateInitializer(context, property)?.usesVariableAsConstant.toString()
         }
     }
 
+    private fun evaluateInitializer(context: BindingContext, property: VariableDescriptor): CompileTimeConstant<*>? {
+        val propertyDeclaration = DescriptorToSourceUtils.descriptorToDeclaration(property) as JetProperty
+        val compileTimeConstant = ConstantExpressionEvaluator.evaluate(
+                propertyDeclaration.getInitializer()!!,
+                DelegatingBindingTrace(context, "trace for evaluating compile time constant"),
+                property.getType()
+        )
+        return compileTimeConstant
+    }
+
     private fun doTest(path: String, getValueToTest: (VariableDescriptor, BindingContext) -> String) {
         val myFile = File(path)
         val fileText = FileUtil.loadFile(myFile, true)