KT-10375, KT-19523: Fix J2K hex literal number conversion issues.

#KT-10375, #KT-19523 fixed

j2k/src/org/jetbrains/kotlin/j2k/ExpressionConverter.kt

@@ -38,6 +38,7 @@ import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 import org.jetbrains.kotlin.psi.psiUtil.isExtensionDeclaration
 import org.jetbrains.kotlin.resolve.jvm.JvmPrimitiveType
 import java.lang.AssertionError
+import java.math.BigInteger
 
 interface ExpressionConverter {
     fun convertExpression(expression: PsiExpression, codeConverter: CodeConverter): Expression
@@ -273,7 +274,7 @@ class DefaultExpressionConverter : JavaElementVisitor(), ExpressionConverter {
         var text = expression.text!!
         val type = expression.type
 
-        if(expression.isNullLiteral()) {
+        if (expression.isNullLiteral()) {
             result = LiteralExpression.NullLiteral
             return
         }
@@ -300,18 +301,24 @@ class DefaultExpressionConverter : JavaElementVisitor(), ExpressionConverter {
             }
 
             fun isHexLiteral(text: String) = text.startsWith("0x") || text.startsWith("0X")
-            fun isLongField(element: PsiElement): Boolean {
-                val fieldType = (element as? PsiVariable)?.type ?: return false
-                return when (fieldType) {
-                    is PsiPrimitiveType -> fieldType.canonicalText == "long"
-                    else -> PsiPrimitiveType.getUnboxedType(fieldType)?.canonicalText == "long"
+
+            if ((typeStr == "long" || typeStr == "int") && isHexLiteral(text)) {
+                val v = BigInteger(text.substring(2).replace("L", ""), 16)
+                if (text.contains("L")) {
+                    if (v.bitLength() > 63) {
+                        text = "-0x${v.toLong().toString(16).substring(1)}L"
+                    }
+                }
+                else {
+                    if (v.bitLength() > 31) {
+                        text = "-0x${v.toInt().toString(16).substring(1)}"
+                    }
                 }
             }
-
-            if (typeStr == "int") {
-                val toIntIsNeeded = value != null && value.toString().toInt() < 0 && !isLongField(expression.parent)
-                text = if (value != null && !isHexLiteral(text)) value.toString() else text + (if (toIntIsNeeded) ".toInt()" else "")
+            else if (typeStr == "int" && value != null) {
+                text = value.toString()
             }
+
             if (typeStr == "char") {
                 text = text.replace("\\\\([0-3]?[0-7]{1,2})".toRegex()) {
                     String.format("\\u%04x", Integer.parseInt(it.groupValues[1], 8))
@@ -323,7 +330,8 @@ class DefaultExpressionConverter : JavaElementVisitor(), ExpressionConverter {
                     val leadingBackslashes = it.groupValues[1]
                     if (leadingBackslashes.length % 2 == 0) {
                         String.format("%s\\u%04x", leadingBackslashes, Integer.parseInt(it.groupValues[2], 8))
-                    } else {
+                    }
+                    else {
                         it.value
                     }
                 }

j2k/testData/fileOrElement/literalExpression/hex.java

@@ -9,5 +9,7 @@ class Test {
     long l1 = 0xffffffff;
     Long l2 = 0xffffffffl;
     long l3 = 0xffffffffffL;
+    long l4 = 0xFFFFFFFFFFFFFFFFL;
+    long l5 = 0xF000000000000000L;
   }
 }

j2k/testData/fileOrElement/literalExpression/hex.kt

@@ -2,11 +2,13 @@ internal class Test {
     fun test() {
         val i1 = 0x21
         val i2 = 0x33
-        val i3 = 0xffffffff.toInt()
+        val i3 = -0x1
         val i4 = 0XCCCC
         val i5 = 0x6fffffff
-        val l1: Long = 0xffffffff
+        val l1: Long = -0x1
         val l2 = 0xffffffffL
         val l3 = 0xffffffffffL
+        val l4 = -0x1L
+        val l5 = -0x1000000000000000L
     }
 }

j2k/testData/fileOrElement/switch/KT-13552.kt

@@ -73,10 +73,10 @@ object SwitchDemo {
         val status = ""
         when (status) {
             "init", "dial", "transmit" -> return 0x111111
-            "ok" -> return 0xFF006600.toInt()
-            "cancel" -> return 0xFF666666.toInt()
-            "fail", "busy", "error" -> return 0xFF660000.toInt()
-            else -> return 0xFF660000.toInt()
+            "ok" -> return -0xff9a00
+            "cancel" -> return -0x99999a
+            "fail", "busy", "error" -> return -0x9a0000
+            else -> return -0x9a0000
         }
     }
 }