Fix compile error on unsigned 64-bit enum int constants

Related to kaitai-io/kaitai_struct#1288
(I consider the change in this commit to be a prerequisite for its full
implementation; without it, enum support would be unnecessarily limited
to *signed* 64-bit integers.)

Fixes the compile error of the EnumLongRangeU test format after
kaitai-io/kaitai_struct_tests@b88e1f5

This commit ensures that the compiler accepts integer constants between
`2**63` (`0x8000_0000_0000_0000` or 9223372036854775808) and `2**64 - 1`
(`0xffff_ffff_ffff_ffff` or 18446744073709551615) in enum definitions.
This allows defining enums with integer values from the entire range of
the unsigned 64-bit integer type in some target languages (where it is
not broken for another reason).

Previously, attempting to use an integer constant outside the range of
the signed 64-bit integer type (i.e. over `2**63 - 1`) in the enum
definition resulted in the following compile error:

```
formats/enum_long_range_u.ksy: /enums/constants:
        error: expected int, got 18446744073709551615 (class java.math.BigInteger)
```

Author: generalmimon

shared/src/main/scala/io/kaitai/struct/format/EnumSpec.scala

@@ -5,7 +5,7 @@ import io.kaitai.struct.problems.KSYParseError
 import scala.collection.immutable.SortedMap
 import scala.collection.mutable
 
