Ticket #38: multiArg-assign-cleanup.patch

Source/SharpGenerator.cobra

@@ -2874 +2874 @@
             sw.write('yield return;\n')
 
 
+class MultiTargetAssignStatement
+    is partial
+
+    def writeSharpDef(sw as SharpWriter)
+        base.writeSharpDef(sw)
+        _block.writeSharpDef(sw)
+
 ##
 ## Expressions
 ##

Source/Statements.cobra

@@ -555 +555 @@
         else
             _var = .bindVar(_varExpr)
             if _multiArgs
+                _validateMultiArgs
                 _unpackMultiArgStmts
             base._bindImp
             _varNumber = .compiler.curBox.makeNextPrivateSerialNumber
             _block.bindImp
         
+    def _validateMultiArgs
+        n=0
+        for id in _multiArgs
+            if not (id inherits IdentifierExpr or id inherits AsExpr)
+                .throwError('Items in comma separated NameId list must be Identifier or Identifier-with-type expression. List item#[n]="[id.token.text]"')
+            n += 1      
+
     def _unpackMultiArgStmts
         """
         Handle expansion of statements for multiArg variables in for statements: 
@@ -1375 +1383 @@
             # TODO: can there just be "yield return"?
             pass
         curCodeMember.hasYieldStmt = true
+        
+class MultiTargetAssignStatement
+    is partial
+    inherits Stmt
+    """
+    Handle atatement of form 
+        a,b[,...] = <List>
+    Gets turned into a sequence of assignExpr.
+        a = <List>[0]
+        b = <LIst>[1]
+
+    TODO: support a,b[,...] = <Enumerable> 
+    TODO: support a,b,[,...] = c,d[,...] form
+    """
+    var _targets as List<of Expr> # Lvalues
+    var _source as Expr         # evaluate to IList/Array/String or otherwise indexable by int
+    var _block as BlockStmt?    # the rewritten/expanded code
+    
+    def init(opToken as IToken, args as List<of Expr>, rhs as Expr)
+        base.init(opToken)
+        assert opToken.which == 'ASSIGN'
+        _targets = args
+        _source = rhs
+        
+    def addSubFields
+        base.addSubFields
+        .addField('targets', _targets)
+        .addField('source', _source)
+        .addField('block', _block)
+
+    get targets from var
+
+    get source from var
+
+    get block from var
+
+    def _writeBlock
+        """
+        Construct expanded assignment block for a multi target assignment.
+        if fewer targets than exprs in _source - extra exprs (silently) ignored
+        if more targets than exprs in _source   - will emit runtime exception
+            above differ fm python - both give errors
+        Unchecked assumptions; 
+            source is int indexable (x[n]) - c# compiler pick up
+        Assignment block contains
+            lh_mt_serno = <source>
+            id0 = lh_mt_serno[0] # id0 is contents of targets[0]
+            id1 = lh_mt_serno[1] # id1 is contents of targets[1]
+                (... repeated for number of items in targets specifying ids (lvalues))
+        """
+        stmts = List<of Stmt>()
+        assignTkn = .lastToken  # the one we stored in init
+        serNo = .compiler.curBox.makeNextPrivateSerialNumber
+        tmpName = 'lh_mt_[serNo]'  # lh=local handler, mt = multiTarget
+        ttoken = .lastToken.copy('XXX', 'xxx')  # invalid template token for copying
+        idToken = ttoken.copy('ID', tmpName)
+        
+        tmpId = IdentifierExpr(idToken, idToken.text)
+        s = AssignExpr(assignTkn, assignTkn.which, tmpId, _source) 
+        stmts.add(s)  
+
+        count = 0
+        for id in _targets
+            intToken = ttoken.copy('INTEGER_LIT', '[count]')
+            intToken.value = count
+            countIntLit = IntegerLit(intToken)
+            exprs = List<of Expr>()
+            exprs.add(countIntLit)
+            tmpIdn = IdentifierExpr(ttoken.copy('ID', tmpName), tmpName)
+            idxExpr = IndexExpr(ttoken.copy('LBRACKET', r'['), tmpIdn, exprs)
+            stmts.add(AssignExpr(assignTkn, assignTkn.which, id, idxExpr))
+            count += 1
+        _block = BlockStmt(ttoken.copy('INDENT', ''), stmts)    
+        
+    #Push up to baseclass or as Utility method ?
+    #TODO: make a better test for real LValue-ness
+    def _isLValue( id as Expr) as bool
+        return (id inherits IdentifierExpr) or (id inherits DotExpr) or (id inherits IndexExpr)
+        
+    def _bindImp
+        base._bindImp
+        for id in _targets
+            if not _isLValue(id)
+                .throwError('"[id.token.text]" must be an assignable lvalue (Identifier, Member or Index Expression)')
+        #TODO: chk _source supports an int indexer ??
+        _writeBlock
+        _block.bindImp
+        

Source/CobraParser.cobra

@@ -225 +225 @@
                 .recordError(error.token, error.message)
 
         _nextTokenIndex = 0
-
-
+        
     ##
     ## Tokens
     ##
@@ -1883 +1882 @@
                 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]."')
-                    if .looksLikeMultiArgIsNext
-                        s = .multiArgAssign 
-                    else
-                        s = .expression
-                        s.afterParserRecognizesStatement
-                            
+                    s = .expression
+                    s.afterParserRecognizesStatement
+                    if .optional('COMMA')
+                        s = .multiTargetAssign(s to Expr)
         if expectEOL
             if .verbosity>=5
                 print '<> last statement start token=[token]'
@@ -1992 +1989 @@
         """
         token = .expect('FOR')
         varr = .nameExpr
