Improve type inference for default initializers and add support for assign operator methods

lynglib/src/commonTest/kotlin/TypesTest.kt

@@ -768,6 +768,33 @@ class TypesTest {
         assertTrue(e.message?.contains("extern variable value cannot have an initializer or delegate") == true)
     }
 
+    @Test
+    fun testInferenceFromDefaults() = runTest {
+        eval("""
+            fun foo(i = 42, s = "bar",r = 0.0) {
+                assert( i is Int )
+                assert( s is String )
+                assert( r is Real )
+                r.toInt()
+            }
+            class Foobar(val i = 100,val s = "42", r = 1.0) {
+                fun test(amount: Int) {
+                    assert( i is Int )
+                    assert( s is String )
+                    assert( r is Real )
+                    (r * amount).toInt()
+                }
+            }
+            foo()
+            val fb = Foobar()
+            assert(fb.i is Int)
+            assert(fb.s is String)
+            assert(fb.r is Real)
+            val n = fb.test(15)
+            assertEquals(n, 15)
+        """.trimIndent())
+    }
+
 //    @Test fun nonTrivialOperatorsTest() = runTest {
 //        val s = Script.newScope()
 //        s.eval("""

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

@@ -256,6 +256,46 @@ class OperatorOverloadingTest {
         """.trimIndent())
     }
 
+    @Test
+    fun testAssignOperatorMethodsOnValMember() = runTest {
+        eval("""
+            class Counter(var n: Int) {
+                fun plusAssign(x: Int) { n = n + x }
+                fun minusAssign(x: Int) { n = n - x }
+                fun mulAssign(x: Int) { n = n * x }
+                fun divAssign(x: Int) { n = n / x }
+                fun modAssign(x: Int) { n = n % x }
+            }
+            class Holder(val counter: Counter)
+
+            val holder = Holder(Counter(10))
+            holder.counter += 2
+            assertEquals(12, holder.counter.n)
+            holder.counter -= 3
+            assertEquals(9, holder.counter.n)
+            holder.counter *= 4
+            assertEquals(36, holder.counter.n)
+            holder.counter /= 6
+            assertEquals(6, holder.counter.n)
+            holder.counter %= 4
+            assertEquals(2, holder.counter.n)
+        """.trimIndent())
+    }
+
+    @Test
+    fun testAssignOperatorFallbackOnMutableMember() = runTest {
+        eval("""
+            class Counter(val n: Int) {
+                fun minus(x: Int) = Counter(n - x)
+            }
+            class Holder(var counter: Counter)
+
+            val holder = Holder(Counter(10))
+            holder.counter -= 3
+            assertEquals(7, holder.counter.n)
+        """.trimIndent())
+    }
+
     @Test
     fun testBuiltinListPlusAssignOnVal() = runTest {
         eval("""