v1.5.5 release

lynglib/src/commonTest/kotlin/WebsiteSamplesTest.kt

@@ -104,14 +104,14 @@ class WebsiteSamplesTest {
             val name = "Lyng"
             val base = { id:, name: } // Shorthand for id: id, name: name
 
-            val full = { ...base, version: "1.5.4", status: "stable" }
+            val full = { ...base, version: "1.5.5", status: "stable" }
             full
         """.trimIndent())
         assertTrue(result is ObjMap)
         val m = result.map
         assertEquals(101L, (m[ObjString("id")] as ObjInt).value)
         assertEquals("Lyng", (m[ObjString("name")] as ObjString).value)
-        assertEquals("1.5.4", (m[ObjString("version")] as ObjString).value)
+        assertEquals("1.5.5", (m[ObjString("version")] as ObjString).value)
         assertEquals("stable", (m[ObjString("status")] as ObjString).value)
     }
 

lynglib/src/commonTest/kotlin/net/sergeych/lyng/OperatorOverloadingTest.kt

@@ -19,6 +19,8 @@ package net.sergeych.lyng
 
 import kotlinx.coroutines.test.runTest
 import kotlin.test.Test
+import kotlin.test.assertContains
+import kotlin.test.assertFailsWith
 
 class OperatorOverloadingTest {
     @Test
@@ -63,6 +65,24 @@ class OperatorOverloadingTest {
         """.trimIndent())
     }
 
+    @Test
+    fun testBuiltinListPlusAssignOnVal() = runTest {
+        eval("""
+            val list = [1, 2]
+            list += 3
+            assertEquals([1, 2, 3], list)
+        """.trimIndent())
+    }
+
+    @Test
+    fun testBuiltinListMinusAssignOnVal() = runTest {
+        eval("""
+            val list = [1, 2, 3]
+            list -= 2
+            assertEquals([1, 3], list)
+        """.trimIndent())
+    }
+
     @Test
     fun testPlusAssignFallback() = runTest {
         eval("""
@@ -76,6 +96,130 @@ class OperatorOverloadingTest {
         """.trimIndent())
     }
 
+    @Test
+    fun testPlusAssignFallbackOnValReportsReadonlyError() = runTest {
+        val ex = assertFailsWith<ScriptError> {
+            eval("""
+                class Vector(var x: Int, var y: Int) {
+                    fun plus(other: Vector) = Vector(this.x + other.x, this.y + other.y)
+                    fun equals(other: Vector) = this.x == other.x && this.y == other.y
+                }
+                val v = Vector(1, 2)
+                v += Vector(3, 4)
+            """.trimIndent())
+        }
+
+        assertContains(ex.errorMessage, "can't reassign val v")
+    }
+
+    @Test
+    fun testMinusAssignOverloadingOnVal() = runTest {
+        eval("""
+            class Counter(var n: Int) {
+                fun minusAssign(x: Int) { this.n = this.n - x }
+            }
+            val c = Counter(10)
+            c -= 3
+            assertEquals(7, c.n)
+        """.trimIndent())
+    }
+
+    @Test
+    fun testMinusAssignFallbackOnValReportsReadonlyError() = runTest {
+        val ex = assertFailsWith<ScriptError> {
+            eval("""
+                class Counter(var n: Int) {
+                    fun minus(x: Int) = Counter(this.n - x)
+                }
+                val c = Counter(10)
+                c -= 3
+            """.trimIndent())
+        }
+
+        assertContains(ex.errorMessage, "can't reassign val c")
+    }
+
+    @Test
+    fun testMulAssignOverloadingOnVal() = runTest {
+        eval("""
+            class Counter(var n: Int) {
+                fun mulAssign(x: Int) { this.n = this.n * x }
+            }
+            val c = Counter(10)
+            c *= 3
+            assertEquals(30, c.n)
+        """.trimIndent())
+    }
+
+    @Test
+    fun testMulAssignFallbackOnValReportsReadonlyError() = runTest {
+        val ex = assertFailsWith<ScriptError> {
+            eval("""
+                class Counter(var n: Int) {
+                    fun times(x: Int) = Counter(this.n * x)
+                }
+                val c = Counter(10)
+                c *= 3
+            """.trimIndent())
+        }
+
+        assertContains(ex.errorMessage, "can't reassign val c")
+    }
+
+    @Test
+    fun testDivAssignOverloadingOnVal() = runTest {
+        eval("""
+            class Counter(var n: Int) {
+                fun divAssign(x: Int) { this.n = this.n / x }
+            }
+            val c = Counter(21)
+            c /= 3
+            assertEquals(7, c.n)
+        """.trimIndent())
+    }
+
+    @Test
+    fun testDivAssignFallbackOnValReportsReadonlyError() = runTest {
+        val ex = assertFailsWith<ScriptError> {
+            eval("""
+                class Counter(var n: Int) {
+                    fun div(x: Int) = Counter(this.n / x)
+                }
+                val c = Counter(21)
+                c /= 3
+            """.trimIndent())
+        }
+
+        assertContains(ex.errorMessage, "can't reassign val c")
+    }
+
+    @Test
+    fun testModAssignOverloadingOnVal() = runTest {
+        eval("""
+            class Counter(var n: Int) {
+                fun modAssign(x: Int) { this.n = this.n % x }
+            }
+            val c = Counter(23)
+            c %= 5
+            assertEquals(3, c.n)
+        """.trimIndent())
+    }
+
+    @Test
+    fun testModAssignFallbackOnValReportsReadonlyError() = runTest {
+        val ex = assertFailsWith<ScriptError> {
+            eval("""
+                class Counter(var n: Int) {
+                    fun mod(x: Int) = Counter(this.n % x)
+                }
+                val c = Counter(23)
+                c %= 5
+            """.trimIndent())
+        }
+
+        assertContains(ex.errorMessage, "can't reassign val c")
+    }
+
     @Test
     fun testCompareOverloading() = runTest {
         eval("""