Assignment: make its origin explicit

codeGeneration/src/prog8/codegen/target/cpu6502/codegen/assignment/AssignmentAsmGen.kt

@@ -298,7 +298,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                             val origTarget = assign.target.origAstTarget
                             if(origTarget!=null) {
                                 val assignTrue = AnonymousScope(mutableListOf(
-                                    Assignment(origTarget, NumericLiteralValue.fromBoolean(true, assign.position), assign.position)
+                                    Assignment(origTarget, NumericLiteralValue.fromBoolean(true, assign.position), AssignmentOrigin.ASMGEN, assign.position)
                                 ), assign.position)
                                 val assignFalse = AnonymousScope(mutableListOf(), assign.position)
                                 val ifelse = IfElse(value.copy(), assignTrue, assignFalse, assign.position)

codeOptimizers/src/prog8/optimizer/BinExprSplitter.kt

@@ -11,6 +11,7 @@ import prog8.ast.expressions.TypecastExpression
 import prog8.ast.expressions.AugmentAssignmentOperators
 import prog8.ast.statements.AssignTarget
 import prog8.ast.statements.Assignment
+import prog8.ast.statements.AssignmentOrigin
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
 import prog8.compilerinterface.CompilationOptions
@@ -83,7 +84,7 @@ X =      BinExpr                                    X   =   LeftExpr
                 }
 
                 if(binExpr.right.isSimple) {
-                    val firstAssign = Assignment(assignment.target.copy(), binExpr.left, binExpr.left.position)
+                    val firstAssign = Assignment(assignment.target.copy(), binExpr.left, AssignmentOrigin.OPTIMIZER, binExpr.left.position)
                     val targetExpr = assignment.target.toExpression()
                     val augExpr = BinaryExpression(targetExpr, binExpr.operator, binExpr.right, binExpr.right.position)
                     return listOf(
@@ -116,7 +117,7 @@ X =      BinExpr                                    X   =   LeftExpr
                 }
                 val assignTempVar = Assignment(
                     AssignTarget(IdentifierReference(tempVar, typecast.position), null, null, typecast.position),
-                    typecast.expression, typecast.position
+                    typecast.expression, AssignmentOrigin.OPTIMIZER, typecast.position
                 )
                 return listOf(
                     IAstModification.InsertBefore(assignment, assignTempVar, parent as IStatementContainer),

codeOptimizers/src/prog8/optimizer/StatementOptimizer.kt

@@ -120,7 +120,7 @@ class StatementOptimizer(private val program: Program,
             if(!arg.isSimple && arg !is TypecastExpression && arg !is IFunctionCall) {
                 val name = getTempVarName(arg.inferType(program))
                 val tempvar = IdentifierReference(name, functionCallStatement.position)
-                val assignTempvar = Assignment(AssignTarget(tempvar.copy(), null, null, functionCallStatement.position), arg, functionCallStatement.position)
+                val assignTempvar = Assignment(AssignTarget(tempvar.copy(), null, null, functionCallStatement.position), arg, AssignmentOrigin.OPTIMIZER, functionCallStatement.position)
                 return listOf(
                     IAstModification.InsertBefore(functionCallStatement, assignTempvar, parent as IStatementContainer),
                     IAstModification.ReplaceNode(arg, tempvar, functionCallStatement)
@@ -183,7 +183,7 @@ class StatementOptimizer(private val program: Program,
                 // for loop over a (constant) range of just a single value-- optimize the loop away
                 // loopvar/reg = range value , follow by block
                 val scope = AnonymousScope(mutableListOf(), forLoop.position)
-                scope.statements.add(Assignment(AssignTarget(forLoop.loopVar, null, null, forLoop.position), range.from, forLoop.position))
+                scope.statements.add(Assignment(AssignTarget(forLoop.loopVar, null, null, forLoop.position), range.from, AssignmentOrigin.OPTIMIZER, forLoop.position))
                 scope.statements.addAll(forLoop.body.statements)
                 return listOf(IAstModification.ReplaceNode(forLoop, scope, parent))
             }
@@ -198,7 +198,7 @@ class StatementOptimizer(private val program: Program,
                     val character = compTarget.encodeString(sv.value, sv.altEncoding)[0]
                     val byte = NumericLiteralValue(DataType.UBYTE, character.toDouble(), iterable.position)
                     val scope = AnonymousScope(mutableListOf(), forLoop.position)
-                    scope.statements.add(Assignment(AssignTarget(forLoop.loopVar, null, null, forLoop.position), byte, forLoop.position))
+                    scope.statements.add(Assignment(AssignTarget(forLoop.loopVar, null, null, forLoop.position), byte, AssignmentOrigin.OPTIMIZER, forLoop.position))
                     scope.statements.addAll(forLoop.body.statements)
                     return listOf(IAstModification.ReplaceNode(forLoop, scope, parent))
                 }
@@ -212,7 +212,7 @@ class StatementOptimizer(private val program: Program,
                         val scope = AnonymousScope(mutableListOf(), forLoop.position)
                         scope.statements.add(Assignment(
                                 AssignTarget(forLoop.loopVar, null, null, forLoop.position), NumericLiteralValue.optimalInteger(av.toInt(), iterable.position),
-                                forLoop.position))
+                                AssignmentOrigin.OPTIMIZER, forLoop.position))
                         scope.statements.addAll(forLoop.body.statements)
                         return listOf(IAstModification.ReplaceNode(forLoop, scope, parent))
                     }
@@ -323,7 +323,7 @@ class StatementOptimizer(private val program: Program,
                                 val addConstant = Assignment(
                                         assignment.target.copy(),
                                         BinaryExpression(binExpr.left.copy(), "+", rExpr.right, rExpr.position),
-                                        assignment.position
+                                        AssignmentOrigin.OPTIMIZER, assignment.position
                                 )
                                 return listOf(
                                         IAstModification.ReplaceNode(binExpr, expr2, binExpr.parent),
@@ -334,7 +334,7 @@ class StatementOptimizer(private val program: Program,
                                 val subConstant = Assignment(
                                         assignment.target.copy(),
                                         BinaryExpression(binExpr.left.copy(), "-", rExpr.right, rExpr.position),
-                                        assignment.position
+                                        AssignmentOrigin.OPTIMIZER, assignment.position
                                 )
                                 return listOf(
                                         IAstModification.ReplaceNode(binExpr, expr2, binExpr.parent),
@@ -375,7 +375,7 @@ class StatementOptimizer(private val program: Program,
                 if(bexpr.right isSameAs assignment.target) {
                     // X = value - X  -->  X = -X ; X += value  (to avoid need of stack-evaluation)
                     val negation = PrefixExpression("-", bexpr.right.copy(), bexpr.position)
-                    val addValue = Assignment(assignment.target.copy(), BinaryExpression(bexpr.right, "+", bexpr.left, bexpr.position), assignment.position)
+                    val addValue = Assignment(assignment.target.copy(), BinaryExpression(bexpr.right, "+", bexpr.left, bexpr.position), AssignmentOrigin.OPTIMIZER, assignment.position)
                     return listOf(
                         IAstModification.ReplaceNode(bexpr, negation, assignment),
                         IAstModification.InsertAfter(assignment, addValue, parent as IStatementContainer)
@@ -454,7 +454,7 @@ class StatementOptimizer(private val program: Program,
                 }
                 val returnValueIntermediary = IdentifierReference(listOf("prog8_lib", returnVarName), returnStmt.position)
                 val tgt = AssignTarget(returnValueIntermediary, null, null, returnStmt.position)
-                val assign = Assignment(tgt, value, returnStmt.position)
+                val assign = Assignment(tgt, value, AssignmentOrigin.OPTIMIZER, returnStmt.position)
                 val returnReplacement = Return(returnValueIntermediary.copy(), returnStmt.position)
                 return listOf(
                     IAstModification.InsertBefore(returnStmt, assign, parent as IStatementContainer),

compiler/src/prog8/compiler/astprocessing/AstPreprocessor.kt

@@ -62,7 +62,7 @@ class AstPreprocessor(val program: Program, val errors: IErrorReporter) : AstWal
                 } else {
                     if(decl.value!=null && decl.datatype in NumericDatatypes) {
                         val target = AssignTarget(IdentifierReference(listOf(decl.name), decl.position), null, null, decl.position)
-                        val assign = Assignment(target, decl.value!!, decl.position)
+                        val assign = Assignment(target, decl.value!!, AssignmentOrigin.VARINIT, decl.position)
                         replacements.add(IAstModification.ReplaceNode(decl, assign, scope))
                         decl.value = null
                         decl.allowInitializeWithZero = false

compiler/src/prog8/compiler/astprocessing/BeforeAsmAstChanger.kt

@@ -84,7 +84,7 @@ internal class BeforeAsmAstChanger(val program: Program, private val options: Co
                                 "unknown dt"
                             )
                             }, sourceDt, implicit=true)
-                            val assignRight = Assignment(assignment.target, right, assignment.position)
+                            val assignRight = Assignment(assignment.target, right, AssignmentOrigin.BEFOREASMGEN, assignment.position)
                             return listOf(
                                 IAstModification.InsertBefore(assignment, assignRight, parent as IStatementContainer),
                                 IAstModification.ReplaceNode(binExpr.right, binExpr.left, binExpr),
@@ -97,7 +97,7 @@ internal class BeforeAsmAstChanger(val program: Program, private val options: Co
                             "unknown dt"
                         )
                         }, sourceDt, implicit=true)
-                        val assignLeft = Assignment(assignment.target, left, assignment.position)
+                        val assignLeft = Assignment(assignment.target, left, AssignmentOrigin.BEFOREASMGEN, assignment.position)
                         return listOf(
                             IAstModification.InsertBefore(assignment, assignLeft, parent as IStatementContainer),
                             IAstModification.ReplaceNode(binExpr.left, assignment.target.toExpression(), binExpr)
@@ -248,7 +248,7 @@ internal class BeforeAsmAstChanger(val program: Program, private val options: Co
             leftAssignment = Assignment(
                 AssignTarget(IdentifierReference(name, expr.position), null, null, expr.position),
                 expr.left,
-                expr.position
+                AssignmentOrigin.BEFOREASMGEN, expr.position
             )
         }
         if(separateRightExpr) {
@@ -263,7 +263,7 @@ internal class BeforeAsmAstChanger(val program: Program, private val options: Co
             rightAssignment = Assignment(
                 AssignTarget(IdentifierReference(name, expr.position), null, null, expr.position),
                 expr.right,
-                expr.position
+                AssignmentOrigin.BEFOREASMGEN, expr.position
             )
         }
         return CondExprSimplificationResult(
@@ -355,9 +355,8 @@ internal class BeforeAsmAstChanger(val program: Program, private val options: Co
         val statement = expr.containingStatement
         val dt = expr.indexer.indexExpr.inferType(program)
         val tempvar = if(dt.isBytes) listOf("prog8_lib","retval_interm_ub") else listOf("prog8_lib","retval_interm_b")
-        val target =
+        val target = AssignTarget(IdentifierReference(tempvar, expr.indexer.position), null, null, expr.indexer.position)
-            AssignTarget(IdentifierReference(tempvar, expr.indexer.position), null, null, expr.indexer.position)
+        val assign = Assignment(target, expr.indexer.indexExpr, AssignmentOrigin.BEFOREASMGEN, expr.indexer.position)
-        val assign = Assignment(target, expr.indexer.indexExpr, expr.indexer.position)
         modifications.add(IAstModification.InsertBefore(statement, assign, statement.parent as IStatementContainer))
         modifications.add(
             IAstModification.ReplaceNode(

compiler/src/prog8/compiler/astprocessing/CodeDesugarer.kt

@@ -129,7 +129,7 @@ _after:
         if(functionCall.target.nameInSource==listOf("poke")) {
             // poke(a, v) is synonymous with @(a) = v
             val tgt = AssignTarget(null, null, DirectMemoryWrite(functionCall.args[0], position), position)
-            val assign = Assignment(tgt, functionCall.args[1], position)
+            val assign = Assignment(tgt, functionCall.args[1], AssignmentOrigin.OPTIMIZER, position)
             return listOf(IAstModification.ReplaceNode(functionCall as Node, assign, parent))
         }
         return noModifications

compiler/src/prog8/compiler/astprocessing/StatementReorderer.kt

@@ -73,7 +73,7 @@ internal class StatementReorderer(val program: Program,
                             // Add assignment to initialize with zero
                             // Note: for block-level vars, this will introduce assignments in the block scope. These have to be dealt with correctly later.
                             val identifier = IdentifierReference(listOf(decl.name), decl.position)
-                            val assignzero = Assignment(AssignTarget(identifier, null, null, decl.position), decl.zeroElementValue(), decl.position)
+                            val assignzero = Assignment(AssignTarget(identifier, null, null, decl.position), decl.zeroElementValue(), AssignmentOrigin.VARINIT, decl.position)
                             return listOf(IAstModification.InsertAfter(
                                 decl, assignzero, parent as IStatementContainer
                             ))
@@ -85,7 +85,7 @@ internal class StatementReorderer(val program: Program,
                     // So basically consider 'ubyte xx=99' as a short form for 'ubyte xx; xx=99'
                     val pos = decl.value!!.position
                     val identifier = IdentifierReference(listOf(decl.name), pos)
-                    val assign = Assignment(AssignTarget(identifier, null, null, pos), decl.value!!, pos)
+                    val assign = Assignment(AssignTarget(identifier, null, null, pos), decl.value!!, AssignmentOrigin.VARINIT, pos)
                     decl.value = null
                     return listOf(IAstModification.InsertAfter(
                         decl, assign, parent as IStatementContainer
@@ -443,7 +443,7 @@ private fun replaceCallSubStatementWithGosub(function: Subroutine, call: Functio
                 if(argumentValue is IdentifierReference)
                     argumentValue = AddressOf(argumentValue, argumentValue.position)
             }
-            Assignment(AssignTarget(paramIdentifier, null, null, argumentValue.position), argumentValue, argumentValue.position)
+            Assignment(AssignTarget(paramIdentifier, null, null, argumentValue.position), argumentValue, AssignmentOrigin.PARAMETERASSIGN, argumentValue.position)
         }
     val scope = AnonymousScope(assignParams.toMutableList(), call.position)
     scope.statements += GoSub(null, call.target, null, call.position)

compiler/test/TestMemory.kt

@@ -37,49 +37,49 @@ class TestMemory: FunSpec({
 
         var memexpr = NumericLiteralValue.optimalInteger(0x0002, Position.DUMMY)
         var target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
-        var assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
+        var assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
         wrapWithProgram(listOf(assign))
         target.isIOAddress(C64Target.machine) shouldBe false
 
         memexpr = NumericLiteralValue.optimalInteger(0x1000, Position.DUMMY)
         target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
-        assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
+        assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
         wrapWithProgram(listOf(assign))
         target.isIOAddress(C64Target.machine) shouldBe false
 
         memexpr = NumericLiteralValue.optimalInteger(0x9fff, Position.DUMMY)
         target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
-        assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
+        assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
         wrapWithProgram(listOf(assign))
         target.isIOAddress(C64Target.machine) shouldBe false
 
         memexpr = NumericLiteralValue.optimalInteger(0xa000, Position.DUMMY)
         target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
-        assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
+        assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
         wrapWithProgram(listOf(assign))
         target.isIOAddress(C64Target.machine) shouldBe false
 
         memexpr = NumericLiteralValue.optimalInteger(0xc000, Position.DUMMY)
         target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
-        assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
+        assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
         wrapWithProgram(listOf(assign))
         target.isIOAddress(C64Target.machine) shouldBe false
 
         memexpr = NumericLiteralValue.optimalInteger(0xcfff, Position.DUMMY)
         target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
-        assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
+        assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
         wrapWithProgram(listOf(assign))
         target.isIOAddress(C64Target.machine) shouldBe false
 
         memexpr = NumericLiteralValue.optimalInteger(0xeeee, Position.DUMMY)
         target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
-        assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
+        assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
         wrapWithProgram(listOf(assign))
         target.isIOAddress(C64Target.machine) shouldBe false
 
         memexpr = NumericLiteralValue.optimalInteger(0xffff, Position.DUMMY)
         target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
-        assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
+        assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
         wrapWithProgram(listOf(assign))
         target.isIOAddress(C64Target.machine) shouldBe false
     }
@@ -88,25 +88,25 @@ class TestMemory: FunSpec({
 
         var memexpr = NumericLiteralValue.optimalInteger(0x0000, Position.DUMMY)
         var target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
-        var assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
+        var assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
         wrapWithProgram(listOf(assign))
         target.isIOAddress(C64Target.machine) shouldBe true
 
         memexpr = NumericLiteralValue.optimalInteger(0x0001, Position.DUMMY)
         target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
-        assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
+        assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
         wrapWithProgram(listOf(assign))
         target.isIOAddress(C64Target.machine) shouldBe true
 
         memexpr = NumericLiteralValue.optimalInteger(0xd000, Position.DUMMY)
         target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
-        assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
+        assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
         wrapWithProgram(listOf(assign))
         target.isIOAddress(C64Target.machine) shouldBe true
 
         memexpr = NumericLiteralValue.optimalInteger(0xdfff, Position.DUMMY)
         target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
-        assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
+        assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
         wrapWithProgram(listOf(assign))
         target.isIOAddress(C64Target.machine) shouldBe true
     }
@@ -115,7 +115,7 @@ class TestMemory: FunSpec({
         val decl = VarDecl(vartype, VarDeclOrigin.USERCODE, DataType.BYTE, ZeropageWish.DONTCARE, null, "address", NumericLiteralValue.optimalInteger(address, Position.DUMMY), false, false, null, Position.DUMMY)
         val memexpr = IdentifierReference(listOf("address"), Position.DUMMY)
         val target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
-        val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
+        val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
         wrapWithProgram(listOf(decl, assignment))
         return target
     }
@@ -138,13 +138,13 @@ class TestMemory: FunSpec({
     test("memory expression mapped to IO memory on C64") {
         var memexpr = PrefixExpression("+", NumericLiteralValue.optimalInteger(0x1000, Position.DUMMY), Position.DUMMY)
         var target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
-        var assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
+        var assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
         wrapWithProgram(listOf(assign))
         target.isIOAddress(C64Target.machine) shouldBe false
 
         memexpr = PrefixExpression("+", NumericLiteralValue.optimalInteger(0xd020, Position.DUMMY), Position.DUMMY)
         target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
-        assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
+        assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
         wrapWithProgram(listOf(assign))
         printProgram(target.definingModule.program)
         target.isIOAddress(C64Target.machine) shouldBe true
@@ -153,7 +153,7 @@ class TestMemory: FunSpec({
     test("regular variable not in mapped IO ram on C64") {
         val decl = VarDecl(VarDeclType.VAR, VarDeclOrigin.USERCODE, DataType.BYTE, ZeropageWish.DONTCARE, null, "address", null, false, false, null, Position.DUMMY)
         val target = AssignTarget(IdentifierReference(listOf("address"), Position.DUMMY), null, null, Position.DUMMY)
-        val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
+        val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
         val subroutine = Subroutine("test", mutableListOf(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, false, mutableListOf(decl, assignment), Position.DUMMY)
         val module = Module(mutableListOf(subroutine), Position.DUMMY, SourceCode.Generated("test"))
         Program("test", DummyFunctions, DummyMemsizer, DummyStringEncoder)
@@ -165,7 +165,7 @@ class TestMemory: FunSpec({
         val address = 0x1000u
         val decl = VarDecl(VarDeclType.MEMORY, VarDeclOrigin.USERCODE, DataType.UBYTE, ZeropageWish.DONTCARE, null, "address", NumericLiteralValue.optimalInteger(address, Position.DUMMY), false, false, null, Position.DUMMY)
         val target = AssignTarget(IdentifierReference(listOf("address"), Position.DUMMY), null, null, Position.DUMMY)
-        val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
+        val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
         val subroutine = Subroutine("test", mutableListOf(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, false, mutableListOf(decl, assignment), Position.DUMMY)
         val module = Module(mutableListOf(subroutine), Position.DUMMY, SourceCode.Generated("test"))
         Program("test", DummyFunctions, DummyMemsizer, DummyStringEncoder)
@@ -177,7 +177,7 @@ class TestMemory: FunSpec({
         val address = 0xd020u
         val decl = VarDecl(VarDeclType.MEMORY, VarDeclOrigin.USERCODE, DataType.UBYTE, ZeropageWish.DONTCARE, null, "address", NumericLiteralValue.optimalInteger(address, Position.DUMMY), false, false, null, Position.DUMMY)
         val target = AssignTarget(IdentifierReference(listOf("address"), Position.DUMMY), null, null, Position.DUMMY)
-        val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
+        val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
         val subroutine = Subroutine("test", mutableListOf(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, false, mutableListOf(decl, assignment), Position.DUMMY)
         val module = Module(mutableListOf(subroutine), Position.DUMMY, SourceCode.Generated("test"))
         Program("test", DummyFunctions, DummyMemsizer, DummyStringEncoder)
@@ -189,7 +189,7 @@ class TestMemory: FunSpec({
         val decl = VarDecl(VarDeclType.VAR, VarDeclOrigin.USERCODE, DataType.ARRAY_UB, ZeropageWish.DONTCARE, null, "address", null, false, false, null, Position.DUMMY)
         val arrayindexed = ArrayIndexedExpression(IdentifierReference(listOf("address"), Position.DUMMY), ArrayIndex(NumericLiteralValue.optimalInteger(1, Position.DUMMY), Position.DUMMY), Position.DUMMY)
         val target = AssignTarget(null, arrayindexed, null, Position.DUMMY)
-        val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
+        val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
         val subroutine = Subroutine("test", mutableListOf(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, false, mutableListOf(decl, assignment), Position.DUMMY)
         val module = Module(mutableListOf(subroutine), Position.DUMMY, SourceCode.Generated("test"))
         Program("test", DummyFunctions, DummyMemsizer, DummyStringEncoder)
@@ -202,7 +202,7 @@ class TestMemory: FunSpec({
         val decl = VarDecl(VarDeclType.MEMORY, VarDeclOrigin.USERCODE, DataType.ARRAY_UB, ZeropageWish.DONTCARE, null, "address", NumericLiteralValue.optimalInteger(address, Position.DUMMY), false, false, null, Position.DUMMY)
         val arrayindexed = ArrayIndexedExpression(IdentifierReference(listOf("address"), Position.DUMMY), ArrayIndex(NumericLiteralValue.optimalInteger(1, Position.DUMMY), Position.DUMMY), Position.DUMMY)
         val target = AssignTarget(null, arrayindexed, null, Position.DUMMY)
-        val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
+        val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
         val subroutine = Subroutine("test", mutableListOf(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, false, mutableListOf(decl, assignment), Position.DUMMY)
         val module = Module(mutableListOf(subroutine), Position.DUMMY, SourceCode.Generated("test"))
         Program("test", DummyFunctions, DummyMemsizer, DummyStringEncoder)
@@ -215,7 +215,7 @@ class TestMemory: FunSpec({
         val decl = VarDecl(VarDeclType.MEMORY, VarDeclOrigin.USERCODE, DataType.ARRAY_UB, ZeropageWish.DONTCARE, null, "address", NumericLiteralValue.optimalInteger(address, Position.DUMMY), false, false, null, Position.DUMMY)
         val arrayindexed = ArrayIndexedExpression(IdentifierReference(listOf("address"), Position.DUMMY), ArrayIndex(NumericLiteralValue.optimalInteger(1, Position.DUMMY), Position.DUMMY), Position.DUMMY)
         val target = AssignTarget(null, arrayindexed, null, Position.DUMMY)
-        val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
+        val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
         val subroutine = Subroutine("test", mutableListOf(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, false, mutableListOf(decl, assignment), Position.DUMMY)
         val module = Module(mutableListOf(subroutine), Position.DUMMY, SourceCode.Generated("test"))
         Program("test", DummyFunctions, DummyMemsizer, DummyStringEncoder)

compiler/test/codegeneration/TestAsmGenSymbols.kt

@@ -51,14 +51,14 @@ class TestAsmGenSymbols: StringSpec({
         val labelInSub = Label("locallabel", Position.DUMMY)
 
         val tgt = AssignTarget(IdentifierReference(listOf("tgt"), Position.DUMMY), null, null, Position.DUMMY)
-        val assign1 = Assignment(tgt, IdentifierReference(listOf("localvar"), Position.DUMMY), Position.DUMMY)
+        val assign1 = Assignment(tgt, IdentifierReference(listOf("localvar"), Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
-        val assign2 = Assignment(tgt, AddressOf(IdentifierReference(listOf("locallabel"), Position.DUMMY), Position.DUMMY), Position.DUMMY)
+        val assign2 = Assignment(tgt, AddressOf(IdentifierReference(listOf("locallabel"), Position.DUMMY), Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
-        val assign3 = Assignment(tgt, AddressOf(IdentifierReference(listOf("var_outside"), Position.DUMMY), Position.DUMMY), Position.DUMMY)
+        val assign3 = Assignment(tgt, AddressOf(IdentifierReference(listOf("var_outside"), Position.DUMMY), Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
-        val assign4 = Assignment(tgt, AddressOf(IdentifierReference(listOf("label_outside"), Position.DUMMY), Position.DUMMY), Position.DUMMY)
+        val assign4 = Assignment(tgt, AddressOf(IdentifierReference(listOf("label_outside"), Position.DUMMY), Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
-        val assign5 = Assignment(tgt, AddressOf(IdentifierReference(listOf("main","start","localvar"), Position.DUMMY), Position.DUMMY), Position.DUMMY)
+        val assign5 = Assignment(tgt, AddressOf(IdentifierReference(listOf("main","start","localvar"), Position.DUMMY), Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
-        val assign6 = Assignment(tgt, AddressOf(IdentifierReference(listOf("main","start","locallabel"), Position.DUMMY), Position.DUMMY), Position.DUMMY)
+        val assign6 = Assignment(tgt, AddressOf(IdentifierReference(listOf("main","start","locallabel"), Position.DUMMY), Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
-        val assign7 = Assignment(tgt, AddressOf(IdentifierReference(listOf("main","var_outside"), Position.DUMMY), Position.DUMMY), Position.DUMMY)
+        val assign7 = Assignment(tgt, AddressOf(IdentifierReference(listOf("main","var_outside"), Position.DUMMY), Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
-        val assign8 = Assignment(tgt, AddressOf(IdentifierReference(listOf("main","label_outside"), Position.DUMMY), Position.DUMMY), Position.DUMMY)
+        val assign8 = Assignment(tgt, AddressOf(IdentifierReference(listOf("main","label_outside"), Position.DUMMY), Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
 
         val statements = mutableListOf(varInSub, var2InSub, labelInSub, assign1, assign2, assign3, assign4, assign5, assign6, assign7, assign8)
         val subroutine = Subroutine("start", mutableListOf(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, false, statements, Position.DUMMY)

compilerAst/src/prog8/ast/antlr/Antlr2Kotlin.kt

@@ -119,7 +119,7 @@ private fun Prog8ANTLRParser.StatementContext.toAst() : Statement {
     if(vardecl!=null) return vardecl
 
     assignment()?.let {
-        return Assignment(it.assign_target().toAst(), it.expression().toAst(), it.toPosition())
+        return Assignment(it.assign_target().toAst(), it.expression().toAst(), AssignmentOrigin.USERCODE, it.toPosition())
     }
 
     augassignment()?.let {
@@ -127,7 +127,7 @@ private fun Prog8ANTLRParser.StatementContext.toAst() : Statement {
         val target = it.assign_target().toAst()
         val oper = it.operator.text.substringBefore('=')
         val expression = BinaryExpression(target.toExpression(), oper, it.expression().toAst(), it.expression().toPosition())
-        return Assignment(it.assign_target().toAst(), expression, it.toPosition())
+        return Assignment(it.assign_target().toAst(), expression, AssignmentOrigin.USERCODE, it.toPosition())
     }
 
     postincrdecr()?.let {
@@ -230,8 +230,7 @@ private class AsmSubroutineParameter(name: String,
 
 private class AsmSubroutineReturn(val type: DataType,
                                   val registerOrPair: RegisterOrPair?,
-                                  val statusflag: Statusflag?,
+                                  val statusflag: Statusflag?)
-                                  val position: Position)
 
 private fun Prog8ANTLRParser.Asmsub_returnsContext.toAst(): List<AsmSubroutineReturn>
         = asmsub_return().map {
@@ -248,8 +247,7 @@ private fun Prog8ANTLRParser.Asmsub_returnsContext.toAst(): List<AsmSubroutineRe
             AsmSubroutineReturn(
                     it.datatype().toAst(),
                     registerorpair,
-                    statusregister,
+                    statusregister)
-                    toPosition())
         }
 
 private fun Prog8ANTLRParser.Asmsub_paramsContext.toAst(): List<AsmSubroutineParameter>

compilerAst/src/prog8/ast/statements/AstStatements.kt

@@ -178,6 +178,7 @@ enum class VarDeclOrigin {
     ARRAYLITERAL
 }
 
+
 class VarDecl(val type: VarDeclType,
               val origin: VarDeclOrigin,
               private val declaredDatatype: DataType,
@@ -305,7 +306,16 @@ class ArrayIndex(var indexExpr: Expression,
     override fun copy() = ArrayIndex(indexExpr.copy(), position)
 }
 
-class Assignment(var target: AssignTarget, var value: Expression, override val position: Position) : Statement() {
+enum class AssignmentOrigin {
+    USERCODE,
+    VARINIT,
+    PARAMETERASSIGN,
+    OPTIMIZER,
+    BEFOREASMGEN,
+    ASMGEN,
+}
+
+class Assignment(var target: AssignTarget, var value: Expression, var origin: AssignmentOrigin, override val position: Position) : Statement() {
     override lateinit var parent: Node
 
     override fun linkParents(parent: Node) {
@@ -323,7 +333,7 @@ class Assignment(var target: AssignTarget, var value: Expression, override val p
         replacement.parent = this
     }
 
-    override fun copy()= Assignment(target.copy(), value.copy(), position)
+    override fun copy()= Assignment(target.copy(), value.copy(), origin, position)
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
     override fun accept(visitor: AstWalker, parent: Node) = visitor.visit(this, parent)
     override fun toString() = "Assignment(target: $target, value: $value, pos=$position)"

docs/source/todo.rst

@@ -3,6 +3,7 @@ TODO
 
 For next compiler release (7.7)
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+- use the assignment origin? in codegen? (origin VARINIT)
 - optimize codegen of pipe operator to avoid needless assigns to temp var
 
 
@@ -21,7 +22,6 @@ Blocked by an official Commander-x16 r39 release
 
 Future Things and Ideas
 ^^^^^^^^^^^^^^^^^^^^^^^
-- mark the initialization assignment to a vardecl as such
 - can we promise a left-to-right function call argument evaluation? without sacrificing performance
 - unify FunctioncallExpression + FunctioncallStatement and PipeExpression + Pipe statement, may require moving Expression/Statement into interfaces instead of abstract base classes
 - for the pipe operator: recognise a placeholder (``?`` or ``%`` or ``_``) in a non-unary function call to allow things as ``4 |> mkword(?, $44) |> print_uw``