-case class EnumSpec(path: List[String], map: SortedMap[Long, EnumValueSpec]) extends YAMLPath {
+case class EnumSpec(path: List[String], map: SortedMap[BigInt, EnumValueSpec]) extends YAMLPath {
   var name = List[String]()
 
   /**
@@ -28,20 +28,20 @@ case class EnumSpec(path: List[String], map: SortedMap[Long, EnumValueSpec]) ext
 object EnumSpec {
   def fromYaml(src: Any, path: List[String]): EnumSpec = {
     val srcMap = ParseUtils.asMap(src, path)
-    val memberNameMap = mutable.Map[String, Long]()
+    val memberNameMap = mutable.Map[String, BigInt]()
     EnumSpec(path, SortedMap.from(
       srcMap.map { case (id, desc) =>
-        val idLong = ParseUtils.asLong(id, path)
-        val value = EnumValueSpec.fromYaml(desc, path ++ List(idLong.toString))
+        val idBigInt = ParseUtils.asBigInt(id, path)
+        val value = EnumValueSpec.fromYaml(desc, path ++ List(idBigInt.toString))
 
-        memberNameMap.get(value.name).foreach { (prevIdLong) =>
+        memberNameMap.get(value.name).foreach { (prevIdBigInt) =>
           throw KSYParseError.withText(
-            s"duplicate enum member ID: '${value.name}', previously defined at /${(path ++ List(prevIdLong.toString)).mkString("/")}",
-            path ++ List(idLong.toString)
+            s"duplicate enum member ID: '${value.name}', previously defined at /${(path ++ List(prevIdBigInt.toString)).mkString("/")}",
+            path ++ List(idBigInt.toString)
           )
         }
-        memberNameMap.put(value.name, idLong)
-        idLong -> value
+        memberNameMap.put(value.name, idBigInt)
+        idBigInt -> value
       }
     ))
   }

shared/src/main/scala/io/kaitai/struct/format/ParseUtils.scala

@@ -177,19 +177,35 @@ object ParseUtils {
     }
   }
 
-  def asLong(src: Any, path: List[String]): Long = {
+  def asBigInt(src: Any, path: List[String]): BigInt = {
     src match {
+      case n: Int =>
+        n
       case n: Long =>
         n
-      case n: Int =>
+      // NB: at the time of writing, JavaKSYParser.yamlJavaToScala() only
+      // converts Java types to Scala types in mapping values, not mapping keys.
+      // Since this method is called on the keys of enum entries, we might get
+      // `java.math.BigInteger` (not `BigInt`) if the YAML tree comes from
+      // SnakeYAML.
+      case n: java.math.BigInteger =>
+        n
+      // At the time of writing, we can actually never get `BigInt` here - it's
+      // only included for potential "forward compatibility" in case we tweak
+      // our YAML parsing.
+      case n: BigInt =>
         n
       case str: String =>
         // Generally should not happen, but when the data comes from JavaScript,
-        // all object keys are forced to be strings.
+        // all object keys are forced to be strings. Nevertheless, since the
+        // YAML parser parses the integer value first, we can only expect
+        // strings returned by the `Number.prototype.toString()` method, which
+        // formats numbers into canonical decimal format for all practically
+        // large values.
         try {
-          Utils.strToLong(str)
+          BigInt(str)
         } catch {
-          case ex: MatchError =>
+          case _: NumberFormatException =>
             throw KSYParseError.withText(s"unable to parse `$str` as int", path)
         }
       case unknown =>

shared/src/main/scala/io/kaitai/struct/languages/CSharpCompiler.scala

@@ -547,7 +547,7 @@ class CSharpCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
 
   def flagForInstName(ksName: Identifier) = s"f_${idToStr(ksName)}"
 
-  override def enumDeclaration(curClass: String, enumName: String, enumColl: Seq[(Long, String)]): Unit = {
+  override def enumDeclaration(curClass: String, enumName: String, enumColl: Seq[(BigInt, String)]): Unit = {
     val enumClass = type2class(enumName)
 
     out.puts

shared/src/main/scala/io/kaitai/struct/languages/CppCompiler.scala

@@ -885,7 +885,7 @@ class CppCompiler(
     handleAssignmentSimple(instName, valExprConverted)
   }
 
-  override def enumDeclaration(curClass: List[String], enumName: String, enumColl: Seq[(Long, EnumValueSpec)]): Unit = {
+  override def enumDeclaration(curClass: List[String], enumName: String, enumColl: Seq[(BigInt, EnumValueSpec)]): Unit = {
     val enumClass = types2class(List(enumName))
 
     outHdr.puts

shared/src/main/scala/io/kaitai/struct/languages/GoCompiler.scala

@@ -491,7 +491,7 @@ class GoCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
   override def instanceSetCalculated(instName: InstanceIdentifier): Unit =
     out.puts(s"this.${calculatedFlagForName(instName)} = true")
 
-  override def enumDeclaration(curClass: List[String], enumName: String, enumColl: Seq[(Long, EnumValueSpec)]): Unit = {
+  override def enumDeclaration(curClass: List[String], enumName: String, enumColl: Seq[(BigInt, EnumValueSpec)]): Unit = {
     val fullEnumName: List[String] = curClass ++ List(enumName)
     val fullEnumNameStr = types2class(fullEnumName)
 

shared/src/main/scala/io/kaitai/struct/languages/JavaCompiler.scala

@@ -947,7 +947,7 @@ class JavaCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     out.puts(s"public void _invalidate${idToSetterStr(instName)}() { ${privateMemberName(instName)} = null; }")
   }
 
-  override def enumDeclaration(curClass: String, enumName: String, enumColl: Seq[(Long, String)]): Unit = {
+  override def enumDeclaration(curClass: String, enumName: String, enumColl: Seq[(BigInt, String)]): Unit = {
     val enumClass = type2class(enumName)
 
     out.puts

shared/src/main/scala/io/kaitai/struct/languages/JavaScriptCompiler.scala

@@ -525,7 +525,7 @@ class JavaScriptCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     out.puts(s"return ${privateMemberName(instName)};")
   }
 
-  override def enumDeclaration(curClass: List[String], enumName: String, enumColl: Seq[(Long, EnumValueSpec)]): Unit = {
+  override def enumDeclaration(curClass: List[String], enumName: String, enumColl: Seq[(BigInt, EnumValueSpec)]): Unit = {
     out.puts(s"${type2class(curClass.last)}.${type2class(enumName)} = Object.freeze({")
     out.inc
 

shared/src/main/scala/io/kaitai/struct/languages/LuaCompiler.scala

@@ -273,12 +273,14 @@ class LuaCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
   override def instanceReturn(instName: InstanceIdentifier, attrType: DataType, isNullable: Boolean): Unit =
     out.puts(s"return ${privateMemberName(instName)}")
 
-  override def enumDeclaration(curClass: List[String], enumName: String, enumColl: Seq[(Long, EnumValueSpec)]): Unit = {
+  override def enumDeclaration(curClass: List[String], enumName: String, enumColl: Seq[(BigInt, EnumValueSpec)]): Unit = {
     importList.add("local enum = require(\"enum\")")
 
     out.puts(s"${types2class(curClass)}.${type2class(enumName)} = enum.Enum {")
     out.inc
-    enumColl.foreach { case (id, label) => out.puts(s"${label.name} = ${translator.doIntLiteral(id)},") }
+    enumColl.foreach { case (id, label) =>
+      out.puts(s"${label.name} = ${translator.doIntLiteral(id)},")
+    }
     out.dec
     out.puts("}")
     out.puts

shared/src/main/scala/io/kaitai/struct/languages/NimCompiler.scala

@@ -183,7 +183,7 @@ class NimCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     out.dec
   }
   // For this to work, we need a {.lenientCase.} pragma which disables nim's exhaustive case coverage check
-  override def enumDeclaration(curClass: List[String], enumName: String, enumColl: Seq[(Long, EnumValueSpec)]): Unit = {
+  override def enumDeclaration(curClass: List[String], enumName: String, enumColl: Seq[(BigInt, EnumValueSpec)]): Unit = {
     val enumClass = namespaced(curClass)
     out.puts(s"${enumClass}_${camelCase(enumName, true)}* = enum")
     out.inc

shared/src/main/scala/io/kaitai/struct/languages/PHPCompiler.scala

@@ -436,7 +436,7 @@ class PHPCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     out.puts(s"return ${privateMemberName(instName)};")
   }
 
-  override def enumDeclaration(curClass: List[String], enumName: String, enumColl: Seq[(Long, EnumValueSpec)]): Unit = {
+  override def enumDeclaration(curClass: List[String], enumName: String, enumColl: Seq[(BigInt, EnumValueSpec)]): Unit = {
     val name = curClass ::: List(enumName)
     classHeader(name, None)
     enumColl.foreach { case (id, label) =>