ir: keep order of children in block

codeGenIntermediate/src/prog8/codegen/intermediate/IRCodeGen.kt

@@ -75,36 +75,36 @@ class IRCodeGen(
         // make sure that first chunks in Blocks and Subroutines share the name of the block/sub as label.
 
         irProg.blocks.forEach { block ->
-            if(block.inlineAssemblies.isNotEmpty()) {
-                val first = block.inlineAssemblies.first()
+            block.children.firstOrNull { it is IRInlineAsmChunk }?.let { first->
+                first as IRInlineAsmChunk
                 if(first.label==null) {
                     val replacement = IRInlineAsmChunk(block.name, first.assembly, first.isIR, first.next)
-                    block.inlineAssemblies.removeAt(0)
-                    block.inlineAssemblies.add(0, replacement)
+                    block.children.removeAt(0)
+                    block.children.add(0, replacement)
                 } else if(first.label != block.name) {
                     throw AssemblyError("first chunk in block has label that differs from block name")
                 }
             }
 
-            block.subroutines.forEach { sub ->
+            block.children.filterIsInstance<IRSubroutine>().forEach { sub ->
                 if(sub.chunks.isNotEmpty()) {
                     val first = sub.chunks.first()
                     if(first.label==null) {
                         val replacement = when(first) {
                             is IRCodeChunk -> {
-                                val replacement = IRCodeChunk(sub.name, first.next)
+                                val replacement = IRCodeChunk(sub.label, first.next)
                                 replacement.instructions += first.instructions
                                 replacement
                             }
-                            is IRInlineAsmChunk -> IRInlineAsmChunk(sub.name, first.assembly, first.isIR, first.next)
-                            is IRInlineBinaryChunk -> IRInlineBinaryChunk(sub.name, first.data, first.next)
+                            is IRInlineAsmChunk -> IRInlineAsmChunk(sub.label, first.assembly, first.isIR, first.next)
+                            is IRInlineBinaryChunk -> IRInlineBinaryChunk(sub.label, first.data, first.next)
                             else -> throw AssemblyError("invalid chunk")
                         }
                         sub.chunks.removeAt(0)
                         sub.chunks.add(0, replacement)
-                    } else if(first.label != sub.name) {
+                    } else if(first.label != sub.label) {
                         val next = if(first is IRCodeChunk) first else null
-                        sub.chunks.add(0, IRCodeChunk(sub.name, next))
+                        sub.chunks.add(0, IRCodeChunk(sub.label, next))
                     }
                 }
             }
@@ -116,7 +116,7 @@ class IRCodeGen(
         // note: we do still export the memory mapped symbols so a code generator can use those
         //       for instance when a piece of inlined assembly references them.
         val replacements = mutableListOf<Triple<IRCodeChunkBase, Int, UInt>>()
-        irProg.blocks.asSequence().flatMap { it.subroutines }.flatMap { it.chunks }.forEach { chunk ->
+        irProg.blocks.asSequence().flatMap { it.children.filterIsInstance<IRSubroutine>() }.flatMap { it.chunks }.forEach { chunk ->
             chunk.instructions.withIndex().forEach {
                 (idx, instr) ->
                     val symbolExpr = instr.labelSymbol

codeGenIntermediate/src/prog8/codegen/intermediate/IRPeepholeOptimizer.kt

@@ -4,7 +4,7 @@ import prog8.intermediate.*
 
 internal class IRPeepholeOptimizer(private val irprog: IRProgram) {
     fun optimize() {
-        irprog.blocks.asSequence().flatMap { it.subroutines }.forEach { sub ->
+        irprog.blocks.asSequence().flatMap { it.children.filterIsInstance<IRSubroutine>() }.forEach { sub ->
             removeEmptyChunks(sub)
             joinChunks(sub)
             sub.chunks.withIndex().forEach { (index, chunk1) ->

codeGenIntermediate/src/prog8/codegen/intermediate/IRUnusedCodeRemover.kt

@@ -9,7 +9,7 @@ internal class IRUnusedCodeRemover(private val irprog: IRProgram, private val er
     fun optimize(): Int {
         val allLabeledChunks = mutableMapOf<String, IRCodeChunkBase>()
 
-        irprog.blocks.asSequence().flatMap { it.subroutines }.forEach { sub ->
+        irprog.blocks.asSequence().flatMap { it.children.filterIsInstance<IRSubroutine>() }.forEach { sub ->
             sub.chunks.forEach { chunk ->
                 chunk.label?.let { allLabeledChunks[it] = chunk }
             }
@@ -19,11 +19,11 @@ internal class IRUnusedCodeRemover(private val irprog: IRProgram, private val er
 
         // remove empty subs
         irprog.blocks.forEach { block ->
-            block.subroutines.reversed().forEach { sub ->
+            block.children.filterIsInstance<IRSubroutine>().reversed().forEach { sub ->
                 if(sub.isEmpty()) {
                     if(!sub.position.file.startsWith(libraryFilePrefix))
-                        errors.warn("unused subroutine ${sub.name}", sub.position)
-                    block.subroutines.remove(sub)
+                        errors.warn("unused subroutine ${sub.label}", sub.position)
+                    block.children.remove(sub)
                     numRemoved++
                 }
             }
@@ -41,7 +41,8 @@ internal class IRUnusedCodeRemover(private val irprog: IRProgram, private val er
     }
 
     private fun removeUnreachable(allLabeledChunks: MutableMap<String, IRCodeChunkBase>): Int {
-        val reachable = mutableSetOf(irprog.blocks.single { it.name=="main" }.subroutines.single { it.name=="main.start" }.chunks.first())
+        val entrypointSub = irprog.blocks.single { it.name=="main" }.children.single { it is IRSubroutine && it.label=="main.start" }
+        val reachable = mutableSetOf((entrypointSub as IRSubroutine).chunks.first())
 
         fun grow() {
             val new = mutableSetOf<IRCodeChunkBase>()
@@ -71,7 +72,7 @@ internal class IRUnusedCodeRemover(private val irprog: IRProgram, private val er
     private fun removeSimpleUnlinked(allLabeledChunks: Map<String, IRCodeChunkBase>): Int {
         val linkedChunks = mutableSetOf<IRCodeChunkBase>()
 
-        irprog.blocks.asSequence().flatMap { it.subroutines }.forEach { sub ->
+        irprog.blocks.asSequence().flatMap { it.children.filterIsInstance<IRSubroutine>() }.forEach { sub ->
             sub.chunks.forEach { chunk ->
                 chunk.next?.let { next -> linkedChunks += next }
                 chunk.instructions.forEach {
@@ -93,7 +94,7 @@ internal class IRUnusedCodeRemover(private val irprog: IRProgram, private val er
         linkedChunks: MutableSet<IRCodeChunkBase>
     ): Int {
         var numRemoved = 0
-        irprog.blocks.asSequence().flatMap { it.subroutines }.forEach { sub ->
+        irprog.blocks.asSequence().flatMap { it.children.filterIsInstance<IRSubroutine>() }.forEach { sub ->
             sub.chunks.withIndex().reversed().forEach { (index, chunk) ->
                 if (chunk !in linkedChunks) {
                     if (chunk === sub.chunks[0]) {

codeGenIntermediate/test/TestIRPeepholeOpt.kt

@@ -36,7 +36,7 @@ class TestIRPeepholeOpt: FunSpec({
         return makeIRProgram(listOf(chunk))
     }
 
-    fun IRProgram.chunks(): List<IRCodeChunkBase> = this.blocks.flatMap { it.subroutines }.flatMap { it.chunks }
+    fun IRProgram.chunks(): List<IRCodeChunkBase> = this.blocks.flatMap { it.children.filterIsInstance<IRSubroutine>() }.flatMap { it.chunks }
 
     test("remove nops") {
         val irProg = makeIRProgram(listOf(