Ticket #315: multiReturn.patch

Source/Members.cobra

@@ -836 +836 @@
             return _returnType to !
 
     get statements from _stmts
+    
+    #following 3 for use while parsing for methods with multiple return values
+    pro hasMultipleReturnValues from var as bool
 
+    get numReturnValues as int
+        require _returnTypeNode inherits GenericTypeIdentifier
+        rtn = _returnTypeNode to GenericTypeIdentifier
+        return rtn.numArgs
+        
+    get returnedTypes as List<of ITypeProxy>
+        """List of return types for method with multiple return values"""
+        require _returnTypeNode inherits GenericTypeIdentifier
+        rtn = _returnTypeNode to GenericTypeIdentifier
+        return rtn.typeNodes to !
+    
     def findLocal(name as String) as AbstractLocalVar?
         # TODO: should this use a dictionary lookup?
         for local in _locals, if local.name == name, return local

Source/CobraParser.cobra

@@ -1372 +1372 @@
             .throwError('Method names cannot be the same as their enclosing [curBox.englishName]. Use `cue init` for creating an initializer/constructor or choose another name.')  # TODO list the enclosing types location
 
         params = _methodParams(opener)
-        returnType = _methodReturnType
+        isMultiReturn as bool
+        returnType = _methodReturnType(out isMultiReturn)
 
         isNames = List<of String>(_isNamesStack)
         attribs = AttributeList()
@@ -1429 +1430 @@
             method = Initializer(token, opener, .curBox, params, isNames, attribs, docString) to AbstractMethod
         else
             method = Method(token, opener, .curBox, name, .makeList<of IType>(genericParams), params, returnType, implementsType, isNames, attribs, docString)
+        method.hasMultipleReturnValues = isMultiReturn  
         if nothingMore
             if method.bodyExclusion is nil, .throwError('Missing method body for "[name]".')
         else
@@ -1448 +1450 @@
             genericParams = List<of GenericParam>()
         return genericParams    
         
-    def _methodReturnType as ITypeProxy
+    def _methodReturnType(isMultiReturn as out bool) as ITypeProxy
         """ Returns declared method return type or void type if none declared. Helper for .declareMethod. """
+        isMultiReturn = false
         if .optional('AS')
-            returnType = .typeId to ITypeProxy
+            retTypes = List<of ITypeProxy>()
+            _commaSepTypes(retTypes)
+            #returnType = .typeId to ITypeProxy
+            if retTypes.count == 1
+                returnType = retTypes[0]
+            else
+                token = (retTypes[0] to AbstractTypeIdentifier).token               
+                returnType = _mkMultiReturnType(token, retTypes)
+                isMultiReturn = true
         else
             returnType = _typeProvider.voidType
         return returnType
-
+        
+    def _mkMultiReturnType(token as IToken, types as List<of ITypeProxy>) as AbstractTypeIdentifier
+        """
+        Make the (generic) container type for the ordered list of multiple return types.
+            'as int, String' becomes 'as Bag<int, String>'
+        """  
+        if types.count > 4
+            .throwError('Cannot have more than 4 return values in a method returning multiple values.')
+        rootName = 'Pair' # 'Bag'
+        fullName = rootName + '<of ' + ', '.repeat(types.count-1) + '>'
+        openGenericToken = token.copy('OPEN_GENERIC', rootName+'<of ', rootName)
+        genericBag = GenericTypeIdentifier(openGenericToken, rootName, fullName, types)
+        return genericBag
+            
     def _methodParams(opener as IToken) as List<of Param>
         """ Returns a list of declared parameters, possibly empty if there were none declared. Helper for .declareMethod. """
         unnecessary = false
@@ -2451 +2475 @@
 
     def returnStmt as Stmt
         token = .expect('RETURN')
-        expr = if(.peek.which == 'EOL', nil, .expression)
+        #expr = if(.peek.which == 'EOL', nil, .expression)
+        if .peek.which == 'EOL'
+            expr = nil
+        else if not _curCodePart.hasMultipleReturnValues
+            expr = .expression
+        else    
+            exprs = .commaSepExprs('EOL.')
+            assert .last.which=='EOL'
+            .ungrab  # need EOL
+            postCallToken = exprs[0].token.copy('LPAREN', '(', '(')
+            expr = _mkMultiReturn(postCallToken,  exprs)
         return ReturnStmt(token, expr)
