Implement PR suggestions

Author: austnwil

src/main/java/com/amazon/ion/bytecode/bin11/ByteArrayBytecodeGenerator11.kt

@@ -50,6 +50,7 @@ internal class ByteArrayBytecodeGenerator11(
                     symTab
                 )
             } catch (e: StackOverflowError) {
+                // TODO: implement recursion limit instead of catching StackOverflowError
                 throw IonException("Ion data nested too deeply", e)
             }
         }

src/main/java/com/amazon/ion/bytecode/bin11/bytearray/AnnotationSIDOpcodeHandler.kt

@@ -22,8 +22,6 @@ internal object AnnotationSIDOpcodeHandler : OpcodeToBytecodeHandler {
         macroIndices: IntArray,
         symbolTable: Array<String?>
     ): Int {
-        assert(opcode == 0x58) { "Handler cannot compile opcode ${opcode.toHexString()}" }
-
         val sidValueAndLength = PrimitiveDecoder.readFlexUIntValueAndLength(source, position)
         val sid = sidValueAndLength.toInt()
         val length = sidValueAndLength.shr(Int.SIZE_BITS).toInt()

src/main/java/com/amazon/ion/bytecode/bin11/bytearray/IntOpcodeHandlers.kt

@@ -152,8 +152,6 @@ internal object LongIntOpcodeHandler : OpcodeToBytecodeHandler {
  * */
 @OptIn(ExperimentalStdlibApi::class)
 internal val TAGLESS_FLEX_INT = OpcodeToBytecodeHandler { opcode, src, pos, dest, cp, _, _, _ ->
-    assert(opcode == 0x60) { "Handler cannot compile opcode ${opcode.toHexString()}" }
-
     val flexIntLength = PrimitiveDecoder.lengthOfFlexIntOrUIntAt(src, pos)
     when (flexIntLength) {
         // TODO(perf): See if there's any performance benefit to having a separate case for length=1|2 and using INT_I16 instruction

src/main/java/com/amazon/ion/bytecode/bin11/bytearray/ListOpcodeHandlers.kt

@@ -27,8 +27,6 @@ internal object ShortLengthPrefixedListOpcodeHandler : OpcodeToBytecodeHandler {
         macroIndices: IntArray,
         symbolTable: Array<String?>
     ): Int {
-        assert(opcode in 0xb0..0xbf) { "Handler cannot compile opcode ${opcode.toHexString()}" }
-
         val length = opcode and 0xF
         BytecodeEmitter.emitList(destination) {
             var p = position
@@ -66,8 +64,6 @@ internal object LongLengthPrefixedListOpcodeHandler : OpcodeToBytecodeHandler {
         macroIndices: IntArray,
         symbolTable: Array<String?>
     ): Int {
-        assert(opcode == 0xfa) { "Handler cannot compile opcode ${opcode.toHexString()}" }
-
         val containerSizeUIntValueAndLength = PrimitiveDecoder.readFlexUIntValueAndLength(source, position)
         val containerLength = containerSizeUIntValueAndLength.toInt()
         val prefixLength = containerSizeUIntValueAndLength.shr(Int.SIZE_BITS).toInt()
@@ -107,8 +103,6 @@ internal object DelimitedListOpcodeHandler : OpcodeToBytecodeHandler {
         macroIndices: IntArray,
         symbolTable: Array<String?>
     ): Int {
-        assert(opcode == 0xf0) { "Handler cannot compile opcode ${opcode.toHexString()}" }
-
         var p = position
         BytecodeEmitter.emitList(destination) {
             while (true) {
@@ -148,16 +142,14 @@ internal object TaglessElementListOpcodeHandler : OpcodeToBytecodeHandler {
         macroIndices: IntArray,
         symbolTable: Array<String?>
     ): Int {
-        assert(opcode == 0x5b) { "Handler cannot compile opcode ${opcode.toHexString()}" }
-
         var p = position
         val childOpcode = source[p++].unsignedToInt()
         val macroAddress = when (childOpcode) {
             in 0x00..0x47 -> childOpcode
             in 0x48..0x4f -> {
                 val flexUIntValueAndLength = PrimitiveDecoder.readFlexUIntValueAndLength(source, p)
                 val addressLength = flexUIntValueAndLength.shr(Int.SIZE_BITS).toInt()
-                p += flexUIntValueAndLength
+                p += addressLength
                 val lsb = childOpcode - 0x48
                 val msb = flexUIntValueAndLength.toInt() * 8
                 msb + lsb + 72
@@ -183,7 +175,7 @@ internal object TaglessElementListOpcodeHandler : OpcodeToBytecodeHandler {
         if (macroAddress < 0) {
             val handler = TaglessOpcodeHandlerTable.handler(childOpcode)
             BytecodeEmitter.emitList(destination) {
-                for (i in 0 until containerLength) {
+                for (i in 0 until childCount) {
                     p += handler.convertOpcodeToBytecode(
                         childOpcode,
                         source,

src/main/java/com/amazon/ion/bytecode/bin11/bytearray/SymbolOpcodeHandlers.kt

@@ -22,8 +22,6 @@ internal object SymbolSIDOpcodeHandler : OpcodeToBytecodeHandler {
         macroIndices: IntArray,
         symbolTable: Array<String?>
     ): Int {
-        assert(opcode in 0x50..0x57) { "Handler cannot compile opcode ${opcode.toHexString()}" }
-
         val lsb = opcode and 0b111
         val msbValueAndLength = PrimitiveDecoder.readFlexUIntValueAndLength(source, position)
         val msb = msbValueAndLength.toInt().shl(3)
@@ -49,8 +47,6 @@ internal object SingleCharSymbolOpcodeHandler : OpcodeToBytecodeHandler {
         macroIndices: IntArray,
         symbolTable: Array<String?>
     ): Int {
-        assert(opcode == 0xa1) { "Handler cannot compile opcode ${opcode.toHexString()}" }
-
         val char = source[position].toInt()
         destination.add(Instructions.I_SYMBOL_CHAR.packInstructionData(char))
         return 1

src/test/java/com/amazon/ion/bytecode/GeneratorTestUtil.kt

@@ -54,7 +54,7 @@ object GeneratorTestUtil {
      * Asserts that the generator throws an [IonException] when compiling its input (as opposed to a [Throwable] of
      * an incorrect type).
      */
-    internal fun BytecodeGenerator.shouldThrowIonException() {
+    internal fun BytecodeGenerator.refillShouldThrowIonException() {
         assertThrows<IonException> {
             val generator = this
             generator.refill(BytecodeBuffer(), ConstantPool(), EMPTY_MACRO_TABLE, intArrayOf(), DEFAULT_SYMBOL_TABLE)

src/test/java/com/amazon/ion/bytecode/bin11/ByteArrayBytecodeGenerator11Test.kt

@@ -5,8 +5,8 @@ package com.amazon.ion.bytecode.bin11
 import com.amazon.ion.TextToBinaryUtils.cleanCommentedHexBytes
 import com.amazon.ion.TextToBinaryUtils.hexStringToByteArray
 import com.amazon.ion.Timestamp
+import com.amazon.ion.bytecode.GeneratorTestUtil.refillShouldThrowIonException
 import com.amazon.ion.bytecode.GeneratorTestUtil.shouldGenerate
-import com.amazon.ion.bytecode.GeneratorTestUtil.shouldThrowIonException
 import com.amazon.ion.bytecode.PrimitiveUtils.generateFlexUIntBytes
 import com.amazon.ion.bytecode.ir.Instructions
 import com.amazon.ion.bytecode.ir.Instructions.packInstructionData
@@ -151,6 +151,6 @@ internal class ByteArrayBytecodeGenerator11Test {
         }
 
         val generator = ByteArrayBytecodeGenerator11(bytes.toByteArray(), 0)
-        generator.shouldThrowIonException()
+        generator.refillShouldThrowIonException()
     }
 }

src/test/java/com/amazon/ion/bytecode/bin11/bytearray/ListOpcodeHandlerTests.kt

@@ -159,7 +159,7 @@ class ListOpcodeHandlerTests {
 
         @Test
         fun `handler compiles large lists`() {
-            val testLength = 10_000_000 // Much larger causes test crash
+            val testLength = 10_000_000 // Much larger causes OutOfMemoryError in gradle test executor
             val bytes = byteArrayOf(
                 OpCode.VARIABLE_LENGTH_LIST.toByte(),
                 *generateFlexUIntBytes(testLength),
@@ -284,7 +284,7 @@ class ListOpcodeHandlerTests {
 
         @Test
         fun `handler compiles large lists`() {
-            val testLength = 10_000_000 // Much larger causes test crash
+            val testLength = 10_000_000 // Much larger causes OutOfMemoryError in gradle test executor
             val bytes = byteArrayOf(
                 OpCode.DELIMITED_LIST.toByte(),
                 *Array<Byte>(testLength) { 0x6E /* true */ }.toByteArray(),
@@ -710,7 +710,7 @@ class ListOpcodeHandlerTests {
 
         @Test
         fun `handler compiles large lists`() {
-            val testLength = 10_000_000 // Much larger causes test crash
+            val testLength = 10_000_000 // Much larger causes OutOfMemoryError in gradle test executor
             val bytes = byteArrayOf(
                 OpCode.TAGLESS_ELEMENT_LIST.toByte(),
                 OpCode.INT_8.toByte(),