refs #22 @35m 2 shorter forms for catch block, fixed catch class instance type checks

docs/tutorial.md

@@ -778,7 +778,32 @@ Very much like in Kotlin. Try block returns its body block result, if no excepti
     assertEquals( "OK", result)
     >>> void
 
-It is possible to catch several exceptions in the same block (TBD)
+There is shorter form of catch block when you want to catch any exception:
+
+    var caught = null
+    try {
+        throw IllegalArgumentException()
+    }
+    catch(t) { // same as catch(t: Exception), but simpler
+        caught = t
+    }
+    assert( caught is IllegalArgumentException )
+    >>> void
+
+And even shortest, for the Lying lang tradition, missing var is `it`:
+
+    var caught = null
+    try {
+        throw IllegalArgumentException()
+    }
+    catch { // same as catch(it: Exception), but simpler
+        caught = it
+    }
+    assert( caught is IllegalArgumentException )
+    >>> void
+
+It is possible to catch several exceptions in the same block too, use 
+`catch( varName: ExceptionClass1, ExceptionClass2)`, etc.
 
 
 # Self-assignments in expression

library/src/commonMain/kotlin/net/sergeych/lyng/Compiler.kt

@@ -744,13 +744,15 @@ class Compiler(
         cc.skipTokens(Token.Type.NEWLINE)
         var t = cc.next()
         while( t.value == "catch" ) {
-            ensureLparen(cc)
+
+            if (cc.skipTokenOfType(Token.Type.LPAREN, isOptional = true)) {
                 t = cc.next()
                 if (t.type != Token.Type.ID) throw ScriptError(t.pos, "expected catch variable")
                 val catchVar = t
-            cc.skipTokenOfType(Token.Type.COLON)
+
-            // load list of exception classes
                 val exClassNames = mutableListOf<String>()
+                if (cc.skipTokenOfType(Token.Type.COLON, isOptional = true)) {
+                    // load list of exception classes
                     do {
                         t = cc.next()
                         if (t.type != Token.Type.ID)
@@ -761,16 +763,30 @@ class Compiler(
                             Token.Type.COMMA -> {
                                 continue
                             }
+
                             Token.Type.RPAREN -> {
                                 break
                             }
+
                             else -> throw ScriptError(t.pos, "syntax error: expected ',' or ')'")
                         }
                     } while (true)
+                } else {
+                    // no type!
+                    exClassNames += "Exception"
+                    cc.skipTokenOfType(Token.Type.RPAREN)
+                }
                 val block = parseBlock(cc)
                 catches += CatchBlockData(catchVar, exClassNames, block)
                 cc.skipTokens(Token.Type.NEWLINE)
                 t = cc.next()
+            } else {
+                // no (e: Exception) block: should be shortest variant `catch { ... }`
+                cc.skipTokenOfType(Token.Type.LBRACE, "expected catch(...) or catch { ... } here")
+                catches += CatchBlockData(Token("it", cc.currentPos(), Token.Type.ID), listOf("Exception"),
+                    parseBlock(cc,true))
+                t = cc.next()
+            }
         }
         if( catches.isEmpty() )
             throw ScriptError(cc.currentPos(), "try block must have at least one catch clause")
@@ -802,7 +818,7 @@ class Compiler(
                             ?: raiseSymbolNotFound("error clas not exists: $exceptionClassName")
                         println("exObj: $exObj")
                         println("objException: ${objException.objClass}")
-                        if( objException.objClass == exObj )
+                        if( objException.isInstanceOf(exObj) )
                             exceptionObject = objException
                             break
                     }

library/src/commonTest/kotlin/ScriptTest.kt

@@ -1753,12 +1753,7 @@ class ScriptTest {
     fun testThrowExisting()= runTest {
         eval("""
             val x = IllegalArgumentException("test")
-            println("instance class",x::class)
-            println("instance", x)
-            println("Exception object",Exception)
-            println("... and it's class",Exception::class)
             assert( x is Exception )
-            println(x)
 
             var t = 0
             var finallyCaught = false
@@ -1780,4 +1775,42 @@ class ScriptTest {
             assert(finallyCaught)
         """.trimIndent())
     }
+
+    @Test
+    fun testCatchShort1()= runTest {
+        eval("""
+            val x = IllegalArgumentException("test")
+            var t = 0
+            var finallyCaught = false
+            try {
+                t = 1
+                throw x
+                t = 2
+            }
+            catch(e) {
+                t = 31
+            }
+            finally {
+                finallyCaught = true
+            }
+            assertEquals(31, t)
+            assert(finallyCaught)
+        """.trimIndent())
+    }
+
+    @Test
+    fun testCatchShort2()= runTest {
+        eval("""
+            val x = IllegalArgumentException("test")
+            var caught = null
+            try {
+                throw x
+            }
+            catch {
+                caught = it
+            }
+            assert( caught is IllegalArgumentException )
+        """.trimIndent())
+    }
+
 }