+        
+    def _mkMultiReturn(postCallToken as IToken, exprs as List<of Expr>) as PostCallExpr
+        """
+        Make the container for the expressions returned for a return of multiple values.
+        Something like      return i, 'val' 
+        gets turned into    return Bag<of int,String>(i, 'val')
+        """ 
+        require _curCodePart.hasMultipleReturnValues
+        if exprs.count > 4
+            .throwError('Cannot have more than 4 return values in a multiple value return statement.')
+        if exprs.count <> _curCodePart.numReturnValues
+            .throwError('Method declared to return [_curCodePart.numReturnValues] return values but [exprs.count] given.')
 
+        returnTypes = _curCodePart.returnedTypes            
+        rootName = 'Pair' # -> 'Bag'
+        fullName = rootName + '<of ' + ', '.repeat(exprs.count-1) + '>'
+        openGenericToken = postCallToken.copy('OPEN_GENERIC', rootName+'<of ', rootName)
+        genBag = GenericTypeIdentifier(openGenericToken, rootName, fullName, returnTypes)
+        return PostCallExpr(postCallToken, TypeExpr(genBag), exprs)     
+
     def _isIndentedContract as bool
         require .peek.which.isOneOf('REQUIRE.ENSURE.OR.AND.')
         offset = 0

Source/Cobra.Core/files.text

@@ -17 +17 @@
 NumericTypes.cobra
 ObjectCatalog.cobra
 Pair.cobra
+Bag.cobra
 Set.cobra
 SourceSite.cobra
 StringMaker.cobra

Source/Cobra.Core/Bag.cobra

