Move methods

compiler/frontend/src/org/jetbrains/jet/lang/evaluate/ConstantExpressionEvaluator.kt

@@ -31,10 +31,9 @@ import org.jetbrains.jet.lexer.JetTokens
 import org.jetbrains.jet.lang.resolve.BindingContext.COMPILE_TIME_INITIALIZER
 import org.jetbrains.jet.lang.resolve.calls.tasks.ExplicitReceiverKind
 import org.jetbrains.jet.lang.types.TypeUtils
-import java.lang.Short as JShort
-import java.lang.Byte as JByte
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedValueArgument
 import org.jetbrains.jet.JetNodeTypes
+import java.lang.Long.parseLong as javaParseLong
 
 [suppress("PARAMETER_NAME_CHANGED_ON_OVERRIDE")]
 public class ConstantExpressionEvaluator private (val trace: BindingTrace) : JetVisitor<CompileTimeConstant<*>, JetType>() {
@@ -75,9 +74,9 @@ public class ConstantExpressionEvaluator private (val trace: BindingTrace) : Jet
         val text = expression.getText()
         if (text == null) return null
         val result: Any? = when (expression.getNode().getElementType()) {
-            JetNodeTypes.INTEGER_CONSTANT -> CompileTimeConstantResolver.parseLong(text)
+            JetNodeTypes.INTEGER_CONSTANT -> parseLong(text)
-            JetNodeTypes.FLOAT_CONSTANT -> CompileTimeConstantResolver.parseDouble(text)
+            JetNodeTypes.FLOAT_CONSTANT -> parseDouble(text)
-            JetNodeTypes.BOOLEAN_CONSTANT -> CompileTimeConstantResolver.parseBoolean(text)
+            JetNodeTypes.BOOLEAN_CONSTANT -> parseBoolean(text)
             JetNodeTypes.CHARACTER_CONSTANT -> CompileTimeConstantResolver.parseChar(expression)
             JetNodeTypes.NULL -> null
             else -> throw IllegalArgumentException("Unsupported constant: " + expression)
@@ -324,6 +323,40 @@ public class ConstantExpressionEvaluator private (val trace: BindingTrace) : Jet
     }
 }
 
+public fun parseLong(text: String): Long? {
+    try {
+        return when {
+            text.startsWith("0x") || text.startsWith("0X") -> javaParseLong(text.substring(2), 16)
+            text.startsWith("0b") || text.startsWith("0B") -> javaParseLong(text.substring(2), 2)
+            else -> javaParseLong(text)
+        }
+    }
+    catch (e: NumberFormatException) {
+        return null
+    }
+}
+
+private fun parseDouble(text: String): Double? {
+    try {
+        return java.lang.Double.parseDouble(text)
+    }
+    catch (e: NumberFormatException) {
+        return null
+    }
+}
+
+private fun parseBoolean(text: String): Boolean {
+    if ("true".equals(text)) {
+        return true
+    }
+    else if ("false".equals(text)) {
+        return false
+    }
+
+    throw IllegalStateException("Must not happen. A boolean literal has text: " + text)
+}
+
+
 private fun createCompileTimeConstantForEquals(result: Any?, operationToken: IElementType): CompileTimeConstant<*>? {
     if (result is Boolean) {
         return when (operationToken) {

compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/CompileTimeConstantResolver.java

@@ -235,49 +235,6 @@ public class CompileTimeConstantResolver {
         }
     }
 
-    @Nullable
-    public static Long parseLong(String text) {
-        try {
-            long value;
-            if (text.startsWith("0x") || text.startsWith("0X")) {
-                String hexString = text.substring(2);
-                value = Long.parseLong(hexString, 16);
-            }
-            else if (text.startsWith("0b") || text.startsWith("0B")) {
-                String binString = text.substring(2);
-                value = Long.parseLong(binString, 2);
-            }
-            else {
-                value = Long.parseLong(text);
-            }
-            return value;
-        }
-        catch (NumberFormatException e) {
-            return null;
-        }
-    }
-
-    @Nullable
-    public static Double parseDouble(String text) {
-        try {
-            return Double.parseDouble(text);
-        }
-        catch (NumberFormatException e) {
-            return null;
-        }
-    }
-
-    @NotNull
-    public static Object parseBoolean(@NotNull String text) {
-        if ("true".equals(text)) {
-            return true;
-        }
-        else if ("false".equals(text)) {
-            return false;
-        }
-        throw new IllegalStateException("Must not happen. A boolean literal has text: " + text);
-    }
-
     @Nullable
     public static Character parseChar(@NotNull JetConstantExpression expression) {
         CompileTimeConstant<?> compileTimeConstant = parseCharValue(expression);

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java

@@ -29,6 +29,7 @@ import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.AnonymousFunctionDescriptor;
 import org.jetbrains.jet.lang.diagnostics.Errors;
 import org.jetbrains.jet.lang.evaluate.ConstantExpressionEvaluator;
+import org.jetbrains.jet.lang.evaluate.EvaluatePackage;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.calls.CallExpressionResolver;
@@ -47,7 +48,10 @@ import org.jetbrains.jet.lang.resolve.calls.tasks.ExplicitReceiverKind;
 import org.jetbrains.jet.lang.resolve.calls.tasks.ResolutionCandidate;
 import org.jetbrains.jet.lang.resolve.calls.tasks.TracingStrategy;
 import org.jetbrains.jet.lang.resolve.calls.util.CallMaker;
-import org.jetbrains.jet.lang.resolve.constants.*;
+import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
+import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstantResolver;
+import org.jetbrains.jet.lang.resolve.constants.IntegerValueTypeConstructor;
+import org.jetbrains.jet.lang.resolve.constants.NumberValueTypeConstructor;
 import org.jetbrains.jet.lang.resolve.name.LabelName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
@@ -137,9 +141,9 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
 
         if (noExpectedType(context.expectedType) && context.contextDependency == DEPENDENT) {
             if (elementType == JetNodeTypes.INTEGER_CONSTANT) {
-                Long longValue = CompileTimeConstantResolver.parseLong(text);
+                Long longValue = EvaluatePackage.parseLong(text);
                 if (longValue != null) {
-                    return createNumberValueTypeInfo(new IntegerValueTypeConstructor((long) longValue), longValue, context.dataFlowInfo);
+                    return createNumberValueTypeInfo(new IntegerValueTypeConstructor(longValue), longValue, context.dataFlowInfo);
                 }
             }
         }