optimized away VarDecl.subroutineParameter

compiler/src/prog8/compiler/astprocessing/AstChecker.kt

@@ -60,10 +60,12 @@ internal class AstChecker(private val program: Program,
     }
 
     override fun visit(identifier: IdentifierReference) {
-        val targetParam = identifier.targetVarDecl(program)?.subroutineParameter
+        val target = identifier.targetVarDecl(program)
-        if(targetParam!=null) {
+        if(target != null && target.origin==VarDeclOrigin.SUBROUTINEPARAM) {
-            if((targetParam.parent as Subroutine).isAsmSubroutine)
+            if(target.definingSubroutine!!.isAsmSubroutine) {
-                errors.err("cannot refer to parameter of asmsub by name", identifier.position)
+                if(target.definingSubroutine!!.parameters.any { it.name == identifier.nameInSource.last() })
+                    errors.err("cannot refer to parameter of asmsub by name", identifier.position)
+            }
         }
     }
 

compiler/src/prog8/compiler/astprocessing/AstIdentifiersChecker.kt

@@ -92,7 +92,7 @@ internal class AstIdentifiersChecker(private val errors: IErrorReporter,
             val paramsToCheck = paramNames.intersect(namesInSub)
             for(name in paramsToCheck) {
                 val symbol = subroutine.searchSymbol(name)
-                if(symbol!=null && (symbol as? VarDecl)?.subroutineParameter==null)
+                if(symbol!=null && (symbol as? VarDecl)?.origin!=VarDeclOrigin.SUBROUTINEPARAM)
                     nameError(name, symbol.position, subroutine)
             }
 

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

@@ -90,7 +90,7 @@ internal class BeforeAsmAstChanger(val program: Program,
                                 "unknown dt"
                             )
                             }, sourceDt, implicit=true)
-                            val assignRight = Assignment(assignment.target, right, AssignmentOrigin.BEFOREASMGEN, assignment.position)
+                            val assignRight = Assignment(assignment.target, right, AssignmentOrigin.ASMGEN, assignment.position)
                             return listOf(
                                 IAstModification.InsertBefore(assignment, assignRight, parent as IStatementContainer),
                                 IAstModification.ReplaceNode(binExpr.right, binExpr.left, binExpr),
@@ -103,7 +103,7 @@ internal class BeforeAsmAstChanger(val program: Program,
                             "unknown dt"
                         )
                         }, sourceDt, implicit=true)
