Ticket #86: tryCatchExpr.patch

Source/Expr.cobra

@@ -1107 +1107 @@
         return if(_what.type inherits AnyIntType, _what.type, _what.type.innerType)
 
 
+class TryCatchExpr inherits Expr is partial
+    """
+    Like try/catch statement but returns the value of the try-ed expression or a default expression on Exception
+    Limited to a single expression in both try and get clauses
+    
+    Currently restricted to use only when it is the target of an assignment.
+    """
+    var _what as Expr
+    var _typeNode as ITypeProxy?
+    var _excType as IType?
+    var _getExpr as Expr
+
+    cue init(token as IToken, what as Expr, excTypeNode as ITypeProxy?, getExpr as Expr)
+        base.init(token)
+        _what = what
+        _typeNode = excTypeNode
+        _getExpr = getExpr
+
+    def addSubFields
+        base.addSubFields
+        .addField('what', _what)
+        .addField('typeNode', _typeNode)
+        .addField('getExpr', _getExpr)
+
+    get what from _what
+    get typeNode from _typeNode
+    get getExpr from _getExpr
+    
+    def _bindImp
+        # TODO revisit this when move from being based on .Net 2 or cobra supports (anon) method type inference
+        if not _superNode inherits BinaryOpExpr or .binarySuperNode.op <> 'ASSIGN'
+            msg = 'More complicated expressions cannot have code generated without side effects.'
+            .throwError('Can only use a tryCatch expression as the simple target of an assignment (e.g "ID = try EXPR catch EXCEPTION get EXPR". [msg]')
+
+        base._bindImp
+        _what.bindImp  
+        if _typeNode
+            _typeNode.bindImp
+            _excType = _typeNode.realType 
+            _excType.bindAll
+
+        _getExpr.bindImp
+        _type = _getExpr.type to !
+    
 class IdentifierExpr
     is partial
     inherits NameExpr

Source/BackEndClr/SharpGenerator.cobra

@@ -3314 +3314 @@
             sw.dedent
             sw.write('})')
 
+            
+class TryCatchExpr  is partial
+    def writeSharpDef(sw as CurlyWriter, parens as bool) is override
+        # codegen below is specific to tryCatch as target of an assignment
+        assert _superNode inherits BinaryOpExpr and  .binarySuperNode.op == 'ASSIGN'
+        sw.write('{')
+        sw.write(_type.sharpRef)
+        sw.write(' r; try { r = ')
+        .what.writeSharpDef(sw, false)
+        sw.write(';} catch ')
+        if _excType
+            sw.write('(')
+            sw.write(_excType.sharpRef)
+            sw.write(') ')
+        sw.write('{ r =')
+        _getExpr.writeSharpDef(sw, false)   
+        sw.write('; } ')
+        lhs = .binarySuperNode.left
+        lhs.writeSharpDef(sw, false)    
+        sw.write(' = r; }')
+    
+        # later try this again for an arbitrarily embedded expr using a generated closure and 
+        # some method type inference and auto sig lookup/generation.        
 
 class IdentifierExpr
     is partial
@@ -4144 +4167 @@
 class AssignExpr is partial
 
     def _writeSharpDef(sw as CurlyWriter) is override
+        # special case handling/trap for tryCatch within assignment
+        if _right inherits TryCatchExpr # expand trycatch and do assignment within the expansion
+            _right.writeSharpDef(sw)    
+            return  
+            
         .writeSharpDefWithRight(sw, true)
 
     def writeSharpDefWithRight(sw as CurlyWriter, right as bool)

Source/CobraParser.cobra

@@ -2939 +2942 @@
                 return .ifExpr
             on 'FOR'
                 return .forExpr
+            on 'TRY'
+                return .tryCatchExpr
             on 'OPEN_CALL'
                 return .callExpr
             on 'OPEN_GENERIC'
@@ -3178 +3183 @@
             getExpr = .expression
         return ForExpr(token, nameExpr, what, stopExpr, stepExpr, whereExpr, getExpr)
 
