Ticket #38: multi-arg-for.patch

Source/Statements.cobra

@@ -521 +521 @@
 
     var _what as Expr
     var _varNumber as int
+    var _multiArgs as List<of Expr>?        # actually contains NameExprs
 
     def init(token as IToken, varr as NameExpr, what as Expr, block as BlockStmt)
         base.init(token, varr, block)
         _what = what
-
+        
+    #multiArg assignment in for stmt
+    def init(token as IToken, varr as NameExpr, args as List<of Expr>, what as Expr, block as BlockStmt)
+        .init(token, varr, what, block)
+        _multiArgs = args
+        
     def addSubFields
         base.addSubFields
         .addField('_what', _what)
         .addField('_varNumber', _varNumber)
+        .addField('_multiArgs', _multiArgs)
 
     get what from var
     
     get varNumber from var
     
+    get multiArgs from var
+    
     def _bindImp
         _what.bindImp
         if _what.type.isDynamic
@@ -545 +554 @@
             base._bindImp  # just to pass the assertion that base._bindImp was invoked
         else
             _var = .bindVar(_varExpr)
+            if _multiArgs
+                _unpackMultiArgStmts
             base._bindImp
             _varNumber = .compiler.curBox.makeNextPrivateSerialNumber
             _block.bindImp
+        
+    # perhaps this should be pushed up to Stmt
+    def _isDict(type as IType) as bool
+        if type inherits NilableType
+            return _isDict(type.theWrappedType to passthrough)
 
+        if type.isDescendantOf(.compiler.idictionaryType)
+            return true
+        genericDict = .compiler.dictionaryOfType
+        if type.isDescendantOf(genericDict)
+            return true
+        if type inherits Box
+            if type.genericDef is genericDict
+                return true
+        genericIDict = .compiler.idictionaryOfType
+        if type.isDescendantOf(genericIDict)
+            
+            return true
+        if type inherits Box
+            if type.genericDef is genericIDict
+                return true
+        if type.isDynamic
+            return true
+        return false
+        
+    def _unpackMultiArgStmts
+        """
+        Handle expansion of statements for multiArg variables in for statements: 
+        for k,v in <dict>  becomes
+            for varExpr_uniq in <dict>
+                k = varExpr_uniq.key
+                v = varExpr_uniq.value
+        and 
+        for a,b,c in <Inumerable (of triplets in this case)> becomes
+            for varExpr_uniq in <IEnumerable>
+                a = varExpr_uniq[0]
+                b = varExpr_uniq[1]
+                c = varExpr_uniq[2]
+        with rest of block following                
+        """
+        stmts = List<of Stmt>()
+        varName = _varExpr.name # "[_varExpr.name]_[.serialNum]"
+        token = _token.copy
+        count=0
+        if _isDict(.what.type to !)
+            # assume enumerator will return KeyValue so cant have other than 2 multiargs
+            if _multiArgs.count <> 2
+                .throwError('Cannot have other than two multiarg variables in a for statement as assignment targets from a Dictionary')
+            kvRHS=[ 'key', 'value' ]
+            for id in _multiArgs
+                forVar =  IdentifierExpr(token.copy('ID', varName), varName)
+                rhsToken = token.copy('ID', kvRHS[count])
+                keyOrVal =  MemberExpr(rhsToken )
+                kvExpr = BinaryOpExpr.make(token.copy('DOT', '.'), 'DOT', forVar, keyOrVal) # forVar.{key,value}
+                assignTkn = token.copy('ASSIGN', '=')
+                #print id.toCobraSource, '=', kvExpr.toCobraSource
+                stmts.add(AssignExpr(assignTkn, assignTkn.which, id, kvExpr))  # id = forVar.{key,value}
+                count += 1
+        else # enumeration each item of which is matching count sequence
+            #TODO: ? Add check varName.count <> multArgs.count throw RTException
+            for id in _multiArgs
+                intToken = token.copy('INTEGER_LIT', '[count]')
+                intToken.value = count
+                countIntLit = IntegerLit(intToken)
+                exprs = List<of Expr>()
+                exprs.add(countIntLit)
+                forVar = IdentifierExpr(token.copy('ID', varName), varName)
+                idxExpr = IndexExpr(token.copy('LBRACKET', r'['), forVar, exprs)  # forVar[count]
+                assignTkn = token.copy('ASSIGN', '=')
+                stmts.add(AssignExpr(assignTkn, assignTkn.which, id, idxExpr))  
+                count += 1
+        _block.stmts.insertRange(0, stmts)
+    
     def inferredType as IType? is override
         assert _what.type
         return _what.type.innerType

