Ticket #38: multi-arg-assign.patch

Source/CobraParser.cobra

@@ -1665 +1665 @@
         type as ITypeProxy?
         if .peek.which == 'AS'
             .grab
+            # code below expresses an undocumented dependency and ordering
+            # allows only    VARI <type>  or  {OUT,INOUT} <type>
+            # i.e cant have VARI and {OUT,INOUT}, if have VARI or OUT,INOUT must specify type
             branch .peek.which
                 on 'VARI'
                     type = VariTypeIdentifier(.grab, .typeId)
@@ -1842 +1845 @@
                 else
                     if .looksLikeType(0) and .looksLikeVarNameIsNext(1)
                         .throwError('The correct local variable syntax is "name as Type" or "name = initValue". Try "[.peek(1).text] as [.peek(0).text]."')
-                    s = .expression
-                    s.afterParserRecognizesStatement
+                    if .looksLikeMultiArgIsNext
+                        s = .multiArgAssign 
+                    else
+                        s = .expression
+                        s.afterParserRecognizesStatement
+                            
         if expectEOL
             if .verbosity>=5
                 print '<> last statement start token=[token]'
@@ -2650 +2657 @@
                 else
                     throw
 
+    # id, [id,]... = <expr>
+    def multiArgAssign as Stmt
+        args = .commaSepIds(['ASSIGN', 'EOL'])
+        if .last.which <> 'ASSIGN'
+            .throwError("Comma separated multiArg identifier list needs to end with an assignment ('=')")
+        assignTkn = .last
+        rhs = .expression
+        return .multiArgBlock(assignTkn, args, rhs)
+    
+    def multiArgBlock(assignTkn as IToken?, args as List<of Expr>, rhs as Expr) as Stmt
+        """
+        Construct expanded assignment block for a multi arg assignment.
+        if less args than exprs in rhs - extra exprs (silently) ignored
+        if more args than exprs in rhs  - additional args are (silently) ignored (not changed)
+            above differ fm python - both give errors
+        Unchecked assumptions; 
+            rhs is indexable (x[n] == IList) - c# compiler pick up
+        Assignment block contains
+            try
+                tmpId = <rhsExpr>
+                id0 = tmpId[0] # id is contents of args[0]
+                id1 = tmpId[1] # id is contents of args[0]
+                    (... repeated for number of items in args specifying ids)
+            catch ArgumentOutOfRangeException
+                pass    
+        """
+        stmts = List<of Stmt>()
+        tmpName = 'lh_ma_[rhs.serialNum]'
+        token = assignTkn.copy('XXX', 'xxx')  # invalid token template for copying
+        idToken = token.copy('ID', tmpName)
+        
+        tmpId = IdentifierExpr(idToken, idToken.text)
+        s = AssignExpr(assignTkn, assignTkn.which, tmpId, rhs) 
+        stmts.add(s)  
+
+        count=0
+        for id in args
+            intToken = token.copy('INTEGER_LIT', '[count]')
+            intToken.value = count
+            countIntLit = IntegerLit(intToken)
+            exprs = List<of Expr>()
+            exprs.add(countIntLit)
+            tmpIdn = IdentifierExpr(token.copy('ID', tmpName), tmpName)
+            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)
+        
     def callExpr as Expr
         """
         Syntax:
@@ -2751 +2819 @@
                 .delOpStack
             expectSep = true
         return exprs
+        
+    def commaSepIds(terminators as IList<of String>) as List<of Expr>
+        """
+        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.
+        """
+        expectSep = false
+        sep = 'COMMA'
+        exprs = List<of Expr>()
+        while true
+            if .peek.which in terminators
+                .grab
+                break
+            if expectSep
+                .expect(sep)
+            if .peek.which in terminators
+                .grab
+                break
+            .newOpStack
+            try
+                exprs.add(.idExpression(0,nil))
+            finally
+                .delOpStack
+            expectSep = true
+        return exprs
 
+    # Expression tree walker for Identifier or DotExpr Identifier Stream 
+    # This method and next are simplified versions of expression and expression2
+    # this code has to deal with scanning for tokens fo an expression that may be an identifier 
+    # (and to stop on anything else)
+    def idExpression(precedence as int, left as Expr?) as Expr
+        if left is nil
+            left = .idExpression2
+        while true
+            peek = .peek.which
+            # get precedence (and detect non-binary operators)
+            binaryOpPrec = Utils.getSI(_binaryOpPrec, peek, -1)
+            if peek <> 'DOT'    # DOT is the only binary op allowed in Id stream
+                break   
+
+            opToken = .grab
+            op = opToken.which
+            assert _binaryOpPrec.containsKey(op)
+            _leftStack.push(left to !)
+            .opStack.push(op)
+            try
+                # get the right hand side of a binary operator expression
+                prec = if(OperatorSpecs.rightAssoc.containsKey(op), binaryOpPrec, binaryOpPrec+1)
+                if op == 'DOT' and .peek and .peek.isKeyword
+                    # support foo.bar where bar is a keyword. Ex: foo.this
+                    right = MemberExpr(.grab) to Expr
+                else
+                    right = .idExpression(prec, nil)
+                    left = DotExpr(opToken, op, left, right, false)
+            finally
+                .opStack.pop
+                _leftStack.pop
+        assert left
+        return left to !
+        
+    def idExpression2 as Expr
+        peekToken = .peek
+        peek = peekToken.which
+        if peek=='DOT'      # leading dot
+            token = .grab
+            .opStack.push('DOT')
+            try
+                peekToken = .peek
+                peek = peekToken.which
+                if peek=='ID' or peekToken.isKeyword
+                    memberToken = .idOrKeyword
+                    expr = MemberExpr(memberToken) to Expr
+                else
+                    .throwError('Syntax error after "." Expecting variable Id ')
+            finally
+                .opStack.pop
+            return BinaryOpExpr.make(token to !, 'DOT', ThisLit(token), expr)
+        else if peek=='ID'
+            return .identifierExpr
+        else if .opStack.count and .opStack.peek=='DOT' and .peek.isKeyword
+            return .identifierExpr
+            
+        msg = 'Expecting an Id expression.'
+        if peekToken.isKeyword
+            msg += ' "[peekToken.text]" is a reserved keyword that is not expected here.'
+        .throwError(msg)
+        assert false
+        return ThisLit(token)  # To shut c# compiler up re paths without return values - notreached
+        
     def forExpr as ForExpr
         """
         t = for x in stuff where x<0 get x*x