@@ +1 @@
+""" 
+    Bag - multivalue collection, 2, 3 and 4 items, each item fully and separately typed
+""" 
+    
+namespace Cobra.Core
+
+    class Bag<of TA, TB> inherits Pair<of TA, TB>
+        implements System.Collections.IEnumerable, IComparable<of Bag<of TA, TB>>
+        """ Bag<of,> 2 item bag - Thin wrapper around Pair<T1, T2> """
+        
+        cue init(a as TA, b as TB)
+            base.init(a, b)
+        
+        def toString as String is override
+            sa = CobraCore.toTechString(.a)
+            sb = CobraCore.toTechString(.b)
+            return 'Bag([sa], [sb])'
+
+        def equals(obj as Object?) as bool is override
+            test
+                assert Pair<of String, String>('a', 'b') == Pair<of String, String>('a', 'b')
+                assert Pair<of String, String>('a', 'b') <> Pair<of String, String>('a', 'c')
+            body
+                if obj is nil, return false
+                if not (obj to? Bag<of TA, TB>), return false # not this Type
+                if obj is this, return true
+                if obj inherits Pair<of TA, TB> 
+                    return obj.a == .a and obj.b == .b
+                return false
+                
+        def equals(b as Bag<of TA, TB>) as bool
+            # suppress through calls fm superclass so equivalent subset (type and values same) not map equal
+            # superclasses must do own independent equality checking not using base.equals
+            if b.getType <> Bag<of TA, TB>, return false
+            return base.equals(b to Pair<of TA, TB>)
+        
+        def compareTo(b as Bag<of TA, TB>) as int
+            test
+                assert Bag<of String, int>('a', 3) < Bag<of String, int>('b', 4)
+                assert Bag<of String, int>('a', 3) < Bag<of String, int>('a', 4)
+                assert Bag<of String, int>('a', 3) <= Bag<of String, int>('a', 3)
+                assert Bag<of int, int>(2, 3) > Bag<of int, int>(2, 2)
+                assert Bag<of int, int>(2, 3) >= Bag<of int, int>(2, 3)
+                assert Bag<of String, int>('a', 3).compareTo(Bag<of String, int, char>('a', 3, c'b')) == 0
+# on-hold. to-do
+#               assert Bag<of String?, String?, String?>(nil, 'a', 'a') < Bag<of String?, String?, String?>(nil, 'b', 'a')
+#               assert Bag<of String?, String?, String?>(nil, 'a', 'a') < Bag<of String?, String?, String?>(nil, 'a', 'b')
+#               assert Bag<of int?, int?, int?>(nil, nil, nil) < Bag<of int?, int?, int?>(1, 1, 1)
+            body
+                return base.compareTo(b)
+            
+            
+                
+    #           
+    # 3-Bag built on 2-Bag
+    #       
+    class Bag<of TA, TB, TC> inherits Bag<of TA, TB>
+        implements System.Collections.IEnumerable, IComparable<of Bag<of TA, TB, TC>>
+        """ Bag<of,,> - 3 item Bag - values separately typed"""
+        
+        test
+            b = Bag<of int, int, int>(1, 2, 3)
+            assert b.a == 1 and b.b == 2 and b.c == 3
+            assert b[0] == 1 and b[1] == 2 and b[2] == 3
+            assert b.toString == 'Bag(1, 2, 3)'
+            expect IndexOutOfRangeException, assert b[3] == 3
+            
+            b1 = Bag<of int, String, int>(1, 'a', 1)
+            assert b1.a == 1 and b1.b == 'a' and b1.c == 1
+            assert b1[0] == 1 and b1[1] == 'a' and b1[2] == 1
+            assert b1.toString == "Bag(1, 'a', 1)"
+            expect IndexOutOfRangeException, assert b1[3] == 3
+            
+        
+        cue init(a as TA, b as TB, c as TC )
+            base.init(a, b)
+            _c = c
+            
+        get c from var as TC
+
+        get [i as int] as dynamic? is new
+            if i == 0, return .a
+            if i == 1, return .b
+            if i == 2, return _c
+            throw IndexOutOfRangeException('Index [i] is out of range for a 3 bag (0-2).')
+        
+        def toString as String is override
+            sa = CobraCore.toTechString(.a)
+            sb = CobraCore.toTechString(.b)
+            sc = CobraCore.toTechString(.c)
+            return 'Bag([sa], [sb], [sc])'
+
+        def equals(other as Bag<of TA, TB, TC>) as bool
+            test
+                assert Bag<of String, int, char>('a', 99, c'b').equals(Bag<of String,int, char>('a', 99, c'b'))
+                assert not Bag<of String, int, char>('a', 99, c'b').equals(Bag<of String, int, char>('a', 98, c'b'))
+                assert not Bag<of String, int, char>('a', 99, c'b').equals(Bag<of String, int, char>('a', 99, c'c'))
+            body
+                if other.getType <> Bag<of TA, TB, TC>, return false # disallow superclasses
+                return other.a ==.a and other.b ==.b and other.c ==.c
+
+        def equals(obj as Object?) as bool is override
+            test
+                assert Bag<of String, String, int>('a', 'b', 1) == Bag<of String, String, int>('a', 'b', 1)
+                assert Bag<of String, String, int>('a', 'b', 1) <> Bag<of String, String, int>('a', 'c', 1)
+                assert Bag<of String, String, int>('a', 'b', 1) <> Bag<of String, String, int>('a', 'b', 2)
+                assert Bag<of String, String>('a', 'c')        <> Bag<of String, String, int>('a', 'b', 1) 
+            body
+                if obj inherits Bag<of TA, TB, TC>
+                    return .equals(obj)
+                return false
+
+        # block equals against base class instances
+        def equals(p as Pair<of TA, TB>) as bool is override
+            test
+                assert Bag<of String, String, int>('a', 'b', 1) <> Pair<of String, String>('a', 'b')
+                assert not Bag<of String, String, int>('a', 'b', 1) == Pair<of String, String>('a', 'b')
+                # this fail - probably testing into Pair rather than here
+                #assert Pair<of String, String>('a', 'b')        <> Bag<of String, String, int>('a', 'b', 1) 
+            body
+                return false
+            
+        # block equals against base class instances
+        def equals(p as Bag<of TA, TB>) as bool is override
+            test
+                assert Bag<of String, String, int>('a', 'b', 1) <> Bag<of String, String>('a', 'b')
+                assert not Bag<of String, String, int>('a', 'b', 1) == Bag<of String, String>('a', 'b')
+                assert Bag<of String, String>('a', 'b')        <> Bag<of String, String, int>('a', 'b', 1) 
+            body
+                return false
+                
+        def compareTo(b as Bag<of TA, TB, TC>) as int
+            test
+                assert Bag<of String, int, char>('a', 3, c'b') < Bag<of String, int, char>('b', 4, c'b')
+                assert Bag<of String, int, char>('a', 3, c'b') < Bag<of String, int, char>('a', 4, c'b')
+                assert Bag<of String, int, char>('a', 3, c'b') < Bag<of String, int, char>('a', 3, c'c')
+                assert Bag<of int, int, int>(2, 3, 4) > Bag<of int, int, int>(2, 2, 4)
+                assert Bag<of int, int, int>(2, 3, 4) > Bag<of int, int, int>(2, 3, 3)
+                assert Bag<of String, int, char>('a', 3, c'b').compareTo(Bag<of String, int, char>('a', 3, c'b')) == 0
+# on-hold. to-do
+#               assert Bag<of String?, String?, String?>(nil, 'a', 'a') < Bag<of String?, String?, String?>(nil, 'b', 'a')
+#               assert Bag<of String?, String?, String?>(nil, 'a', 'a') < Bag<of String?, String?, String?>(nil, 'a', 'b')
+#               assert Bag<of int?, int?, int?>(nil, nil, nil) < Bag<of int?, int?, int?>(1, 1, 1)
+            body
+                diff = base.compareTo(b)
+                if diff == 0, diff = _compare(.c, b.c)
+                return diff
+
+        def getHashCode as int is override
+            test
+                assert Bag<of int, String, int>(1, 'one', 1).getHashCode == Bag<of int, String, int>(1, 'one', 1).getHashCode 
+                assert Bag<of int, int, int>(2, 2, 2).getHashCode == Bag<of int, int, int>(2, 2, 2).getHashCode
+                assert Bag<of int, String, int>(1, 'one', 1).getHashCode <> Bag<of int, int, int>(2, 2, 2).getHashCode
+                assert Bag<of int, int, int>(2, 2, 2).getHashCode <> Bag<of int, int, int>(2, 2, 1).getHashCode
+                d = {
+                    Bag<of int, String, int>(1, 'one', 1): 'one',
+                    Bag<of int, int, int>(2, 2, 2): 'two',
+# to-do                 Bag<of dynamic, dynamic, dynamic>(nil, nil, nil): 'nil',
+                }
+
+                assert d[Bag<of int, String, int>(1, 'one', 1)] == 'one'
+                assert d[Bag<of int, int, int>(2, 2, 2)] == 'two'
+# to-do             assert d[Bag<of dynamic, dynamic, dynamic>(nil, nil, nil)] == 'nil'
+            body
+                return HashCodeUtils.combine(base.getHashCode, if(.c is nil, 0, .c.getHashCode))
+
+        def getEnumerator as System.Collections.IEnumerator is override
+            test
+                assert (for s in Bag<of String, String, String>('a', 'b', 'c') get s) == ['a', 'b', 'c']
+                assert (for s in Bag<of String, String, int>('a', 'b', 99) get s) == ['a', 'b', 99]
+            body
+                yield .a
+                yield .b
+                yield .c
+
+    #           
+    # 4-Bag built on 3-bag
+    #       
+    class Bag<of TA, TB, TC, TD> inherits Bag<of TA, TB, TC>
+        implements System.Collections.IEnumerable, IComparable<of Bag<of TA, TB, TC, TD>>
+        """ Bag<of,,,> - 4 item Bag - values separately typed"""
+        
+        test
+            b = Bag<of int, int, int, int>(1, 2, 3, 4)
+            assert b.a == 1 and b.b == 2 and b.c == 3 and b.d ==4
+            assert b[0] == 1 and b[1] == 2 and b[2] == 3 and b[3] ==4
+            assert b.toString == 'Bag(1, 2, 3, 4)'
+            expect IndexOutOfRangeException, assert b[4] == 3
+            
+            b1 = Bag<of int, String, int, String>(1, 'a', 1, 'a')
+            assert b1.a == 1 and b1.b == 'a' and b1.c == 1 and b1.d == 'a'
+            assert b1[0] == 1 and b1[1] == 'a' and b1[2] == 1 and b1[3] == 'a'
+            assert b1.toString == "Bag(1, 'a', 1, 'a')"
+            expect IndexOutOfRangeException, assert b1[4] == 3
+            
+        
+        cue init(a as TA, b as TB, c as TC, d as TD)
+            base.init(a, b, c)
+            _d = d
+            
+        get d from var as TD
+
+        get [i as int] as dynamic? is new
+            if i == 0, return .a
+            if i == 1, return .b
+            if i == 2, return .c
+            if i == 3, return _d
+            throw IndexOutOfRangeException('Index [i] is out of range for a 4 bag (0-3).')
+        
+        def toString as String is override
+            sa = CobraCore.toTechString(.a)
+            sb = CobraCore.toTechString(.b)
+            sc = CobraCore.toTechString(.c)
+            sd = CobraCore.toTechString(.d)
+            return 'Bag([sa], [sb], [sc], [sd])'
+
+        def equals(other as Bag<of TA, TB, TC, TD>) as bool
+            test
+                assert Bag<of String, int, char, int>('a', 99, c'b', 1).equals(Bag<of String,int, char, int>('a', 99, c'b', 1))
+                assert not Bag<of String, int, char, int>('a', 99, c'b', 1).equals(Bag<of String, int, char, int>('a', 98, c'b', 1))
+                assert not Bag<of String, int, char, int>('a', 99, c'b', 1).equals(Bag<of String, int, char, int>('a', 99, c'c', 1))
+                assert not Bag<of String, int, char, int>('a', 99, c'b', 1).equals(Bag<of String, int, char, int>('a', 99, c'b', 2))
+            body
+                if other.getType <> Bag<of TA, TB, TC, TD>, return false # disallow equality on superclasses
+                return other.a ==.a and other.b ==.b and other.c ==.c and other.d == .d
+
+        def equals(obj as Object?) as bool is override
+            test
+                assert Bag<of String, String, int, int>('a', 'b', 1, 1) == Bag<of String, String, int, int>('a', 'b', 1, 1)
+                assert Bag<of String, String, int, int>('a', 'b', 1, 1) <> Bag<of String, String, int, int>('a', 'c', 1, 1)
+                assert Bag<of String, String, int, int>('a', 'b', 1, 1) <> Bag<of String, String, int, int>('a', 'b', 2, 1)
+                assert Bag<of String, String, int, int>('a', 'b', 1, 1) <> Bag<of String, String, int, int>('a', 'b', 1, 2)
+                assert Bag<of String, String, int>('a', 'b', 1)  <> Bag<of String, String, int, int>('a', 'b', 1, 1) 
+            body
+                if obj inherits Bag<of TA, TB, TC, TD>
+                    return .equals(obj)
+                return false
+
+        # block equals against base class instances
+        def equals(p as Bag<of TA, TB, TC>) as bool is override
+            test
+                assert Bag<of String, String, int, int>('a', 'b', 1, 1) <> Bag<of String, String, int>('a', 'b', 1)
+                assert not Bag<of String, String, int, int>('a', 'b', 1, 1) == Bag<of String, String, int>('a', 'b', 1)
+                assert Bag<of String, String, int>('a', 'b', 1)  <> Bag<of String, String, int, int>('a', 'b', 1, 1) 
+            body
+                return false
+                
+        def compareTo(b as Bag<of TA, TB, TC, TD>) as int
+            test
+                assert Bag<of String, int, char, int>('a', 3, c'b', 1) < Bag<of String, int, char, int>('b', 4, c'b', 1)
+                assert Bag<of String, int, char, int>('a', 3, c'b', 1) < Bag<of String, int, char, int>('a', 3, c'c', 1)
+                assert Bag<of String, int, char, int>('a', 3, c'b', 1) < Bag<of String, int, char, int>('a', 3, c'b', 2)
+                assert Bag<of int, int, int, int>(2, 3, 4, 5) > Bag<of int, int, int, int>(2, 2, 4, 5)
+                assert Bag<of int, int, int, int>(2, 3, 4, 5) > Bag<of int, int, int, int>(2, 3, 3, 5)
+                assert Bag<of int, int, int, int>(2, 3, 4, 5) > Bag<of int, int, int, int>(2, 3, 4, 4)
+                assert Bag<of String, int, char, int>('a', 3, c'b', 1).compareTo(Bag<of String, int, char, int>('a', 3, c'b', 1)) == 0
+                assert Bag<of int, int, int, int>(2, 3, 4, 5).compareTo(Bag<of int, int, int, int>(2, 3, 4, 4)) > 0
+                assert Bag<of int, int, int, int>(2, 3, 4, 5).compareTo(Bag<of int, int, int, int>(2, 3, 4, 6)) <0
+# on-hold. to-do
+#               assert Bag<of String?, String?, String?>(nil, 'a', 'a') < Bag<of String?, String?, String?>(nil, 'b', 'a')
+#               assert Bag<of String?, String?, String?>(nil, 'a', 'a') < Bag<of String?, String?, String?>(nil, 'a', 'b')
+#               assert Bag<of int?, int?, int?>(nil, nil, nil) < Bag<of int?, int?, int?>(1, 1, 1)
+            body
+                diff = base.compareTo(b)
+                if diff == 0, diff = _compare(.d, b.d)
+                return diff
+
+        def getHashCode as int is override
+            test
+                assert Bag<of int, String, int, int>(1, 'one', 1, 1).getHashCode == Bag<of int, String, int, int>(1, 'one', 1, 1).getHashCode 
+                assert Bag<of int, int, int, int>(2, 2, 2, 2).getHashCode == Bag<of int, int, int, int>(2, 2, 2, 2).getHashCode
+                assert Bag<of int, String, int, int>(1, 'one', 1, 1).getHashCode <> Bag<of int, int, int, int>(2, 2, 2, 2).getHashCode
+                assert Bag<of int, int, int, int>(2, 2, 2, 2).getHashCode <> Bag<of int, int, int, int>(2, 2, 2, 1).getHashCode
+                d = {
+                    Bag<of int, String, int, int>(1, 'one', 1, 1): 'one',
+                    Bag<of int, int, int, int>(2, 2, 2, 2): 'two',
+# to-do                 Bag<of dynamic, dynamic, dynamic>(nil, nil, nil): 'nil',
+                }
+
+                assert d[Bag<of int, String, int, int>(1, 'one', 1, 1)] == 'one'
+                assert d[Bag<of int, int, int, int>(2, 2, 2, 2)] == 'two'
+# to-do             assert d[Bag<of dynamic, dynamic, dynamic>(nil, nil, nil)] == 'nil'
+            body
+                return HashCodeUtils.combine(base.getHashCode, if(.d is nil, 0, .d.getHashCode))
+
+        def getEnumerator as System.Collections.IEnumerator is override
+            test
+                assert (for s in Bag<of String, String, String, String>('a', 'b', 'c', 'd') get s) == ['a', 'b', 'c', 'd']
+                assert (for s in Bag<of String, String, int, int>('a', 'b', 99, 1) get s) == ['a', 'b', 99, 1]
+            body
+                yield .a
+                yield .b
+                yield .c
+                yield .d
+                
+                
+class BagExerciser
+    def main is shared
+        print 'Test'
+        b = Bag<of int, String, int>(1, 'xx', 1)
+        assert b.a == 1 and b.b=='xx' and b.c ==1
+        assert b.a.typeOf == Int32
+        assert b.b.typeOf == String
+        
+        d = Bag<of int, String, int, char>(1, 'xx', 1, c'a')
+        assert d.a == 1 and d.b=='xx' and d.c ==1 and d.d == c'a'
+        assert d.a.typeOf == Int32
+        assert d.b.typeOf == String
+        assert d.d.typeOf == Char
+    
+        ty = [Int32, String, Int32, Char]
+        i=0
+        for o in d
+            assert o == d[i]
+            assert o.getType == ty[i]
+            i += 1
+
+        #print b.toString
+        #print d.toString   