Source/Compiler.cobra

@@ -1242 +1242 @@
     def listOfType as Class
         return _libraryClass('System.Collections.Generic.List<of>')
 
-    def idictionaryOfType as Class
-        return _libraryClass('System.Collections.Generic.IDictionary<of,>')
+    def idictionaryType as Box
+        return _libraryBox('System.Collections.IDictionary')
+        
+    def idictionaryOfType as Box
+        return _libraryBox('System.Collections.Generic.IDictionary<of,>')
 
     def dictionaryOfType as Class
         return _libraryClass('System.Collections.Generic.Dictionary<of,>')

Source/CobraParser.cobra

@@ -1990 +1990 @@
     def forStmtBeginning as Stmt
         """
         numeric    for int x = 0 up to n step 2
-        enumerable for Customer cust in customers
+        enumerable for cust as Customer in customers
+                   for k,v in dict
+                   for i,j,k in listOfThrees
         """
         token = .expect('FOR')
         varr = .nameExpr
+        if .optional('COMMA')     # forStmt multiarg    for v1,... 
+            args = .commaSepNameIds(['IN' ,'EOL'])
+            if .last.which <> 'IN'
+                .throwError("Comma separated nameId list in forStatement needs to terminate with an IN token ('in')")
+            if args.count == 0   # "for v1, in ..."  single multiarg variable 
+                .undo   # 'in' token
+                return .forStmt(token, varr)
+            else
+                args.insert(0, varr)
+                what = .expression
+                name='forEnumVar[what.serialNum]'  # will get made more unique by For Stmt 
+                nameToken = token.copy('ID', name)
+                varr =  IdentifierExpr(nameToken, name)
+                return ForEnumerableStmt(token, varr, args, what, .block)
+
+        # forStmt single variable assign - for v {in,=} ...
         peek = .peek.which
         if peek=='ASSIGN'
             return .oldNumericForStmt(token, varr)
@@ -2054 +2072 @@
         else
             # for x in stuff
             return ForEnumerableStmt(token, varr, what, .block)
-
+            
     def ifStmt as Stmt
         token = .expect('IF')
         cond = .expression
@@ -2698 +2716 @@
                     throw FallThroughException()
                 else
                     throw
-
     def multiArgAssign as Stmt
         # id, [id,]... = <expr>
         args = .commaSepIds(['ASSIGN', 'EOL'])
@@ -2745 +2762 @@
             idxExpr = IndexExpr(token.copy('LBRACKET', r'['), tmpIdn, exprs)
             stmts.add(AssignExpr(assignTkn, assignTkn.which, id , idxExpr))
             count += 1
-        #return BlockStmt(token.copy('INDENT', ''), stmts)  
-        # if prefer exception when nArgs > nRHSExprs Uncomment above line and lose lines below 
-        tryBlock = BlockStmt(token.copy('INDENT',''), stmts)        
-        catchBlocks = List<of CatchBlock>()
-        catchStmts = List<of Stmt>()
-        catchStmts.add(PassStmt(token.copy('PASS', 'pass')))
-        catchBlock = BlockStmt(token.copy('INDENT',''), catchStmts)
-        catchType = TypeIdentifier(token.copy('ID', 'IndexOutOfRangeException'))
-        catchBlocks.add(CatchBlock(token.copy('CATCH', 'catch'), catchType, catchBlock))
-        # 'IndexOutOfRangeException' for Arrays and Strings 
-        catchType = TypeIdentifier(token.copy('ID', 'ArgumentOutOfRangeException'))
-        catchBlocks.add(CatchBlock(token.copy('CATCH', 'catch'), catchType, catchBlock))
-        # 'ArgumentOutOfRangeException' for others, probably something else yet to find
-        return TryStmt(token.copy('TRY', 'try'), tryBlock, catchBlocks, nil, nil)
+        return BlockStmt(token.copy('INDENT', ''), stmts)   
 
     def callExpr as Expr
         """
@@ -2862 +2866 @@
             expectSep = true
         return exprs
         
-    def commaSepIds(terminators as IList<of String>) as List<of Expr>
+    def commaSepNameIds(terminators as IList<of String>) as List<of Expr>
+        return _commaSepLValues(terminators, true)
+
+    def  commaSepIds(terminators as IList<of String>) as List<of Expr>
+        return _commaSepLValues(terminators, false)
+            
+    def _commaSepLValues(terminators as IList<of String>, expectingNameIds as bool ) as List<of Expr>
         """
