From d9e13201dddded99f90f12ccaa2b1af648486125 Mon Sep 17 00:00:00 2001
From: Irmen de Jong <irmen@razorvine.net>
Date: Fri, 26 May 2023 19:14:19 +0200
Subject: [PATCH 1/2] fix kotlin version IDE warning

---
 .idea/kotlinc.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.idea/kotlinc.xml b/.idea/kotlinc.xml
index bd5867845..ee8249b2b 100644
--- a/.idea/kotlinc.xml
+++ b/.idea/kotlinc.xml
@@ -4,6 +4,6 @@
     <option name="jvmTarget" value="11" />
   </component>
   <component name="KotlinJpsPluginSettings">
-    <option name="version" value="1.8.20-release-327" />
+    <option name="version" value="1.8.21-release-380" />
   </component>
 </project>
\ No newline at end of file

From 0eb2d437e2e89f331a180575004d8386119403fe Mon Sep 17 00:00:00 2001
From: Irmen de Jong <irmen@razorvine.net>
Date: Sun, 28 May 2023 12:10:56 +0200
Subject: [PATCH 2/2] fix compiler error and codegen fault on signed value
 bitwise operation

---
 .../src/prog8/optimizer/UnusedCodeRemover.kt  |  6 ++++
 .../compiler/astprocessing/AstChecker.kt      | 11 +++++--
 .../astprocessing/BeforeAsmAstChanger.kt      |  5 +++
 .../compiler/astprocessing/TypecastsAdder.kt  | 26 +++++++++++----
 examples/test.p8                              | 32 +++++++++++++------
 5 files changed, 62 insertions(+), 18 deletions(-)

diff --git a/codeOptimizers/src/prog8/optimizer/UnusedCodeRemover.kt b/codeOptimizers/src/prog8/optimizer/UnusedCodeRemover.kt
index d42dadf84..10c301681 100644
--- a/codeOptimizers/src/prog8/optimizer/UnusedCodeRemover.kt
+++ b/codeOptimizers/src/prog8/optimizer/UnusedCodeRemover.kt
@@ -157,6 +157,12 @@ class UnusedCodeRemover(private val program: Program,
         return noModifications
     }
 
+    override fun after(assignment: Assignment, parent: Node): Iterable<IAstModification> {
+        if(assignment.target isSameAs assignment.value)
+            return listOf(IAstModification.Remove(assignment, parent as IStatementContainer))
+        return noModifications
+    }
+
     private fun deduplicateAssignments(statements: List<Statement>, scope: IStatementContainer): List<IAstModification> {
         // removes 'duplicate' assignments that assign the same target directly after another, unless it is a function call
         val linesToRemove = mutableListOf<Assignment>()
diff --git a/compiler/src/prog8/compiler/astprocessing/AstChecker.kt b/compiler/src/prog8/compiler/astprocessing/AstChecker.kt
index 9d01593a9..82d754505 100644
--- a/compiler/src/prog8/compiler/astprocessing/AstChecker.kt
+++ b/compiler/src/prog8/compiler/astprocessing/AstChecker.kt
@@ -480,7 +480,9 @@ internal class AstChecker(private val program: Program,
                         errors.err("target datatype is unknown", assignment.target.position)
                     // otherwise, another error about missing symbol is already reported.
                 } else {
-                    errors.err("type of value $valueDt doesn't match target $targetDt", assignment.value.position)
+                    // allow bitwise operations on different types as long as the size is the same
+                    if (!((assignment.value as? BinaryExpression)?.operator in BitwiseOperators && targetDt.isBytes && valueDt.isBytes || targetDt.isWords && valueDt.isWords))
+                        errors.err("type of value $valueDt doesn't match target $targetDt", assignment.value.position)
                 }
             }
         }