-        if .optional('COMMA')     # forStmt multiarg    for v1,... 
-            args = .commaSepNameIds(['IN' ,'EOL'])
+        if .optional('COMMA')     # forStmt multiarg    for v1,... in 
+            args = .commaSepExprsPartial(['IN' ,'EOL'], 'IN')
             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 
@@ -2712 +2709 @@
                     throw FallThroughException()
                 else
                     throw
-
-    def multiArgAssign as Stmt
-        # id, [id,]... = <expr>
-        args = .commaSepIds(['ASSIGN', 'EOL'])
+ 
+    def multiTargetAssign(arg0 as Expr) as Stmt
+        # id, |[id,]... = <expr>
+        args = .commaSepExprsPartial(['ASSIGN', 'EOL'], 'ASSIGN')
+        args.insert(0, arg0)
         if .last.which <> 'ASSIGN'
             .throwError('Comma separated identifier list needs to end with an assignment ("=").')
-        assignTkn = .last
+        assignTkn = .last to !
         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)
+        return MultiTargetAssignStatement(assignTkn, args, rhs)
         
-        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)   
-
     def callExpr as Expr
         """
         Syntax:
@@ -2812 +2771 @@
         expr.argumentLabel = label
         return expr
 
+    def commaSepExprsPartial(terminators as IList<of String>, binOpBrk as String) as List<of Expr>
+        # As commaSepExprs but setup to break out of middle of binOpExpression on terminating token
+        assert _binaryOpPrec.containsKey(binOpBrk)
+        realPrec = _binaryOpPrec[binOpBrk]
+        _binaryOpPrec[binOpBrk] = -1    # reset precedence to exit expression parser when hit this op
+        try
+            exprs = .commaSepExprs(terminators)
+        finally
+            _binaryOpPrec[binOpBrk] = realPrec
+        return exprs
+            
     def commaSepExprs(terminator as String) as List<of Expr>
         return .commaSepExprs([terminator], false, false)
 
@@ -2863 +2833 @@
             expectSep = true
         return exprs
         
-    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) or NameIds 
-        """
-        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
-                if expectingNameIds
-                    exprs.add(.nameExpr)
-                else
-                    exprs.add(.idExpression(0,nil))
-            finally
-                .delOpStack
-            expectSep = true
-        return exprs
-
-    def idExpression(precedence as int, left as Expr?) as Expr
-        # 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)
-        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
@@ -3438 +3306 @@
         token = .peek(peekAhead)
         if token.which == 'ID'
             return Utils.startsNonLower(token.value to String)