+        pickup comma sep stream of Identifiers or NameIds 
         Example source
             ... idexpr, TERMINATOR
             ... idexpr, idexpr ...  TERMINATOR
             ... idexpr, idexpr, ... TERMINATOR
         Returns
-            A list of Identifier Expressions ([DotExpr] IdentifiersExpr) 
-        Notes
-            The terminator token is consumed, but can be examined with .last.
+            A list of Identifier Expressions ([DotExpr] IdentifiersExpr) or NameIds 
         """
         expectSep = false
         sep = 'COMMA'
@@ -2887 +2896 @@
                 break
             .newOpStack
             try
-                exprs.add(.idExpression(0, nil))
+                if expectingNameIds
+                    exprs.add(.nameExpr)
+                else
+                    exprs.add(.idExpression(0,nil))
             finally
                 .delOpStack
             expectSep = true
@@ -3452 +3464 @@
             if token.which == 'DOT'
                 state=1
             else if token.which == 'ID'
-                if not (token.text[0] == '_' or Utils.startsWithLowerLetter(token.text))
-                    break
                 state = 2
             else if token.which == 'COMMA' 
                 match = state == 2 # comma after [.]ID

Tests/820-errors/300-statements/510-multi-arg-forList-fail.cobra

@@ +1 @@
+# multi arg assign in forEnum from non list of lists
+class ListTst
+    def main is shared
+        ListTst()
+        
+    def init
+        ls = [1,2,3,4,5,6]
+        for l1,l2 in ls     # .error. Cannot find an indexer
+            assert l1 in [1,3,5]
+            assert l2 in [2,4,6]

Tests/820-errors/300-statements/500-multi-arg-forDict-fail.cobra

@@ +1 @@
+class Dict
+    def main is shared
+        xdict = {0:'z', 1:'w', 3:'x'}
+        for k,v,c in xdict   # .error. other than two multiarg variables
+            pass

Tests/110-basics-two/915-multi-arg-forDict.cobra

@@ +1 @@
+# Test multivariable assignment in forEnumeration from a Dictionary
+# this is oriented towards dicts of generics since HashTable enumerator
+# type inference is NYI
+class Dict
+    def main is shared
+        d = Dict()
+        d.manualAssign
+        d.multiAssign
+        d.twoArgs
+        d.dictGen
+        d.hashTblDict
+        
+    def manualAssign
+        xdict = {0:'z', 1:'w', 3:'x'}
+        for kv in xdict
+            k = kv.key
+            v = kv.value
+            #print 'k=',k, 'v=',v
+            assert k in [0,1,3]
+            assert v in ['z', 'w', 'x']
+
+    def multiAssign
+        xdict = {0:'z', 1:'w', 3:'x'}
+        for kv in xdict
+            k,v = [kv.key, kv.value]
+            #print 'k=',k, 'v=',v
+            assert k in [0,1,3]
+            assert v in ['z', 'w', 'x']
+
+    def twoArgs
+        xdict = {0:'z', 1:'w', 3:'x'}
+        for k,v in xdict
+            #print 'k=',k, 'v=',v
+            assert k in [0,1,3]
+            assert v in ['z', 'w', 'x']
+        
+    def edgeCases
+        xdict = {0:'z', 1:'w', 3:'x'}
+        for kv, in xdict   # note trailing comma after kv
+            k,v = [kv.key, kv.value]
+            #print 'k=',k, 'v=',v
+            assert k in [0,1,3]
+            assert v in ['z', 'w', 'x']
+        
+        x1dict = {99:'zzz'}
+        for k,v in x1dict
+            pass
+        assert k == 99
+        assert v == 'zzz'
+    
+        k2=994
+        x2dict = {:}
+        for k2,v2 in x2dict
+            pass
+        assert k2 == 994
+        assert v2 == nil
+        
+    def dictGen
+        gdict = Dictionary<of String,int>()
+        gdict['a1'] = 1
+        gdict['b1'] = 2
+        gdict['c1'] = 3
+        
+        for k,v in gdict
+        #for kv in gdict
+        #   k,v = [kv.key, kv.value]
+            assert k in ['a1','b1','c1']
+            assert v in [1,2,3]
+            
+    def hashTblDict
+        gdict = Hashtable()
+        gdict['a'] = 'z'
+        gdict['b'] = 'y'
+        gdict['c'] = 'w'
+        assert gdict['a'] == 'z'
+        
+        for dev in gdict
+            de = dev to DictionaryEntry # necessary casting
+            k,v = [de.key, de.value]
+            assert k in ['a','b','c']
+            assert v in ['z','y','w']
+            
+        # this not work till HashTable enumerator type inference implemented
+/#      for k,v in gdict
+            assert k in ['a','b','c']
+            assert v in ['z','y','w']
+#/          

Tests/110-basics-two/918-multi-arg-forList.cobra

@@ +1 @@
+#multiarg assignment in a for-statement on a List
+class ListTst
+    def main is shared
+        d = ListTst()
+        d.ma1
+        d.ooRange
+        
+    def ma1
+        l2s = [[1,2],[3,4],[5,6]]
+        for l in l2s
+            l1,l2 = l
+            assert l1 in [1,3,5]
+            assert l2 in [2,4,6]
+            #print 'l1=[l1], l2=[l2]'           
+        assert l1 == 5
+        assert l2 == 6
+    
+        # existing variables
+        for l1,l2 in l2s
+            assert l1 in [1,3,5]
+            assert l2 in [2,4,6]
+        assert l1 == 5
+        assert l2 == 6
+        
+        #new variables
+        for l3,l4 in l2s
+            assert l3 in [1,3,5]
+            assert l4 in [2,4,6]
+        assert l3 == 5
+        assert l4 == 6
+    
+        for l5,l6 in [[0,1],[1,2],[2,3]]
+            assert l5 in [0,1,2]
+            assert l6 in [1,2,3]
+        assert l5 == 2
+        assert l6 == 3
+        
+    def ooRange     
+        l2s = [[1,2],[3,4],[5,6]]
+        expect ArgumentOutOfRangeException # ?? multi-arg list size mismatch?
+            for l1,l2,l3 in l2s
+                assert l1 in [1,3,5]
+                assert l2 in [2,4,6]
+                assert l3 == 0 
+    # test for assignment from a flatlist done in 800-errors/300-statements

Tests/110-basics-two/910-multi-assign.cobra

@@ -87 +87 @@
         assert s2 == 'three'
         
     def nonMatchCount
-        a, b, c = [11, 12]
+        expect ArgumentOutOfRangeException
+            a, b, c = [11, 12]
         assert a == 11
         assert b == 12
         assert c == 0  # instantiated but unassigned
-
         f, = [3, 4]
         assert f == 3
     
@@ -117 +117 @@
 
         m = ''
         c1 as Object = 'x'
-        l, m, n, c1 = @[1, 'Two', c'3']
+        expect IndexOutOfRangeException
+            l, m, n, c1 = @[1, 'Two', c'3']
         
         assert l == 1
         assert m == 'Two'
         assert n == c'3'
         assert c1 == 'x'
     
-        p, q, r = 'ab'
+        expect IndexOutOfRangeException
+            p, q, r = 'ab'
         assert p == c'a'
         assert q == c'b'
         assert r == c'\0'

Tests/110-basics-two/912-multi-assign.cobra

@@ -13 +13 @@
         ma = MultiAssign()
         ma.nonLocalVar
         ma.forIEnum
+        ma.forSwap
 
     def nonLocalVar
         _i0, _i1 = [3,4]
@@ -44 +45 @@
         a, b = for k in list get k 
         assert a == 1
         assert b == 2
+        
+    def forSwap
+        # common variable swap idiom ( python a,b = b,a)
+        a = 99
+        b = 100
+        a,b = [b,a]
+        assert a == 100
+        assert b == 99
+        

Developer/IntermediateReleaseNotes.text

@@ -13 +13 @@
 * Added support for "multi-arg assignment" which allows you to assign to a number of variables from contents of a list in one statement
 .code
     a,b,c = ['val1', 'val2', 'val3']
-
-
+Also support such assignment in for statements for (generic) Dictionaries 
+and Lists
+.code
+    for k,v in aDictionary
+        print 'key=[k]'
+    for a,b in [[1,2],[3,4]]
+        print a+b
+            
 * Added support for a new compiler directive 'args' that takes command line options and applies them to the compilation environment from that point on.
 .code
     %% args -target:lib -embed-run-time:no