better checking for number of return values

assignment optimization if return register already is the same as the assignment target

codeCore/src/prog8/code/ast/AstExpressions.kt

@@ -210,11 +210,6 @@ class PtFunctionCall(val name: String,
                      val void: Boolean,
                      type: DataType,
                      position: Position) : PtExpression(type, position) {
-    init {
-        if(!void)
-            require(type!=DataType.UNDEFINED)
-    }
-
     val args: List<PtExpression>
         get() = children.map { it as PtExpression }
 }

codeCore/src/prog8/code/ast/AstPrinter.kt

@@ -10,7 +10,7 @@ fun printAst(root: PtNode, skipLibraries: Boolean, output: (text: String) -> Uni
     fun type(dt: DataType) = "!${dt.name.lowercase()}!"
     fun txt(node: PtNode): String {
         return when(node) {
-            is PtAssignTarget -> "<target>"
+            is PtAssignTarget -> if(node.void) "<void>" else "<target>"
             is PtAssignment -> "<assign>"
             is PtAugmentedAssign -> "<inplace-assign> ${node.operator}"
             is PtBreakpoint -> "%breakpoint"

codeCore/src/prog8/code/optimize/Optimizer.kt

@@ -1,13 +1,18 @@
 package prog8.code.optimize
 
+import prog8.code.StRomSub
+import prog8.code.SymbolTable
 import prog8.code.ast.*
 import prog8.code.core.*
 
 
-fun optimizeIntermediateAst(program: PtProgram, options: CompilationOptions, errors: IErrorReporter) {
+fun optimizeIntermediateAst(program: PtProgram, options: CompilationOptions, st: SymbolTable, errors: IErrorReporter) {
     if (!options.optimize)
         return
-    while(errors.noErrors() && optimizeCommonSubExpressions(program, errors)>0) {
+    while (errors.noErrors() &&
+        (optimizeCommonSubExpressions(program, errors)
+                + optimizeAssignTargets(program, st, errors)) > 0
+    ) {
         // keep rolling
     }
 }
@@ -109,6 +114,79 @@ private fun optimizeCommonSubExpressions(program: PtProgram, errors: IErrorRepor
 }
 
 
+private fun optimizeAssignTargets(program: PtProgram, st: SymbolTable, errors: IErrorReporter): Int {
+    var changes = 0
+    walkAst(program) { node: PtNode, depth: Int ->
+        if(node is PtAssignment) {
+            val value = node.value
+            val functionName = when(value) {
+                is PtBuiltinFunctionCall -> value.name
+                is PtFunctionCall -> value.name
+                else -> null
+            }
+            if(functionName!=null) {
+                val stNode = st.lookup(functionName)
+                if (stNode is StRomSub) {
+                    require(node.children.size==stNode.returns.size+1) {
+                        "number of targets must match return values"
+                    }
+                    node.children.zip(stNode.returns).withIndex().forEach { (index, xx) ->
+                        val target = xx.first as PtAssignTarget
+                        val returnedRegister = xx.second.register.registerOrPair
+                        if(returnedRegister!=null && !target.void && target.identifier!=null) {
+                            if(isSame(target.identifier!!, xx.second.type, returnedRegister)) {
+                                // output register is already identical to target register, so it can become void
+                                val voidTarget = PtAssignTarget(true, target.position)
+                                node.children[index] = voidTarget
+                                voidTarget.parent = node
+                                changes++
+                            }
+                        }
+                    }
+                }
+                if(node.children.dropLast(1).all { (it as PtAssignTarget).void }) {
+                    // all targets are now void, the whole assignment can be discarded and replaced by just a (void) call to the subroutine
+                    val index = node.parent.children.indexOf(node)
+                    val voidCall = PtFunctionCall(functionName, true, value.type, value.position)
+                    value.children.forEach { voidCall.add(it) }
+                    node.parent.children[index] = voidCall
+                    voidCall.parent = node.parent
+                    changes++
+                }
+            }
+        }
+        true
+    }
+    return changes
+}
+
+internal fun isSame(identifier: PtIdentifier, type: DataType, returnedRegister: RegisterOrPair): Boolean {
+    if(returnedRegister in Cx16VirtualRegisters) {
+        val regname = returnedRegister.name.lowercase()
+        val identifierRegName = identifier.name.substringAfterLast('.')
+        /*
+            cx16.r?    UWORD
+            cx16.r?s   WORD
+            cx16.r?L   UBYTE
+            cx16.r?H   UBYTE
+            cx16.r?sL  BYTE
+            cx16.r?sH  BYTE
+         */
+        if(identifier.type in ByteDatatypes && type in ByteDatatypes) {
+            if(identifier.name.startsWith("cx16.$regname") && identifierRegName.startsWith(regname)) {
+                return identifierRegName.substring(2) in arrayOf("", "L", "sL")     // note: not the -H (msb) variants!
+            }
+        }
+        else if(identifier.type in WordDatatypes && type in WordDatatypes) {
+            if(identifier.name.startsWith("cx16.$regname") && identifierRegName.startsWith(regname)) {
+                return identifierRegName.substring(2) in arrayOf("", "s")
+            }
+        }
+    }
+    return false   // there are no identifiers directly corresponding to cpu registers
+}
+
+
 internal fun findScopeName(node: PtNode): String {
     var parent=node
     while(parent !is PtNamedNode)