@@ -1607,8 +1609,11 @@ internal class AstChecker(private val program: Program,
         else if(sourceDatatype== DataType.FLOAT && targetDatatype in IntegerDatatypes)
             errors.err("cannot assign float to ${targetDatatype.name.lowercase()}; possible loss of precision. Suggestion: round the value or revert to integer arithmetic", position)
         else {
-            if(targetDatatype!=DataType.UWORD && sourceDatatype !in PassByReferenceDatatypes)
-                errors.err("type of value $sourceDatatype doesn't match target $targetDatatype", position)
+            if(targetDatatype!=DataType.UWORD && sourceDatatype !in PassByReferenceDatatypes) {
+                // allow bitwise operations on different types as long as the size is the same
+                if (!((sourceValue as? BinaryExpression)?.operator in BitwiseOperators && targetDatatype.equalsSize(sourceDatatype)))
+                    errors.err("type of value $sourceDatatype doesn't match target $targetDatatype", position)
+            }
         }
 
         return false
diff --git a/compiler/src/prog8/compiler/astprocessing/BeforeAsmAstChanger.kt b/compiler/src/prog8/compiler/astprocessing/BeforeAsmAstChanger.kt
index e1a986b40..d4369edce 100644
--- a/compiler/src/prog8/compiler/astprocessing/BeforeAsmAstChanger.kt
+++ b/compiler/src/prog8/compiler/astprocessing/BeforeAsmAstChanger.kt
@@ -93,6 +93,11 @@ internal class BeforeAsmAstChanger(val program: Program,
                             )
                         }
                     } else {
+                        if(binExpr.left isSameAs assignment.target)
+                            return noModifications
+                        val typeCast = binExpr.left as? TypecastExpression
+                        if(typeCast!=null && typeCast.expression isSameAs assignment.target)
+                            return noModifications
                         val sourceDt = binExpr.left.inferType(program).getOrElse { throw AssemblyError("unknown dt") }
                         val (_, left) = binExpr.left.typecastTo(assignment.target.inferType(program).getOrElse { throw AssemblyError(
                             "unknown dt"
diff --git a/compiler/src/prog8/compiler/astprocessing/TypecastsAdder.kt b/compiler/src/prog8/compiler/astprocessing/TypecastsAdder.kt
index af6f6c8e7..3e5f2dd2d 100644
--- a/compiler/src/prog8/compiler/astprocessing/TypecastsAdder.kt
+++ b/compiler/src/prog8/compiler/astprocessing/TypecastsAdder.kt
@@ -133,9 +133,16 @@ class TypecastsAdder(val program: Program, val options: CompilationOptions, val
                         return listOf(IAstModification.ReplaceNode(expr.left, cast, expr))
                     }
                     if(leftDt istype DataType.WORD && rightDt.oneOf(DataType.UBYTE, DataType.UWORD)) {
-                        // cast left to unsigned
-                        val cast = TypecastExpression(expr.left, rightDt.getOr(DataType.UNDEFINED), true, expr.left.position)
-                        return listOf(IAstModification.ReplaceNode(expr.left, cast, expr))
+                        // cast left to unsigned word. Cast right to unsigned word if it is ubyte
+                        val mods = mutableListOf<IAstModification>()
+                        val cast = TypecastExpression(expr.left, DataType.UWORD, true, expr.left.position)
+                        mods += IAstModification.ReplaceNode(expr.left, cast, expr)
+                        if(rightDt istype DataType.UBYTE) {
+                            mods += IAstModification.ReplaceNode(expr.right,
+                                TypecastExpression(expr.right, DataType.UWORD, true, expr.right.position),
+                                expr)
+                        }
+                        return mods
                     }
                     if(rightDt istype DataType.BYTE && leftDt.oneOf(DataType.UBYTE, DataType.UWORD)) {
                         // cast right to unsigned
@@ -143,9 +150,16 @@ class TypecastsAdder(val program: Program, val options: CompilationOptions, val
                         return listOf(IAstModification.ReplaceNode(expr.right, cast, expr))
                     }
                     if(rightDt istype DataType.WORD && leftDt.oneOf(DataType.UBYTE, DataType.UWORD)) {
-                        // cast right to unsigned
-                        val cast = TypecastExpression(expr.right, leftDt.getOr(DataType.UNDEFINED), true, expr.right.position)
-                        return listOf(IAstModification.ReplaceNode(expr.right, cast, expr))
+                        // cast right to unsigned word. Cast left to unsigned word if it is ubyte
+                        val mods = mutableListOf<IAstModification>()
+                        val cast = TypecastExpression(expr.right, DataType.UWORD, true, expr.right.position)
+                        mods += IAstModification.ReplaceNode(expr.right, cast, expr)
+                        if(leftDt istype DataType.UBYTE) {
+                            mods += IAstModification.ReplaceNode(expr.left,
+                                TypecastExpression(expr.left, DataType.UWORD, true, expr.left.position),
+                                expr)
+                        }
+                        return mods
                     }
                 }
 
diff --git a/examples/test.p8 b/examples/test.p8
index 474a0deaa..d1bea1db7 100644
--- a/examples/test.p8
+++ b/examples/test.p8
@@ -4,18 +4,32 @@
 main {
 
     sub start() {
+        ubyte ub = 123
+        byte bb = -100
+        uword uw = 12345
+        word ww = -12345
 
-        uword table = memory("table", 100, 0)
+        ub |= 63    ; vm/c64 ok (127)
+        bb |= 63    ; vm/c64 ok (-65)
+        uw |= 63    ; vm/c64 ok (12351)
+        ww |= 63    ; vm/c64 ok (-12289)
 
-        ubyte pos
-        for pos in 0 to 7 {
-            pokew(table + 64 + pos*2, ($000a-pos)*200)
-        }
+        txt.print_ub(ub)
+        txt.spc()
+        txt.print_b(bb)
+        txt.spc()
+        txt.print_uw(uw)
+        txt.spc()
+        txt.print_w(ww)
+        txt.nl()
 
-        for pos in 0 to 7 {
-            txt.print_uw(peekw(table+64+pos*2))
-            txt.nl()
-        }
+        uw |= 16384  ; vm/c64 ok (28735)
+        ww |= 8192   ; vm/c64 ok (-4097)
+
+        txt.print_uw(uw)
+        txt.spc()
+        txt.print_w(ww)
+        txt.nl()
     }
 }