+    def tryCatchExpr as TryCatchExpr
+        """
+        t = try ...  catch FormatException get 0 
+        grammar: try EXPR catch [<EXCEPTIONTYPE>] get EXPR
+        """
+        token = .expect('TRY')
+        what = .expression
+        .expect('CATCH')
+        if .peek.which <> 'GET'
+            excType = .typeId
+        .expect('GET')
+        getExpr = .expression
+        return TryCatchExpr(token, what, excType, getExpr)
+        
     def identifierExpr as Expr
         """
         Can return an IdentifierExpr or an AsExpr if the user says "i as int", for example.

Source/BackEndJvm/JavaGenerator.cobra

@@ -2721 +2721 @@
     # TODO
     pass
 
+class TryCatchExpr  is partial
+    def writeJavaDef(sw as CurlyWriter, parens as bool) is override
+        # codegen below is specific to tryCatch as target of an assignment
+        assert _superNode inherits BinaryOpExpr and  .binarySuperNode.op == 'ASSIGN'
+        sw.write('{')
+        sw.write(_type.javaRef)
+        sw.write(' r; try { r = ')
+        .what.writeJavaDef(sw, false)
+        sw.write(';} catch ')
+        if _excType
+            sw.write('(')
+            sw.write(_excType.javaRef)
+            sw.write(') ')
+        sw.write('{ r =')
+        _getExpr.writeJavaDef(sw, false)    
+        sw.write('; } ')
+        lhs = .binarySuperNode.left
+        lhs.writeJavaDef(sw, false) 
+        sw.write(' = r; }')
+    
+        # with java8 try this again for any arbitrarily embedded trycatch expr by generating a closure and 
+        # immediately executing of it - otherwise some method type inference and auto sig lookup/generation.        
 
+
 class IdentifierExpr is partial
 
     def writeJavaDef(sw as CurlyWriter, parens as bool) is override
@@ -3306 +3329 @@
     var isJavaSetProperty = false
     
     def _writeJavaDef(sw as CurlyWriter) is override
+        # special case handling/trap for tryCatch within assignment
+        if _right inherits TryCatchExpr # expand trycatch and do assignment within the expansion
+            _right.writeJavaDef(sw) 
+            return  
+
         # TODO:
         # if trackLocal:
         #   out.write('CobraLangInternal.CobraImp.SetLocal("%s", ' % .left.name)

Tests/200-misc/270-try-catch-expr-restrict.cobra

@@ +1 @@
+# Fail because not simple assignment to tryCatch expr
+class TryExpr
+    def main is shared
+        
+        x = 0
+        x = 4 + try int.parse('123') catch FormatException get 0 - 2  # .error.  target of an assignment
+        CobraCore.noOp(x)

Tests/200-misc/270-try-catch-expr.cobra

@@ +1 @@
+class TryExpr
+    def main is shared
+        
+        x = 0
+        x = try int.parse('123') catch FormatException get 0
+        assert x == 123
+    
+        val ='11213'
+        x = try int.parse(val) catch FormatException get 0
+        assert x == 11213
+    
+        val1 ='foo'
+        x = try int.parse(val1) catch FormatException get 0
+        assert x == 0
+        
+        
+        

Tests/200-misc/271-try-catch-expr.cobra

@@ +1 @@
+class TryExpr
+    var val as int
+    
+    def main
+        
+        x = 0
+        x = try int.parse('123') catch get 0
+        assert x == 123
+
+        # type inference
+        y = try int.parse('x123') catch get 0
+        assert y ==  0
+    
+        # get expr not literal
+        x = 666
+        y = try int.parse('123') catch get x
+        assert y == 123
+        
+        y = try int.parse('123x') catch get x-6
+        assert y == 660
+
+        x = try int.parse(nil) catch get 0
+        assert x == 0
+        
+        x = try int.parse(nil) catch ArgumentNullException get 0
+        assert x == 0
+        
+        expect ArgumentNullException
+            x = try int.parse(nil) catch FormatException get 0
+            
+            
+        .val = try int.parse('9909') catch get 0
+        assert .val ==  9909
+        
+        te2  = TryExpr()
+        assert te2.val == 0
+        te2.val = try int.parse('100') catch get 0
+        assert te2.val == 100
+        
+        
+        dflt = '---'
+        s0 = try String.format('{0:P}', 0.123) catch get dflt
+        assert s0 == '12.30 %'
+        s1 = try String.format('{1:P}', 0.123) catch FormatException get dflt
+        assert s1 == dflt
+        
+        s1 = try String.format('{1:XP}', 0.123) catch FormatException get dflt
+        assert s1 == dflt
+