Ticket #304: ticket-304-2.patch

Source/CobraParser.cobra

@@ -114 +114 @@
 
     var _spaceAgnosticIndentLevel as int
     var _spaceAgnosticExprLevel as int
-    var _isContractOnSameLine as bool
 
     var _isTraceOn as bool
 
@@ -1925 +1924 @@
             <any statement 2>
             <any statement N>
         Example source
+            require <cond 1> |
             require
                 <cond 1>
                 <cond N>
+            ensure <cond 1>  |  
             ensure
                 <cond 1>
                 <cond N>
-            test
+            [test
                 <any statement 1>
                 <any statement 2>
-                <any statement N>
+                <any statement N>]
             [body
                 <any statement 1>
                 <any statement 2>
@@ -1943 +1944 @@
             Nothing.
         Errors
             Already encountered "code" block.
-            Already encountered "test" block.
+            Missing 'body' block
         Notes
+            If have 'test' blocks or indented 'ensure' or 'require' blocks must also have 'body' code block
+            May (now) have multiple 'test' blocks'
             The caller must check whether or not statements were found and issue an error when appropriate.
             For example, interface members and abstract members cannot have any statements.
             Other members must have at least one.
@@ -1956 +1959 @@
             while .peek.which == 'EOL', .grab
             if .peek.which.isOneOf('BODY.TEST.REQUIRE.ENSURE.OR.AND.')
                 # sectional
-                # not flexible. sequence is signature, contract, test, implementation
-                _isContractOnSameLine = false
+                # not flexible. sequence is signature, contracts, tests, implementation body
+                # if have indented contract or test blocks, must also have an explicit body block
+                haveContract = haveTest = indentedContract = false
                 if .peek.which.isOneOf('REQUIRE.OR.')
+                    haveContract, indentedContract = true, _isIndentedContract
                     .requireSection(codePart)
                 if .peek.which.isOneOf('ENSURE.AND.')
+                    haveContract, indentedContract = true, _isIndentedContract
                     .ensureSection(codePart)
                 while .peek.which == 'TEST'
+                    haveTest = true 
                     .testSection(codePartContainingTest to !)
-                if .peek.which=='BODY'
+
+                bodyNeeded = not codePart.bodyExclusion     
+                detail='mandate that the body code also be indented. You need the "body" keyword with indented code following it.'      
+                if haveTest and .peek.which <> 'BODY'
+                    .throwError('Missing BODY keyword. Earlier (indented) "test" clauses [detail]')     
+                if .peek.which == 'BODY'
                     .grab
                     .indent
                     _statementsFor(codePart)
+                    .dedent
                 else
-                    if _isContractOnSameLine
+                    if haveContract 
+                        if indentedContract and bodyNeeded
+                            .throwError('Missing BODY keyword. Earlier indented contract clauses [detail]')
                         _statementsFor(codePart)
                     else
                         pass
                         # There is no body for abstract or interface members. Error checking is done elsewhere.
                         # .throwError('Expecting `body` section.')
-                if not _isContractOnSameLine
-                    .dedent
+
             else
                 # non-sectional
                 _statementsFor(codePart)
@@ -1991 +2005 @@
                     # TODO: is the toplevel statement really useful?
                     _warning('More than 100 lines of code ([codePart.statements.count] toplevel statements) in method [fullName].') 
                 #print '[fullName.padLeft(50)]\t[nLines]\t[codePart.statements.count]'
-
+                
     def _statementsFor(codePart as HasAddStmt)
         """
         Utility method for .statementsFor.
@@ -2438 +2452 @@
         expr = if(.peek.which == 'EOL', nil, .expression)
         return ReturnStmt(token, expr)
 
+    def _isIndentedContract as bool
+        require .peek.which.isOneOf('REQUIRE.ENSURE.OR.AND.')
+        ofst=0
+        if .peek(ofst).which.isOneOf('.OR.AND.'),        ofst +=1
+        if .peek(ofst).which.isOneOf('REQUIRE.ENSURE.'), ofst += 1
+        return .peek(ofst).which.isOneOf('EOL.COLON.')  # code must be indented
+        
     def requireSection(codeMember as AbstractMethod) as ContractPart
         return _requireOrEnsure(codeMember, 'OR', 'REQUIRE', RequirePart)
 
@@ -2447 +2468 @@
     def _requireOrEnsure(codeMember as AbstractMethod, connectWhich as String, mainWhich as String, theClass as Type) as ContractPart
         connectToken = .optional(connectWhich)
         mainToken = .expect(mainWhich)
-        if .peek.which.isOneOf('EOL.COLON.')
+        if .peek.which.isOneOf('EOL.COLON.')  # TODO: COLON here should throw a not-needed-warning 
             .indent
             exprs = List<of Expr>()
             while true
@@ -2463 +2484 @@
             # one expression, on the same line
             exprs = [.expression]
             .endOfLine
-            _isContractOnSameLine = true
         return theClass(connectToken, mainToken, codeMember, exprs) to ContractPart
 
     def throwStmt as Stmt

Tests/340-contracts/093-parse-tests-fail.cobra

@@ +1 @@
+# test the main the variants of contract layout - looking for parsing errors
+class ContractParsing
+            
+    # we allow this - 1 line contract, non indented or keyworded body
+    def dedent1(x as int) as char
+        require x < 3
+        return c'z'
+        
+            
+    def dedent2c(x as int) as char
+        require 
+            x < 3
+        #test
+        #   assert true
+        # indented clause after keyword no body keyword, no body code
+            
+    def main is shared      # .error. missing BODY
+        c = ContractParsing()
+        assert c.dedent1(1) == c'z'
+        assert c.dedent2c(2) == c'z'

Tests/340-contracts/095-parse-tests-fail.cobra

@@ +1 @@
+# test the main the variants of contract layout - looking for parsing errors
+class ContractParsing
+            
+    # we allow this - 1 line contract, non indented or keyworded body
+    def dedent1(x as int) as char
+        require x < 3
+        return c'z'
+        
+    def dedent4(x as int) as char
+        require x < 3
+        test
+            assert true
+        #No 'body'
+        return c'z' #.error. missing BODY
+        
+            
+    def main is shared
+        c = ContractParsing()
+        assert c.dedent1(1) == c'z'
+        assert c.dedent4(1) == c'z'

Tests/340-contracts/097-parse-tests-fail.cobra

@@ +1 @@
+# test the main the variants of contract layout - looking for parsing errors
+class ContractParsing
+            
+    # we allow this - 1 line contract, non indented or keyworded body
+    def dedent1(x as int) as char
+        require x < 3
+        return c'z'
+    
+    def dedent5(x as int) as char
+        #require x < 3
+        test
+            assert true
+        #no body/indented body code
+        return c'z' # .error. missing BODY
+        
+            
+    def main is shared
+        c = ContractParsing()
+        assert c.dedent1(1) == c'z'
+        assert c.dedent5(1) == c'z'

Tests/340-contracts/091-parse-tests-maybe.cobra

@@ +1 @@
+# test the main the variants of contract layout - looking for parsing errors
+class ContractParsing
+            
+    # we allow this - 1 line contract, non indented or keyworded body
+    def dedent1(x as int) as char
+        require x < 3
+        return c'z'
+        
+    #should we allow this even though body not necessary?
+    def dedent2a(x as int) as char
+        require x < 3
+        body    # optional body
+            return c'z'
+            
+    def main is shared
+        c = ContractParsing()
+        assert c.dedent1(1) == c'z'
+        assert c.dedent2a(2) == c'z'

Tests/340-contracts/092-parse-tests-fail.cobra

@@ +1 @@
+# test the main the variants of contract layout - looking for parsing errors
+class ContractParsing
+            
+    # we allow this - 1 line contract, non indented or keyworded body
+    def dedent1(x as int) as char
+        require x < 3
+        c = c'z'
+        return c
+        
+
+    def dedent2a(x as int) as char
+        require 
+            x < 3
+        #test
+        #   assert true
+        # indented contract clause keyword, no body keyword 
+        return c'z' #.error. Missing BODY
+        
+            
+    def main is shared
+        c = ContractParsing()
+        assert c.dedent1(1) == c'z'
+        assert c.dedent2a(2) == c'z'

Tests/340-contracts/090-parse-test.cobra

@@ +1 @@
+# test the main variants of contract layout - these should be all OK
+class ContractParsing
+    # this was the failure case
+    def dedentError(x as int) as char
+        require x < 3
+        test
+            assert true
+        body
+            return c'z'
+    # to here
+        
+    # contract and test clauses
+    def dedent1(x as int) as char
+        require 
+            x < 3
+        test
+            assert true
+        body
+            return c'z'
+
+    # 1 stmt contract and unindented body only      
+    def dedent2(x as int) as char
+        require x < 3
+        #test
+        #   assert true
+        return c'z'
+
+    #should we allow this even though body not necessary?
+    def dedent2a(x as int) as char
+        require x < 3
+        body  
+            return c'z'
+            
+    # no test clause
+    def dedent3(x as int) as char
+        require 
+            x < 3
+        #test
+        #   assert true
+        # indented contract clause must also have keyword and indented body
+        body
+            return c'z'
+            
+    def dedent3a(x as int) as char
+        require 
+            x < 3
+        body
+            return c'z'
+
+        
+    # no contract
+    def dedent4(x as int) as char
+        #require x < 3
+        test
+            assert true
+        body
+            return c'z'
+        
+    def dedent4a(x as int) as char
+        test
+            assert true
+        body
+            return c'z'
+            
+    # stmt(s) only - none of contract/test or body
+    def noDedent(x as int) as char
+        return c'z'
+        
+    def main is shared
+        c = ContractParsing()
+        assert c.dedentError(1) == c'z'
+        assert c.dedent1(1)  == c'z'
+        assert c.dedent2(1)  == c'z'
+        assert c.dedent2a(1)  == c'z'
+        assert c.dedent3(2)  == c'z'
+        assert c.dedent3a(2) == c'z'
+        assert c.dedent4(1)  == c'z'
+        assert c.dedent4a(1) == c'z'
+        assert c.noDedent(1) == c'z'

Tests/340-contracts/094-parse-tests-fail.cobra

@@ +1 @@
+# test the main the variants of contract layout - looking for parsing errors
+class ContractParsing
+            
+    # we allow this - 1 line contract, non indented or keyworded body
+    def dedent1(x as int) as char
+        require x < 3
+        return c'z'
+        
+        
+    def dedent3a(x as int) as char
+        require 
+            x < 3
+        test
+            assert true
+        #no 'body'
+        return c'z' #.error. missing BODY
+        
+            
+    def main is shared
+        c = ContractParsing()
+        assert c.dedent1(1) == c'z'
+        assert c.dedent3a(2) == c'z'

Tests/340-contracts/096-parse-tests-fail.cobra

@@ +1 @@
+# test the main the variants of contract layout - looking for parsing errors
+class ContractParsing
+            
+    # we allow this - 1 line contract, non indented or keyworded body
+    def dedent1(x as int) as char
+        require x < 3
+        return c'z'
+        
+        
+    def dedent4a(x as int) as char
+        require 
+            x < 3
+        test
+            assert true
+        #no body
+        return c'z' #.error. missing BODY
+        
+            
+    def main is shared
+        c = ContractParsing()
+        assert c.dedent1(1) == c'z'
+        assert c.dedent4a(2) == c'z'