Ticket #211: implicit-line-cont-expr2.patch

Source/CobraParser.cobra

@@ -2252 +2252 @@
 
     def ifStmt as Stmt
         token = .expect('IF')
-        cond = .expression
+        cond = _expressionMultiLinePreBlock     # was .expression
         trueStmts = .block
         falseStmts as BlockStmt?
         if .peek.which=='ELSE'
@@ -2297 +2297 @@
     def postWhileStmt as Stmt
         token = .expect('POST')
         .expect('WHILE')
-        return PostWhileStmt(token, .expression, .block)
+        return PostWhileStmt(token, _expressionMultiLinePreBlock, .block)
 
     def traceStmt as TraceStmt?
         """
@@ -2495 +2495 @@
         return UsingStmt(token, varr, initExpr, block)
 
     def whileStmt as Stmt
-        return WhileStmt(.expect('WHILE'), .expression, .block)
+        return WhileStmt(.expect('WHILE'), _expressionMultiLinePreBlock, .block)
 
     def yieldStmt as Stmt
         token = .expect('YIELD')
@@ -2708 +2708 @@
 
     var _inExpression as int
     
+    def _expressionMultiLinePreBlock as Expr
+        """
+        Special handling for expressions in some statements that may have a multiline/continued expression 
+            prior to an indented block.
+        Ensures a statement that has hanging unpaired indents/dedents from removing indents in a multiline
+            expression cleaned up and has the expected trailing EOL and INDENT after the expression.
+        """
+        cond = .expression
+        if  cond.token.lineNum <> .last.lineNum  and _spaceAgnosticIndentLevel <> 0
+            # expression is broken across multiple lines and changed indentation
+            # unwind indentation and correct indentation tokens for the expected following block
+            _spaceAgnostic
+            _spaceAgnosticIndentLevel=0
+            if .peek.which <> 'COMMA'
+                .ungrab
+                .replace(.peek.copy('INDENT'))
+                .ungrab
+                .replace(.peek.copy('EOL'))
+        return cond
+        
     def expression as Expr
         test
             assert 0 not in _binaryOpPrec.values
@@ -2787 +2807 @@
                         # support foo.bar where bar is a keyword. Ex: foo.this
                         right = MemberExpr(.grab) to Expr
                     else
-                        right = .expression(prec)
+                        right = _continuedExpression(prec, opToken to !)
                     if op == 'ASSIGN' and left inherits IdentifierExpr and (left to IdentifierExpr).name.startsWithNonLowerLetter
                         .recordError(ErrorMessages.localVariablesMustStartLowercase)
                     if op == 'DOT' and not right inherits IDotRightExpr
@@ -2923 +2943 @@
                         else
                             throw
 
+    var _implicitContinuationOps = [
+        'ASSIGN', 'AND', 'OR', 'STAR', 'SLASH', 'PLUS', 'MINUS',
+        'EQ', 'NE', 'LT', 'GT', 'LE', 'GE', 'IN', 'NOTIN',  
+        'PLUS_EQUALS', 'MINUS_EQUALS', 'STAR_EQUALS', 'SLASH_EQUALS', 'PERCENT_EQUALS', 
+        'SLASHSLASH', 'PERCENT', 'AMPERSAND', 'VERTICAL_BAR',   'CARET', 'DOUBLE_LT',   
+        'DOUBLE_GT', 'AMPERSAND_EQUALS', 'VERTICAL_BAR_EQUALS', 'CARET_EQUALS', 
+        'DOUBLE_LT_EQUALS', 'DOUBLE_GT_EQUALS', 'STARSTAR', 'STARSTAR_EQUALS' 
+    ]
+            
+    def _continuedExpression(prec as int, opToken as IToken) as Expr
+        """
+        Handle expression that may end in line with an implicit continuation character
+        Relies on _expressionMultilinePreBlock (on if, postwhile and while stmts)
+        and end of statement _finishSpaceAgnostic to handle subsequent indent/dedent cleanup
+        """
+        if .peek.which == 'EOL' and opToken.which in _implicitContinuationOps 
+            _spaceAgnostic # eat the following EOL and remove any now hanging indents
+        right = .expression(prec)
+        return right
+        
+        
     def multiTargetAssign(arg0 as Expr) as Stmt
         # id, |[id,]... = <expr>
         args = .commaSepExprsPartial('ASSIGN.EOL.', 'ASSIGN')

Tests/110-basics-two/150-line-continuation/120-implicit-line-cont-ops.cobra

@@ +1 @@
+# Test for implicit forms of line continuation: round brackets and trailing binary ops
+# ticket:211 (partially also addresses ticket 210)
+class Program
+
+    def main
+        .cond
+        .stmtExpr
+    
+    def stmtExpr
+        assert 1 + 2 == 3       # ok
+            
+        assert (1 +     # braces ok
+            2) == 3
+        assert (1 +     # braces ok
+            2) 
+        assert 1 *      # implicit trailing '*', 0 indent
+        2  == 2
+        
+        assert 1 +      # implicit trailing '+', 1 indent
+            2 == 3
+        #assert (1 +        # Ticket 210: Cannot mix tabs and spaces in indentation.
+        #      2)
+        #assert 1 +     # Both tickets.
+        #     2 == 3
+        
+        assert (1 +     # braces, double indent
+                12) == 13
+        assert 1 +      # trailing '+', double indent after
+                2 == 3
+        assert 3 -      # trailing '-', double indent after
+                2 == 1
+                
+        assert 3 *      # ((3*1) + 4) -(8/2)  # multiple lines
+            1 +
+            4 -
+            8 /
+            2 == 3
+            
+        a = 1
+        b = 2
+        assert (a == 1 and  
+            b == 2)
+        assert a == 1 and   #implicit on 'and'
+            b == 2
+        assert a == 1 or    # implicit on or
+            b == 2
+
+        #assert a == 1 and  # implicit on and and tabs+spaces
+        #      b == 2
+
+
+    def cond
+        a=99
+        b=99
+        
+        
+        # expect these two to be the most common multiline condition indentation
+        # 2nd and perhaps subsequent lines indented 1 or 2 indents
+        if  a > 98 and
+            b == 99 
+            assert true, 'OK - 1 indent'
+        else
+            assert false, 'fail'
+
+        if  a > 98 and
+                b == 99 
+            assert true, 'OK - 2 indents'
+        else
+            assert false, 'fail'
+
+        if  a > 98 and
+            b == 99 or
+            a == b
+            assert true, 'OK - 1 indent'
+        else
+            assert false, 'fail'
+            
+        if  a > 98 and
+                b == 99 or
+                a == b or
+                b > 45
+            assert true, 'OK - 2 indents'
+        else
+            assert false, 'fail'
+        
+            
+        if a > 98 and
+        b == 99     # no or matching indent - otherwise OK
+            assert true, 'OK - 0'
+        else, assert false, 'fail'
+        
+        if  a > 98 and
+                        b == 99
+            assert true, 'OK - 4 indents'
+        else
+            assert false, 'fail'
+
+            
+        if  a > 98 and  b == 99, assert true, 'OK - 2' 
+        else, assert false, 'fail'
+
+        /# TODO Fix this case
+        if  a > 98 and
+            b == 99, assert true, 'OK - 2'
+        else, assert true, 'fail'
+        #/
+        
+        # pathological back indentation
+        if  a > 98 and
+    b == 99 
+            assert true, 'OK - 1 DEDENT)'
+        else
+            assert false, 'fail'
+        
+        # non multiline 
+        if b==99 or a==99
+            assert true, 'normal'   
+            
+        if b==99 or a==99, assert true, 'normal'    
+