-                        val assignLeft = Assignment(assignment.target, left, AssignmentOrigin.BEFOREASMGEN, assignment.position)
+                        val assignLeft = Assignment(assignment.target, left, AssignmentOrigin.ASMGEN, assignment.position)
                         return listOf(
                             IAstModification.InsertBefore(assignment, assignLeft, parent as IStatementContainer),
                             IAstModification.ReplaceNode(binExpr.left, assignment.target.toExpression(), binExpr)
@@ -293,7 +293,7 @@ internal class BeforeAsmAstChanger(val program: Program,
         val dt = expr.indexer.indexExpr.inferType(program)
         val (tempVarName, _) = program.getTempVar(dt.getOrElse { throw FatalAstException("invalid dt") })
         val target = AssignTarget(IdentifierReference(tempVarName, 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, AssignmentOrigin.ASMGEN, expr.indexer.position)
         modifications.add(IAstModification.InsertBefore(statement, assign, statement.parent as IStatementContainer))
         modifications.add(
             IAstModification.ReplaceNode(

compiler/src/prog8/compiler/astprocessing/BoolRemover.kt

@@ -30,7 +30,7 @@ internal class BoolRemover(val program: Program) : AstWalker() {
                     newvalue = NumericLiteral(DataType.UBYTE, 1.0, newvalue.position)
             }
             val ubyteDecl = VarDecl(decl.type, decl.origin, DataType.UBYTE, decl.zeropage, decl.arraysize, decl.name,
-                newvalue, decl.isArray, decl.sharedWithAsm, decl.subroutineParameter, decl.position)
+                newvalue, decl.isArray, decl.sharedWithAsm, decl.position)
             return listOf(IAstModification.ReplaceNode(decl, ubyteDecl, parent))
         }
 
@@ -47,7 +47,7 @@ internal class BoolRemover(val program: Program) : AstWalker() {
                 newarray = ArrayLiteral(InferredTypes.InferredType.known(DataType.ARRAY_UB), convertedArray, decl.position)
             }
             val ubyteArrayDecl = VarDecl(decl.type, decl.origin, DataType.ARRAY_UB, decl.zeropage, decl.arraysize, decl.name,
-                newarray, true, decl.sharedWithAsm, decl.subroutineParameter, decl.position)
+                newarray, true, decl.sharedWithAsm, decl.position)
             return listOf(IAstModification.ReplaceNode(decl, ubyteArrayDecl, parent))
         }
 

compiler/src/prog8/compiler/astprocessing/NotExpressionAndIfComparisonExprChanger.kt

@@ -178,7 +178,7 @@ internal class NotExpressionAndIfComparisonExprChanger(val program: Program, val
             leftAssignment = Assignment(
                 AssignTarget(IdentifierReference(name, expr.position), null, null, expr.position),
                 expr.left.copy(),
-                AssignmentOrigin.BEFOREASMGEN, expr.position
+                AssignmentOrigin.ASMGEN, expr.position
             )
         }
         if(separateRightExpr) {
@@ -187,7 +187,7 @@ internal class NotExpressionAndIfComparisonExprChanger(val program: Program, val
             rightAssignment = Assignment(
                 AssignTarget(IdentifierReference(tempVarName, expr.position), null, null, expr.position),
                 expr.right.copy(),
-                AssignmentOrigin.BEFOREASMGEN, expr.position
+                AssignmentOrigin.ASMGEN, expr.position
             )
         }
         return CondExprSimplificationResult(

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

@@ -153,7 +153,7 @@ internal class StatementReorderer(val program: Program,
                     subroutine.statements
                         .asSequence()
                         .filterIsInstance<VarDecl>()
-                        .filter { it.subroutineParameter!=null && it.name in stringParamsByNames }
+                        .filter { it.origin==VarDeclOrigin.SUBROUTINEPARAM && it.name in stringParamsByNames }
                         .map {
                             val newvar = VarDecl(it.type, it.origin, DataType.UWORD,
                                 it.zeropage,
@@ -162,7 +162,6 @@ internal class StatementReorderer(val program: Program,
                                 null,
                                 false,
                                 it.sharedWithAsm,
-                                stringParamsByNames.getValue(it.name),
                                 it.position
                             )
                             IAstModification.ReplaceNode(it, newvar, subroutine)

compiler/test/TestMemory.kt

@@ -112,7 +112,7 @@ class TestMemory: FunSpec({
     }
 
     fun createTestProgramForMemoryRefViaVar(address: UInt, vartype: VarDeclType): AssignTarget {
-        val decl = VarDecl(vartype, VarDeclOrigin.USERCODE, DataType.BYTE, ZeropageWish.DONTCARE, null, "address", NumericLiteral.optimalInteger(address, Position.DUMMY), false, false, null, Position.DUMMY)
+        val decl = VarDecl(vartype, VarDeclOrigin.USERCODE, DataType.BYTE, ZeropageWish.DONTCARE, null, "address", NumericLiteral.optimalInteger(address, Position.DUMMY), false, false, Position.DUMMY)
         val memexpr = IdentifierReference(listOf("address"), Position.DUMMY)
         val target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
         val assignment = Assignment(target, NumericLiteral.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
@@ -150,7 +150,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 decl = VarDecl(VarDeclType.VAR, VarDeclOrigin.USERCODE, DataType.BYTE, ZeropageWish.DONTCARE, null, "address", null, false, false, Position.DUMMY)
         val target = AssignTarget(IdentifierReference(listOf("address"), Position.DUMMY), null, null, Position.DUMMY)
         val assignment = Assignment(target, NumericLiteral.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)
@@ -162,7 +162,7 @@ class TestMemory: FunSpec({
 
     test("memory mapped variable not in mapped IO ram on C64") {
         val address = 0x1000u
-        val decl = VarDecl(VarDeclType.MEMORY, VarDeclOrigin.USERCODE, DataType.UBYTE, ZeropageWish.DONTCARE, null, "address", NumericLiteral.optimalInteger(address, Position.DUMMY), false, false, null, Position.DUMMY)
+        val decl = VarDecl(VarDeclType.MEMORY, VarDeclOrigin.USERCODE, DataType.UBYTE, ZeropageWish.DONTCARE, null, "address", NumericLiteral.optimalInteger(address, Position.DUMMY), false, false, Position.DUMMY)
         val target = AssignTarget(IdentifierReference(listOf("address"), Position.DUMMY), null, null, Position.DUMMY)
         val assignment = Assignment(target, NumericLiteral.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)
@@ -174,7 +174,7 @@ class TestMemory: FunSpec({
 
     test("memory mapped variable in mapped IO ram on C64") {
         val address = 0xd020u
-        val decl = VarDecl(VarDeclType.MEMORY, VarDeclOrigin.USERCODE, DataType.UBYTE, ZeropageWish.DONTCARE, null, "address", NumericLiteral.optimalInteger(address, Position.DUMMY), false, false, null, Position.DUMMY)
+        val decl = VarDecl(VarDeclType.MEMORY, VarDeclOrigin.USERCODE, DataType.UBYTE, ZeropageWish.DONTCARE, null, "address", NumericLiteral.optimalInteger(address, Position.DUMMY), false, false, Position.DUMMY)
         val target = AssignTarget(IdentifierReference(listOf("address"), Position.DUMMY), null, null, Position.DUMMY)
         val assignment = Assignment(target, NumericLiteral.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)
@@ -185,7 +185,7 @@ class TestMemory: FunSpec({
     }
 
     test("array not in mapped IO ram") {
-        val decl = VarDecl(VarDeclType.VAR, VarDeclOrigin.USERCODE, DataType.ARRAY_UB, ZeropageWish.DONTCARE, null, "address", null, false, false, null, Position.DUMMY)
+        val decl = VarDecl(VarDeclType.VAR, VarDeclOrigin.USERCODE, DataType.ARRAY_UB, ZeropageWish.DONTCARE, null, "address", null, false, false, Position.DUMMY)
         val arrayindexed = ArrayIndexedExpression(IdentifierReference(listOf("address"), Position.DUMMY), ArrayIndex(NumericLiteral.optimalInteger(1, Position.DUMMY), Position.DUMMY), Position.DUMMY)
         val target = AssignTarget(null, arrayindexed, null, Position.DUMMY)
         val assignment = Assignment(target, NumericLiteral.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
@@ -198,7 +198,7 @@ class TestMemory: FunSpec({
 
     test("memory mapped array not in mapped IO ram") {
         val address = 0x1000u
-        val decl = VarDecl(VarDeclType.MEMORY, VarDeclOrigin.USERCODE, DataType.ARRAY_UB, ZeropageWish.DONTCARE, null, "address", NumericLiteral.optimalInteger(address, Position.DUMMY), false, false, null, Position.DUMMY)
+        val decl = VarDecl(VarDeclType.MEMORY, VarDeclOrigin.USERCODE, DataType.ARRAY_UB, ZeropageWish.DONTCARE, null, "address", NumericLiteral.optimalInteger(address, Position.DUMMY), false, false, Position.DUMMY)
         val arrayindexed = ArrayIndexedExpression(IdentifierReference(listOf("address"), Position.DUMMY), ArrayIndex(NumericLiteral.optimalInteger(1, Position.DUMMY), Position.DUMMY), Position.DUMMY)
         val target = AssignTarget(null, arrayindexed, null, Position.DUMMY)
         val assignment = Assignment(target, NumericLiteral.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
@@ -211,7 +211,7 @@ class TestMemory: FunSpec({
 
     test("memory mapped array in mapped IO ram") {
         val address = 0xd800u
-        val decl = VarDecl(VarDeclType.MEMORY, VarDeclOrigin.USERCODE, DataType.ARRAY_UB, ZeropageWish.DONTCARE, null, "address", NumericLiteral.optimalInteger(address, Position.DUMMY), false, false, null, Position.DUMMY)
+        val decl = VarDecl(VarDeclType.MEMORY, VarDeclOrigin.USERCODE, DataType.ARRAY_UB, ZeropageWish.DONTCARE, null, "address", NumericLiteral.optimalInteger(address, Position.DUMMY), false, false, Position.DUMMY)
         val arrayindexed = ArrayIndexedExpression(IdentifierReference(listOf("address"), Position.DUMMY), ArrayIndex(NumericLiteral.optimalInteger(1, Position.DUMMY), Position.DUMMY), Position.DUMMY)
         val target = AssignTarget(null, arrayindexed, null, Position.DUMMY)
         val assignment = Assignment(target, NumericLiteral.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)

compiler/test/codegeneration/TestAsmGenSymbols.kt

@@ -46,8 +46,8 @@ class TestAsmGenSymbols: StringSpec({
     }
 
          */
-        val varInSub = VarDecl(VarDeclType.VAR, VarDeclOrigin.USERCODE, DataType.UWORD, ZeropageWish.DONTCARE, null, "localvar", NumericLiteral.optimalInteger(1234, Position.DUMMY), false, false, null, Position.DUMMY)
+        val varInSub = VarDecl(VarDeclType.VAR, VarDeclOrigin.USERCODE, DataType.UWORD, ZeropageWish.DONTCARE, null, "localvar", NumericLiteral.optimalInteger(1234, Position.DUMMY), false, false, Position.DUMMY)
-        val var2InSub = VarDecl(VarDeclType.VAR, VarDeclOrigin.USERCODE, DataType.UWORD, ZeropageWish.DONTCARE, null, "tgt", null, false, false, null, Position.DUMMY)
+        val var2InSub = VarDecl(VarDeclType.VAR, VarDeclOrigin.USERCODE, DataType.UWORD, ZeropageWish.DONTCARE, null, "tgt", null, false, false, Position.DUMMY)
         val labelInSub = Label("locallabel", Position.DUMMY)
 
         val tgt = AssignTarget(IdentifierReference(listOf("tgt"), Position.DUMMY), null, null, Position.DUMMY)
@@ -63,7 +63,7 @@ class TestAsmGenSymbols: StringSpec({
         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)
         val labelInBlock = Label("label_outside", Position.DUMMY)
-        val varInBlock = VarDecl(VarDeclType.VAR, VarDeclOrigin.USERCODE, DataType.UWORD, ZeropageWish.DONTCARE, null, "var_outside", null, false, false, null, Position.DUMMY)
+        val varInBlock = VarDecl(VarDeclType.VAR, VarDeclOrigin.USERCODE, DataType.UWORD, ZeropageWish.DONTCARE, null, "var_outside", null, false, false, Position.DUMMY)
         val block = Block("main", null, mutableListOf(labelInBlock, varInBlock, subroutine), false, Position.DUMMY)
 
         val module = Module(mutableListOf(block), Position.DUMMY, SourceCode.Generated("test"))

compilerAst/src/prog8/ast/Extensions.kt

@@ -40,7 +40,7 @@ fun Program.getTempVar(dt: DataType, altNames: Boolean=false): Pair<List<String>
     // add new temp variable to the ast directly (we can do this here because we're not iterating inside those container blocks)
     val decl = VarDecl(
         VarDeclType.VAR, VarDeclOrigin.AUTOGENERATED, dt, ZeropageWish.DONTCARE,
-        null, tmpvarName[1], null, isArray = false, sharedWithAsm = false, subroutineParameter = null, position = Position.DUMMY
+        null, tmpvarName[1], null, isArray = false, sharedWithAsm = false, position = Position.DUMMY
     )
     block.statements.add(decl)
     decl.linkParents(block)

compilerAst/src/prog8/ast/Program.kt

@@ -85,7 +85,7 @@ class Program(val name: String,
             val varName = "string_${internedStringsBlock.statements.size}"
             val decl = VarDecl(
                 VarDeclType.VAR, VarDeclOrigin.STRINGLITERAL, DataType.STR, ZeropageWish.NOT_IN_ZEROPAGE, null, varName, string,
-                isArray = false, sharedWithAsm = false, subroutineParameter = null, position = string.position
+                isArray = false, sharedWithAsm = false, position = string.position
             )
             internedStringsBlock.statements.add(decl)
             decl.linkParents(internedStringsBlock)

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

@@ -607,7 +607,6 @@ private fun Prog8ANTLRParser.VardeclContext.toAst(type: VarDeclType, value: Expr
             value,
             ARRAYSIG() != null || arrayindex() != null,
             shared,
-            null,
             toPosition()
     )
 }

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

@@ -190,7 +190,6 @@ class VarDecl(val type: VarDeclType,
               var value: Expression?,
               val isArray: Boolean,
               val sharedWithAsm: Boolean,
-              val subroutineParameter: SubroutineParameter?,
               override val position: Position) : Statement(), INamedStatement {
     override lateinit var parent: Node
     var allowInitializeWithZero = true
@@ -204,7 +203,6 @@ class VarDecl(val type: VarDeclType,
             return VarDecl(VarDeclType.VAR, VarDeclOrigin.SUBROUTINEPARAM, param.type, ZeropageWish.DONTCARE, null, param.name, null,
                 isArray = false,
                 sharedWithAsm = false,
-                subroutineParameter = param,
                 position = param.position
             )
         }
@@ -215,7 +213,7 @@ class VarDecl(val type: VarDeclType,
             val declaredType = ArrayToElementTypes.getValue(arrayDt)
             val arraysize = ArrayIndex.forArray(array)
             return VarDecl(VarDeclType.VAR, VarDeclOrigin.ARRAYLITERAL, declaredType, ZeropageWish.NOT_IN_ZEROPAGE, arraysize, autoVarName, array,
-                    isArray = true, sharedWithAsm = false, subroutineParameter = null, position = array.position)
+                    isArray = true, sharedWithAsm = false, position = array.position)
         }
     }
 
@@ -262,14 +260,14 @@ class VarDecl(val type: VarDeclType,
 
     override fun copy(): VarDecl {
         val copy = VarDecl(type, origin, declaredDatatype, zeropage, arraysize?.copy(), name, value?.copy(),
-            isArray, sharedWithAsm, subroutineParameter, position)
+            isArray, sharedWithAsm, position)
         copy.allowInitializeWithZero = this.allowInitializeWithZero
         return copy
     }
 
     fun renamed(newName: String): VarDecl {
         val copy = VarDecl(type, origin, declaredDatatype, zeropage, arraysize, newName, value,
-            isArray, sharedWithAsm, subroutineParameter, position)
+            isArray, sharedWithAsm, position)
         copy.allowInitializeWithZero = this.allowInitializeWithZero
         return copy
     }
@@ -316,10 +314,8 @@ class ArrayIndex(var indexExpr: Expression,
 enum class AssignmentOrigin {
     USERCODE,
     VARINIT,
-    PARAMETERASSIGN,
     OPTIMIZER,
-    BEFOREASMGEN,
+    ASMGEN
-    ASMGEN,
 }
 
 class Assignment(var target: AssignTarget, var value: Expression, var origin: AssignmentOrigin, override val position: Position) : Statement() {

compilerAst/src/prog8/compiler/CallGraph.kt

@@ -3,7 +3,6 @@ package prog8.compiler
 import prog8.ast.Module
 import prog8.ast.Node
 import prog8.ast.Program
-import prog8.ast.base.FatalAstException
 import prog8.ast.expressions.AddressOf
 import prog8.ast.expressions.FunctionCallExpression
 import prog8.ast.expressions.IdentifierReference
@@ -12,7 +11,7 @@ import prog8.ast.walk.IAstVisitor
 import prog8.code.core.IErrorReporter
 
 
-class CallGraph(private val program: Program, private val allowMissingIdentifierTargetVarDecls: Boolean=false) : IAstVisitor {
+class CallGraph(private val program: Program) : IAstVisitor {
 
     val imports = mutableMapOf<Module, Set<Module>>().withDefault { setOf() }
     val importedBy = mutableMapOf<Module, Set<Module>>().withDefault { setOf() }
@@ -99,15 +98,8 @@ class CallGraph(private val program: Program, private val allowMissingIdentifier
 
     override fun visit(identifier: IdentifierReference) {
         val target = identifier.targetStatement(program)
-        if(allowMissingIdentifierTargetVarDecls) {
+        if(target!=null)
-            if(target!=null)
+            allIdentifiersAndTargets[identifier] = target
-                allIdentifiersAndTargets[identifier] = target
-        } else {
-            if(target==null)
-                throw FatalAstException("missing target stmt for $identifier")
-            else
-                allIdentifiersAndTargets[identifier] = target
-        }
     }
 
     override fun visit(inlineAssembly: InlineAssembly) {