-        if token.isKeyword and token.text in ['bool', 'char', 'decimal', 'int', 'uint', 'float', 'number']
-            return true
-        return false
+        return .isOneOfKeywords(token, ['bool', 'char', 'decimal', 'int', 'uint', 'float', 'number'])
 
     def looksLikeVarNameIsNext(peekAhead as int) as bool
         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'
-                state = 2
-            else if token.which == 'COMMA' 
-                match = state == 2 # comma after [.]ID
-            else
-                break
-            peekAhead += 1
-        return match
-
+        
+    def isOneOfKeywords(nToken as IToken?, keywords as List<of String>) as bool
+        token = nToken to !
+        return token.isKeyword and token.text in keywords
+        
     def recordError(msg as String) as ParserException
         return .recordError(.last, msg)
 

Tests/820-errors/300-statements/500-multi-assign.cobra

@@ +1 @@
+# compile failure cases for multiTarget assignment
+class MAssign
+    def main is shared
+        # missing list terminators (ASSIGN)
+        a,b,c == [1,2,3]    # .error. Comma separated identifier list needs to end with an assignment

Tests/320-misc-two/810-multi-assignment/110-multi-assign.cobra

@@ -9 +9 @@
     
     pro p0 from _i0
     pro p1 from _i1
-        
+
+    set [i as int]
+        branch i 
+            on 0
+                .x0 = value
+            on 1
+                .x1 = value
+            else
+                throw ArgumentOutOfRangeException('[i] out of range 0,1')
+            
     def main is shared
         ma = MultiAssign()
         ma.nonLocalVar
         ma.forIEnum
+        ma.forIndexor
         ma.forSwap
 
     def nonLocalVar
@@ -47 +57 @@
         assert a == 1
         assert b == 2
         
+    def forIndexor
+        this[0] = 'x'
+        this[1] = 'y'
+        assert .x0 == 'x'
+        assert .x1 == 'y'
+
+        this[0],this[1] = ['aa', 'bb']
+        assert .x0 == 'aa'
+        assert .x1 == 'bb'
+    
+        tx=this
+        tx[0],tx[1] = ['xa', 'xb']
+        assert .x0 == 'xa'
+        assert .x1 == 'xb'
+        
     def forSwap
         # common variable swap idiom ( python a,b = b,a)
         a = 99
@@ -54 +79 @@
         a, b = [b, a]
         assert a == 100
         assert b == 99
+        

Tests/320-misc-two/810-multi-assignment/120-multi-assign-fail.cobra

@@ +1 @@
+# test failure cases for multiTarget assignment
+class MAssign
+    def main is shared
+        # non LValues
+        a,b,c = [1,2,3] 
+        assert a == 1
+        assert b == 2
+        assert c == 3
+        
+        33,a,b = [1,2,3]    #.error. "33" must be an assignable lvalue
+        a,33,c = [1,2,3]    #.error. "33" must be an assignable lvalue
+        a,b,34 = [1,2,3]    #.error. "34" must be an assignable lvalue
+
+        'aye',b,c = [1,2,3] #.error. "'aye'" must be an assignable lvalue
+        a,'bee',c = [1,2,3] #.error. "'bee'" must be an assignable lvalue
+        a,b,"cee" = [1,2,3] #.error. ""cee"" must be an assignable lvalue
+    
+        # missing list terminators (ASSIGN)
+#       a,b,c == [1,2,3]    # .compile-error . Comma separated identifier list needs to end with an assignment

Tests/320-misc-two/810-multi-assignment/210-multi-arg-for-list-fail.cobra

@@ -4 +4 @@
 
     def main is shared
         ls = [1, 2, 3, 4, 5, 6]
+        # ls needs to be pairs i.e [[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]
+            
+        for a, 2 in [1,2]    #.error. must be Identifier or Identifier-with-type
+            pass
+            
+        for a, b, 'xx' in [1,2] #.error. must be Identifier or Identifier-with-type expression. List item#2
+            pass
+