Semicolon Cleanup

1. Semicolons were required in the wrong spot.
2. Make semicolons "invisible" (from the tree-sitter perspective).

Signed-off-by: Will Hawkins <hawkinsw@obs.cr>

Sources/P4Parser/Expression.swift

@@ -168,14 +168,16 @@ struct Expression {
     ]
 
     for le_parser in localElementsParsers {
-      if case Result.Ok(.some(let parsed)) = le_parser.parse(
+      switch le_parser.parse(
         node: node, inTree: inTree, withScopes: scopes)
       {
-        return .Ok(parsed)
+      case .Ok(.some(let parsed)): return .Ok(parsed)
+      case .Error(let e): return .Error(e)
+      default: continue
       }
     }
 
-    return Result.Error(Error(withMessage: "Could not parse into expression."))
+    return Result.Error(Error(withMessage: "\(node.range): Could not parse into expression"))
   }
 }
 

Sources/P4Parser/Parser.swift

@@ -212,26 +212,27 @@ public struct Parser {
       }
       let body_node = body[0].node
       var kses: [KeysetExpression] = Array()
-      for childidx in 0..<body_node.childCount {
-
-        if !childidx.isMultiple(of: 2) {
-          let maybe_semicolon = body_node.child(at: childidx)!
-          if maybe_semicolon.nodeType != "semicolon" {
-            return .Error(Error(withMessage: "Expected a semicolon but saw \(maybe_semicolon)"))
-          }
-          continue
-        }
+      var kses_errors: [Error] = Array()
 
+      body_node.enumerateNamedChildren { current_node in
         let maybe_parsed_kse = TransitionSelectExpressionCaseStatement.Parse(
-          node: body_node.child(at: childidx)!, inTree: tree, withLexicalScopes: scopes)
+          node: current_node, inTree: tree, withLexicalScopes: scopes)
         if case .Ok((let parsed_kse, _)) = maybe_parsed_kse {
           kses.append(parsed_kse)
         } else {
-          return .Error(
-            Error(withMessage: "Error when parsing select case: \(maybe_parsed_kse.error()!)"))
+          kses_errors.append(Error(withMessage: "\(maybe_parsed_kse.error()!)"))
         }
       }
 
+      if !kses_errors.isEmpty {
+        return .Error(
+          Error(
+            withMessage: "Error(s) parsing select cases: "
+              + (kses_errors.map { error in
+                return "\(error.msg)"
+              }.joined(separator: ";\n"))))
+      }
+
       return .Ok(
         (
           ParserTransitionSelectExpression(withSelector: selector, withKeysetExpressions: kses),
@@ -288,7 +289,7 @@ public struct Parser {
         let parser_state_query = try? SwiftTreeSitter.Query(
           language: p4lang,
           data: String(
-            "(parserState (state) (identifier) @state-name (parserLocalElements ((parserLocalElement) @state-local-element (semicolon))*)* (parserStatements ((parserStatement) @state-statement (semicolon))*)* (parserTransitionStatement) @transition)"
+            "(parserState (state) (identifier) @state-name (parserLocalElements ((parserLocalElement) @state-local-element)*)? (parserStatements ((parserStatement) @state-statement)*)? (parserTransitionStatement) @transition)"
           ).data(using: String.Encoding.utf8)!)
       else {
         return Result.Error(Error(withMessage: "Could not compile the tree sitter query"))
@@ -312,7 +313,7 @@ public struct Parser {
       }
 
       for state_le in state_le_capture {
-        state_le.node.enumerateChildren { node in
+        state_le.node.enumerateNamedChildren { node in
           switch LocalElements.Parse(
             node: node, inTree: tree, withScope: current_scopes)
           {
@@ -333,7 +334,7 @@ public struct Parser {
 
       if !statements_capture.isEmpty {
         for statement in statements_capture {
-          statement.node.enumerateChildren { node in
+          statement.node.enumerateNamedChildren { node in
             switch Statements.Parse(
               node: node, inTree: tree, withScope: current_scopes)
             {

Sources/P4Parser/Statement.swift

@@ -32,7 +32,7 @@ extension BlockStatement: ParseableStatement {
       let block_statement_query = try? SwiftTreeSitter.Query(
         language: p4lang,
         data: String(
-          "(statement . (blockStatement . (statements . ((statement) @astatement (semicolon))*) @statements) @block-statement) @statement"
+          "(statement . (blockStatement . (statements . ((statement) @astatement)*) @statements) @block-statement) @statement"
         ).data(using: String.Encoding.utf8)!)
     else {
       return Result.Ok((.none, scopes))
@@ -55,6 +55,7 @@ extension BlockStatement: ParseableStatement {
     let statement_node = statement_capture[0].node
     let blockstatement_capture_node = blockstatement_capture[0].node
     let statements_capture_node = statements_capture[0].node
+
     /*
         if statement_node.parent != node.parent
         {

Sources/TreeSitterExtensions/Extensions.swift

@@ -53,3 +53,15 @@ extension MutableTree {
     return false
   }
 }
+
+extension Node {
+  public func enumerateNamedChildren(block: (Node) -> Void) {
+    for childIdx in 0..<self.childCount {
+      let child = self.child(at: childIdx)!
+      if !child.isNamed {
+        continue
+      }
+      block(child)
+    }
+  }
+}