@@ -3233 +3395 @@
         token = .peek(peekAhead)
         return token is not nil and token.which=='ID' and Utils.startsWithLowerLetter(token.text)
 
+    def looksLikeMultiArgIsNext as bool
+        """
+        peek ahead for ID (local or instance variable) COMMA or 
+        {DOT, ID}... (memberVar) COMMA
+        """
+        state = 0
+        peekAhead =0
+        match = false
+        while not match
+            token = .peek(peekAhead)
+            if token is nil
+                break
+            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
+            else
+                break
+            peekAhead += 1
+        return match
+
     def recordError(msg as String) as ParserException
         return .recordError(.last, msg)
 

Source/SharpGenerator.cobra

@@ -2275 +2275 @@
             _ifInheritsVar.ifInheritsStack.pop
         if close
             sw.dedent
-            sw.write('}\n')
+            sw.write(' }\n')
 
 
 class BreakStmt

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

@@ +1 @@
+#
+class MultiAssign
+    var _i0 as int
+    var _i1 as int
+
+    var x0 as String =''
+    var x1 as String =''
+    
+    pro p0 from _i0
+    pro p1 from _i1
+        
+    def main is shared
+        ma=MultiAssign()
+        ma.nonLocalVar
+        ma.forIEnum
+
+    def nonLocalVar
+        _i0,_i1 = [3,4]
+        assert _i0 == 3
+        assert _i1 == 4
+        
+        .x0,.x1 = ['03','04']
+        assert .x0 == '03'
+        assert .x1 == '04'
+    
+        .x0,.x1 = .methRetList
+        assert .x0 == 'a'
+        assert .x1 == 'b'
+        
+        s = this
+        s.x0,s.x1 = ['031','041']
+        assert .x0 == '031'
+        assert .x1 == '041'
+    
+        .p0,.p1 = [910, 911]
+        assert .p0 == 910
+        assert .p1 == 911
+        
+    def methRetList as List<of String>
+        return ['a', 'b', 'c', 'd','e']
+        
+    def forIEnum
+        lst = [1,2,3,4]
+        a,b = for k in lst get k 
+        assert a == 1
+        assert b == 2
+        

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