Tests/200-misc/450-multi-return/550-mismatch.cobra

@@ +1 @@
+class MultiRet
+    def main is shared
+        m = MultiRet()
+        a, b = m.call
+        assert a == 'hi'
+        assert err == 1
+    
+        
+    def call as int, int, int, int, int # .error. more than 4
+        err=1
+        s = 'hi'
+        return err, 1, 2, 3, 5 

Tests/200-misc/450-multi-return/560-mismatch.cobra

@@ +1 @@
+class MultiRet
+    def main is shared
+        m = MultiRet()
+        a, b = m.call
+        assert a == 'hi'
+        assert err == 1
+    
+        
+    def call as int, int
+        err=1
+        s = 'hi'
+        return err, 1, 2, 3, 5  # .error. more than 4

Tests/200-misc/450-multi-return/100-multi-return-orig.cobra

@@ +1 @@
+# can do typed multi return without syntax support using explicit Pair
+class MultiRet
+    def main is shared
+        m = MultiRet()
+        a, err = m.call
+        assert a == 'hi'
+        assert err == 1
+    
+    # works now (only for 2 vals)
+    def call as Pair<of String, int>
+        err=1
+        s = 'hi'
+        return Pair<of String, int>(s, err)
+        

Tests/200-misc/450-multi-return/200-multi-return.cobra

@@ +1 @@
+# Multireturn syntax supported
+class MultiRet
+    def main is shared
+        m = MultiRet()
+        a, err = m.call
+        assert a == 'hi'
+        assert err == 1
+    
+    def call as String, int
+        err=1
+        s = 'hi'
+        return s, err
+        

Tests/200-misc/450-multi-return/210-multi-return.cobra

@@ +1 @@
+# Multireturn syntax supported
+class MultiRet
+    def main is shared
+        m = MultiRet()
+        a, err = m.call
+        assert a == 'hi'
+        assert err == 'No Error'
+    
+    def call as String, String
+        err='No Error'
+        s = 'hi'
+        return s, err
+        

Tests/200-misc/450-multi-return/500-mismatch.cobra

@@ +1 @@
+class MultiRet
+    def main is shared
+        m = MultiRet()
+        a, err = m.call
+        assert a == 'hi'
+        assert err == 1
+    
+        
+    def call as String, int
+        err=1
+        s = 'hi'
+        return Pair<of String, int>(s, err) # .error. declared to return 2
+        

Tests/200-misc/450-multi-return/220-multi-return.cobra

@@ +1 @@
+class MultiRet
+    def main is shared
+        m = MultiRet()
+        err, a = m.call
+        assert err == 'No Error'
+        assert a.typeOf == X
+    
+    def call as String, X
+        err='No Error'
+        return err, X()
+        
+        
+class X
+    pass

Tests/200-misc/450-multi-return/510-mismatch.cobra

@@ +1 @@
+class MultiRet
+    def main is shared
+        m = MultiRet()
+        a, err = m.go
+        assert a == 'hi'
+        assert err == 1
+    
+        
+    def go as String, int
+        err=1
+        s = 'hi'
+        return  99 # .error. declared to return 2
+        

Tests/200-misc/450-multi-return/230-multi-return.cobra

@@ +1 @@
+class MultiRet
+    def main is shared
+        m = MultiRet()
+        err, a = m.call
+        assert err == 'No Error'
+        assert a.typeOf == X
+    
+    def call as String, X
+        err='No Error'
+        x = X()
+        return err, x
+        
+        
+class X
+    pass

Tests/200-misc/450-multi-return/520-mismatch.cobra

@@ +1 @@
+class MultiRet
+    def main is shared
+        m = MultiRet()
+        a, err = m.go
+        assert a == 'hi'
+        assert err == 1
+    
+        
+    def go as int
+        err=1
+        s = 'hi'
+        return  s, err1 # .error. Expecting EOL
+