@@ +1 @@
+# Tests for multiarg assignment from list, array and method to local vars
+class MultiAssign
+    
+    def main is shared
+        ma=MultiAssign()
+        
+        ma.array    
+        ma.list
+        ma.dict
+        ma.nonMatchCount
+
+    def array
+        a,b = @[1,2]  
+        assert a==1
+        assert b==2
+    
+        c,d,x = @['1','2','3']
+        assert c=='1'
+        assert d=='2'
+        assert x=='3'
+        
+        e,f,g = @[1, 'Two', c'3']
+        assert e ==1
+        assert f == 'Two'
+        assert g == c'3'
+        
+    def dict
+        # sorta interesting - resolves to a normal lookup by 0-offset 
+        # numeric key in order of given variables....
+        #x = {0:'a', 1:'b'}
+        #print x[0]
+
+        c,d,e = {0:'a', 1:'b', 2:'c', 3:'d'}
+        assert c == 'a'
+        assert d == 'b'
+        assert e == 'c'
+        # but if theres a key missing in the range -> KeyNotFoundException
+        
+        xdict = {0:'z', 1:'w', 3:'x'}
+        #for k in xdict.keys 
+        #   print k
+        #for v in xdict.values
+        #   print v
+        keysColl = for k in xdict.keys get k 
+        #print keysColl
+        f,g = keysColl
+        assert f==0
+        assert g==1
+        valsColl = for v in xdict.values get v 
+        h,i = valsColl
+        assert h == 'z'
+        assert i == 'w'
+        #print valsColl
+
+        
+    def list
+        a,b = [1,2]  
+        assert a==1
+        assert b==2
+
+        d,e = .func3  
+        assert d=='a'
+        assert e=='b'
+        
+        # {:-)}
+        d1,d2 = .funcStr1
+        assert d1 == c'e'
+        assert d2 == c'h'
+        
+        ll = [21,22]
+        f,g = ll   
+        assert f==21
+        assert g==22
+
+        ii,s = [99, 'STR']
+        assert ii == 99
+        assert ii.getType is Int32
+        assert s == 'STR'
+    
+        ls = List<of String>()
+        ls.add("one")
+        ls.add("two")
+        ls.add( "three")
+        s0,s1,s2 = ls
+        assert s0=='one'
+        assert s1=='two'
+        assert s2=='three'
+        
+    def nonMatchCount
+        a,b,c = [11,12]
+        assert a==11
+        assert b==12
+        assert c==0  # instantiated but unassigned
+
+        f, = [3,4]
+        assert f==3
+    
+        ls = List<of String>()
+        ls.add("one")
+        ls.add("two")
+        ls.add( "three")
+        s0,s1 = ls
+        assert s0=='one'
+        assert s1=='two'
+    
+        g,h = @['1','2','3']
+        assert g=='1'
+        assert h=='2'
+    
+        cd,dd = {0:'a', 1:'b', 3:'c'}
+        assert cd == 'a'
+        assert dd == 'b'
+        
+        l,m = @[1, 'Two', c'3']
+        assert l ==1
+        assert m == 'Two'
+
+        m=''
+        c1 as Object = 'x'
+        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'
+        assert p == c'a'
+        assert q == c'b'
+        assert r == c'\0'
+        
+    def func3 as List<of String> is shared
+        return ['a', 'b', 'c', 'd','e']
+        
+    def funcStr1 as String is shared
+        return 'eh?'
+
+        

Developer/IntermediateReleaseNotes.text

@@ -1 +1 @@
 Post 0.8
-
+* 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']
+    
 * Added support for "extended initializers" which allow you to set properties of the object in the same call being used to create the object:
 .code
     r = Rectangle(p1=Point(x=0, y=1), p2=Point(x=2, y=3))