Refactor Parsing/Runtime

Signed-off-by: Will Hawkins <hawkinsw@obs.cr>
2026-02-24 00:28:41 -05:00
parent f9353c683e
commit 64a0fe4255
29 changed files with 1269 additions and 974 deletions
@@ -0,0 +1,205 @@
+// p4rse, Copyright 2026, Will Hawkins
+//
+// This file is part of p4rse.
+//
+// This file is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import Common
+import P4Lang
+import SwiftTreeSitter
+import TreeSitterP4
+
+protocol ParseableEvaluatableExpression {
+  static func parse(
+    node: Node, inTree tree: MutableTree, withScopes scopes: LexicalScopes
+  ) -> Result<EvaluatableExpression?>
+}
+
+extension TypedIdentifier: ParseableEvaluatableExpression {
+  static func parse(
+    node: SwiftTreeSitter.Node, inTree tree: SwiftTreeSitter.MutableTree, withScopes scopes: LexicalScopes
+  ) -> Result<EvaluatableExpression?> {
+
+    guard
+      let parser_statement_query = try? SwiftTreeSitter.Query(
+        language: p4lang,
+        data: String(
+          "(expression (identifier) @identifier)"
+        ).data(using: String.Encoding.utf8)!)
+    else {
+      return Result.Error(Error(withMessage: "Could not compile the tree sitter query"))
+    }
+
+    let qr = parser_statement_query.execute(node: node, in: tree)
+
+    guard let result = qr.next() else {
+      return .Ok(.none)
+    }
+
+    let value_capture = result.captures(named: "identifier")
+    guard
+      case Result.Ok(let type) = scopes.lookup(
+        identifier: Identifier(name: value_capture[0].node.text!))
+    else {
+      return .Error(Error(withMessage: "Cannot find \(result.captures[0].node.text!) in scope"))
+    }
+
+    return .Ok(TypedIdentifier(name: result.captures[0].node.text!, withType: type))
+  }
+}
+
+extension P4BooleanValue: ParseableEvaluatableExpression {
+  static func parse(
+    node: SwiftTreeSitter.Node, inTree tree: SwiftTreeSitter.MutableTree, withScopes scopes: LexicalScopes
+  ) -> Result<EvaluatableExpression?> {
+
+    guard
+      let true_query = try? SwiftTreeSitter.Query(
+        language: p4lang,
+        data: String(
+          "(expression (true))"
+        ).data(using: String.Encoding.utf8)!)
+    else {
+      return Result.Error(Error(withMessage: "Could not compile the tree sitter query"))
+    }
+
+    let true_qr = true_query.execute(node: node, in: tree)
+
+    if true_qr.next() != nil {
+      return .Ok(P4BooleanValue(withValue: true))
+    }
+
+    guard
+      let false_query = try? SwiftTreeSitter.Query(
+        language: p4lang,
+        data: String(
+          "(expression (false))"
+        ).data(using: String.Encoding.utf8)!)
+    else {
+      return Result.Error(Error(withMessage: "Could not compile the tree sitter query"))
+    }
+
+    let false_qr = false_query.execute(node: node, in: tree)
+
+    if false_qr.next() != nil {
+      return .Ok(P4BooleanValue(withValue: false))
+    }
+    return .Ok(.none)
+  }
+}
+
+extension P4IntValue: ParseableEvaluatableExpression {
+  static func parse(
+    node: SwiftTreeSitter.Node, inTree tree: SwiftTreeSitter.MutableTree, withScopes scopes: LexicalScopes
+  ) -> Result<EvaluatableExpression?> {
+
+    guard
+      let integer_query = try? SwiftTreeSitter.Query(
+        language: p4lang,
+        data: String(
+          "(expression (integer) @value)"
+        ).data(using: String.Encoding.utf8)!)
+    else {
+      return Result.Error(Error(withMessage: "Could not compile the tree sitter query"))
+    }
+
+    let integer_qr = integer_query.execute(node: node, in: tree)
+
+    guard let result = integer_qr.next() else {
+      return .Ok(.none)
+    }
+
+    let value_capture = result.captures(named: "value")
+    if let parsed_int = Int(value_capture[0].node.text!) {
+      return .Ok(P4IntValue(withValue: parsed_int))
+    } else {
+      print("HERE!!")
+      return .Error(Error(withMessage: "Failed to parse integer: \(result.captures[0].node.text!)"))
+    }
+  }
+}
+
+extension P4StringValue: ParseableEvaluatableExpression {
+  static func parse(
+    node: SwiftTreeSitter.Node, inTree tree: SwiftTreeSitter.MutableTree, withScopes scopes: LexicalScopes
+  ) -> Result<EvaluatableExpression?> {
+
+    guard
+      let string_query = try? SwiftTreeSitter.Query(
+        language: p4lang,
+        data: String(
+          "(expression (string_literal) @value)"
+        ).data(using: String.Encoding.utf8)!)
+    else {
+      return Result.Error(Error(withMessage: "Could not compile the tree sitter query"))
+    }
+
+    let string_qr = string_query.execute(node: node, in: tree)
+
+    guard let result = string_qr.next() else {
+      return .Ok(.none)
+    }
+
+    return .Ok(P4StringValue(withValue: result.captures[0].node.text!))
+  }
+}
+
+struct Expression {
+  public static func Parse(
+    node: Node, inTree: MutableTree, withScopes scopes: LexicalScopes
+  ) -> Result<EvaluatableExpression> {
+    let localElementsParsers: [ParseableEvaluatableExpression.Type] = [
+      P4BooleanValue.self, P4StringValue.self, P4IntValue.self, TypedIdentifier.self,
+    ]
+
+    for le_parser in localElementsParsers {
+      if case Result.Ok(.some(let parsed)) = le_parser.parse(
+        node: node, inTree: inTree, withScopes: scopes)
+      {
+        return .Ok(parsed)
+      }
+    }
+
+    return Result.Error(Error(withMessage: "Could not parse into expression."))
+  }
+}
+
+extension ExpressionStatement: ParseableStatement {
+  public static func Parse(
+    node: Node, inTree tree: MutableTree, withScopes scopes: LexicalScopes
+  ) -> Result<(EvaluatableStatement?, LexicalScopes)> {
+    guard
+      let expression_statement_query = try? SwiftTreeSitter.Query(
+        language: p4lang,
+        data: String(
+          "(expressionStatement (expression) @expression)"
+        ).data(using: String.Encoding.utf8)!)
+    else {
+      return Result.Ok((.none, scopes))
+    }
+
+    let qr = expression_statement_query.execute(node: node, in: tree)
+    guard let query_result = qr.next() else {
+      return Result.Ok((.none, scopes))
+    }
+
+    let expression_capture = query_result.captures(named: "expression")
+    if !expression_capture.isEmpty {
+      // TODO: Actually create an ExpressionStatement
+      return Result.Ok((ExpressionStatement(), scopes))
+    }
+    return Result.Ok((.none, scopes))
+  }
+}
+
@@ -0,0 +1,387 @@
+// p4rse, Copyright 2026, Will Hawkins
+//
+// This file is part of p4rse.
+//
+// This file is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import Common
+import P4Lang
+import P4Runtime
+import SwiftTreeSitter
+import TreeSitterExtensions
+import TreeSitterP4
+
+let p4lang = Language(tree_sitter_p4())
+
+extension ParserAssignmentStatement: ParseableStatement {
+  public static func Parse(
+    node: Node, inTree tree: MutableTree, withScopes scopes: LexicalScopes
+  ) -> Result<(EvaluatableStatement?, LexicalScopes)> {
+
+    guard
+      let parser_assignment_statement_query = try? SwiftTreeSitter.Query(
+        language: p4lang,
+        data: String(
+          "(assignmentStatement (expression) @lvalue (assignment) (expression) @value)"
+        ).data(using: String.Encoding.utf8)!)
+    else {
+      return Result.Ok((.none, scopes))
+    }
+
+    let qr = parser_assignment_statement_query.execute(node: node, in: tree)
+    guard let parser_assignment_statement = qr.next() else {
+      return Result.Ok((.none, scopes))
+    }
+
+    let lvalue_capture = parser_assignment_statement.captures(named: "lvalue")
+    let rvalue_capture = parser_assignment_statement.captures(named: "value")
+
+    // There must be a type name and a variable name
+    guard !lvalue_capture.isEmpty,
+      !rvalue_capture.isEmpty,
+      let lvalue_expression_raw = lvalue_capture[0].node.text
+    else {
+      return Result.Error(
+        Error(withMessage: "Could not parse a parser assignment statement"))
+    }
+
+    let rvalue_raw = rvalue_capture[0].node
+    let maybe_parsed_rvalue = Expression.Parse(node: rvalue_raw, inTree: tree, withScopes: scopes)
+    guard case Result.Ok(let rvalue) = maybe_parsed_rvalue else {
+      return Result.Error(maybe_parsed_rvalue.error()!)
+    }
+
+    let lvalue_identifier = Identifier(name: lvalue_expression_raw)
+    guard case Result.Ok(let lvalue_type) = scopes.lookup(identifier: lvalue_identifier) else {
+      return Result.Error(
+        Error(withMessage: "Cannot assign to variable \(lvalue_identifier) not in scope"))
+    }
+
+    if rvalue.type().eq(rhs: lvalue_type) {
+      return Result.Ok(
+        (
+          ParserAssignmentStatement(
+            withLValue: TypedIdentifier(name: lvalue_expression_raw, withType: lvalue_type),
+            withValue: rvalue
+          ), scopes
+        ))
+
+    } else {
+      return Result.Error(
+        Error(
+          withMessage:
+            "Cannot assign value of type \(rvalue.type()) to \(lvalue_identifier) (with type \(lvalue_type))"
+        ))
+
+    }
+  }
+}
+
+public struct Parser {
+  public struct LocalElements {
+    static func Parse(
+      node: Node, inTree tree: MutableTree, withScope scopes: LexicalScopes
+    ) -> Result<(EvaluatableStatement, LexicalScopes)> {
+      let localElementsParsers: [ParseableStatement.Type] = [
+        VariableDeclarationStatement.self
+      ]
+
+      for local_element_parser in localElementsParsers {
+        switch local_element_parser.Parse(node: node, inTree: tree, withScopes: scopes) {
+        case Result.Ok((.some(let parsed), let parsed_updated_scopes)):
+          return Result.Ok((parsed, parsed_updated_scopes))
+        case Result.Error(let e):
+          return Result.Error(Error(withMessage: "Failed to parse local element: \(e)"))
+        default: continue
+        }
+      }
+
+      return Result.Error(
+        Error(
+          withMessage:
+            "Failed to parse any local elements from specified local elements: \(node.text!)")
+      )
+    }
+  }
+
+  public struct Statements {
+    static func Parse(
+      node: Node, inTree tree: MutableTree, withScope scopes: LexicalScopes
+    ) -> Result<(EvaluatableStatement, LexicalScopes)> {
+      let statementParsers: [ParseableStatement.Type] = [
+        ParserAssignmentStatement.self, ExpressionStatement.self,
+        VariableDeclarationStatement.self,
+      ]
+
+      // Iterate through statement parsers and give each one a chance.
+      for parser in statementParsers {
+        switch parser.Parse(node: node, inTree: tree, withScopes: scopes) {
+        case Result.Ok((.some(let parsed), let updatedLexicalScopes)):
+          return .Ok((parsed, updatedLexicalScopes))
+        case Result.Error(let e):
+          return .Error(Error(withMessage: "Failed to parse a statement element: \(e)"))
+        default: continue
+        }
+      }
+      return Result.Error(
+        Error(withMessage: "Failed to parse a statement element: \(node.text!)"))
+    }
+  }
+
+  public struct TransitionSelectExpressionCaseStatement {
+    static func Parse(
+      node: Node, inTree tree: MutableTree, withLexicalScopes scopes: LexicalScopes
+    ) -> Result<([KeysetExpression], LexicalScopes)> {
+      guard
+        let transition_selection_expression_query = try? SwiftTreeSitter.Query(
+          language: p4lang,
+          data: String(
+            "((keysetExpression (expression) @ks) (colon) (identifier) @next-state)"
+          ).data(using: String.Encoding.utf8)!)
+      else {
+        return Result.Error(Error(withMessage: "Could not compile the tree sitter query"))
+      }
+
+      let qr = transition_selection_expression_query.execute(node: node, in: tree)
+
+      var kses: [KeysetExpression] = Array()
+
+      for expression in qr {
+        let next_state_name = expression.captures[1].node.text!
+        if case .Error(let e) = Expression.Parse(
+          node: expression.captures[0].node, inTree: tree, withScopes: scopes
+        )
+        .map(block: { expression in
+          kses.append(
+            KeysetExpression(
+              withKey: expression, withNextStateName: next_state_name))
+          return .Ok(expression)
+        }) {
+          return .Error(e)
+        }
+      }
+
+      return .Ok((kses, scopes))
+    }
+  }
+
+  public struct TransitionSelectExpression {
+    static func Parse(
+      node: Node, inTree tree: MutableTree, withScope scopes: LexicalScopes
+    ) -> Result<(ParserTransitionStatement?, LexicalScopes)> {
+      guard
+        let transition_selection_expression_query = try? SwiftTreeSitter.Query(
+          language: p4lang,
+          data: String(
+            "(parserTransitionStatement (transition) (transitionSelectionExpression (selectExpression (select) (expression) @selector (selectBody) @body)))"
+          ).data(using: String.Encoding.utf8)!)
+      else {
+        return Result.Error(Error(withMessage: "Could not compile the tree sitter query"))
+      }
+
+      let qr = transition_selection_expression_query.execute(node: node, in: tree)
+
+      guard let query_result = qr.next() else {
+        return .Error(Error(withMessage: "Could not find transition select expression"))
+      }
+
+      let selector = query_result.captures(named: "selector")
+      let body = query_result.captures(named: "body")
+
+      return Expression.Parse(node: selector[0].node, inTree: tree, withScopes: scopes).map {
+        expression in
+        return
+          switch TransitionSelectExpressionCaseStatement.Parse(
+            node: body[0].node, inTree: tree, withLexicalScopes: scopes)
+        {
+        case .Ok((let kse, let newLexicalScopes)):
+          Result<(ParserTransitionStatement?, LexicalScopes)>.Ok(
+            (
+              ParserTransitionStatement(
+                withTransitionExpression: ParserTransitionSelectExpression(
+                  withSelector: expression, withKeysetExpressions: kse)), newLexicalScopes
+            ))
+        case .Error(let e): Result.Error(e)
+        }
+      }
+    }
+  }
+
+  public struct TransitionStatement {
+    static func Parse(
+      node: Node, inTree tree: MutableTree, withScope scopes: LexicalScopes
+    ) -> Result<(ParserTransitionStatement?, LexicalScopes)> {
+      guard
+        let next_state_query = try? SwiftTreeSitter.Query(
+          language: p4lang,
+          data: String(
+            "(parserTransitionStatement (transition) (transitionSelectionExpression (identifier) @next-state))"
+          ).data(using: String.Encoding.utf8)!)
+      else {
+        return Result.Error(Error(withMessage: "Could not compile the tree sitter query"))
+      }
+
+      let qr = next_state_query.execute(node: node, in: tree)
+
+      if let next_state_result = qr.next() {
+        let transition_capture = next_state_result.captures(named: "next-state")
+        return .Ok(
+          (ParserTransitionStatement(withNextState: transition_capture[0].node.text!), scopes))
+      }
+
+      return TransitionSelectExpression.Parse(node: node, inTree: tree, withScope: scopes)
+    }
+  }
+
+  public struct State {
+    static func Parse(
+      node: Node, inTree tree: MutableTree, withLexicalScopes scopes: LexicalScopes
+    ) -> Result<(ParserState, LexicalScopes)> {
+      guard
+        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)"
+          ).data(using: String.Encoding.utf8)!)
+      else {
+        return Result.Error(Error(withMessage: "Could not compile the tree sitter query"))
+      }
+
+      let qr = parser_state_query.execute(node: node, in: tree)
+
+      let parser_declaration = qr.next()!
+
+      let transition_capture = parser_declaration.captures(named: "transition")
+      let state_name_capture = parser_declaration.captures(named: "state-name")
+      let state_le_capture = parser_declaration.captures(named: "state-local-element")
+      let statements_capture = parser_declaration.captures(named: "state-statement")
+
+      var parsed_les: [EvaluatableStatement] = Array()
+      var parse_err: Error? = .none
+      var current_scopes = scopes.enter()
+
+      defer {
+        current_scopes = current_scopes.exit()
+      }
+
+      for state_le in state_le_capture {
+        state_le.node.enumerateChildren { node in
+          switch LocalElements.Parse(
+            node: node, inTree: tree, withScope: current_scopes)
+          {
+          case .Ok((let le, let le_parsed_scopes)):
+            current_scopes = le_parsed_scopes
+            parsed_les.append(le)
+          case .Error(let e):
+            parse_err = e
+          }
+        }
+      }
+
+      if let parse_err = parse_err {
+        return Result.Error(parse_err)
+      }
+
+      var parsed_s: [EvaluatableStatement] = Array()
+
+      if !statements_capture.isEmpty {
+        for statement in statements_capture {
+          statement.node.enumerateChildren { node in
+            switch Statements.Parse(
+              node: node, inTree: tree, withScope: current_scopes)
+            {
+            case .Ok((let le, let le_parsed_scopes)):
+              current_scopes = le_parsed_scopes
+              parsed_s.append(le)
+            case .Error(let e):
+              parse_err = e
+            }
+          }
+        }
+      }
+
+      if let parse_err = parse_err {
+        return Result.Error(parse_err)
+      }
+
+      print("current_scopes: \(current_scopes)")
+      // TODO: Now that scopes are involved, doing this out of order will not work!
+      guard !state_name_capture.isEmpty,
+        !transition_capture.isEmpty,
+        let parsed_state_name = state_name_capture[0].node.text
+      else {
+        return Result.Error(Error(withMessage: "Could not parse a parser declaration"))
+      }
+
+      switch TransitionStatement.Parse(
+        node: transition_capture[0].node, inTree: tree, withScope: current_scopes)
+      {
+      case .Ok((.some(let transition_statement), let current_scopes)):
+        return Result.Ok(
+          (
+            ParserState(
+              name: parsed_state_name, withLocalElements: parsed_les,
+              withStatements: parsed_s,
+              withTransition: transition_statement), current_scopes
+          ))
+      case .Error(let e): return .Error(e)
+      case .Ok((.none, _)): return .Error(Error(withMessage: "Missing transition statement"))
+      }
+
+    }
+  }
+
+  static func Parse(
+    withName name: Identifier, node: Node, inTree tree: MutableTree,
+    withLexicalScopes scopes: LexicalScopes
+  ) -> Result<(P4Lang.Parser, LexicalScopes)> {
+    guard
+      let parser_state_query = try? SwiftTreeSitter.Query(
+        language: p4lang,
+        data: String(
+          "(parserStates) @parser-states"
+        ).data(using: String.Encoding.utf8)!)
+    else {
+      return Result.Error(
+        Error(withMessage: "Could not compile the parser state tree sitter query"))
+    }
+
+    var parser = P4Lang.Parser(withName: name)
+
+    // Build a state from each one listed.
+    let qr = parser_state_query.execute(node: node, in: tree)
+    let qr_value = qr.next()!
+    let captures = qr_value.captures(named: "parser-states")
+
+    var error: Error? = .none
+
+    var parser_scopes = scopes
+
+    // TODO: Assert that there is only one.
+    captures[0].node.enumerateChildren { parser_state in
+      switch Parser.State.Parse(node: parser_state, inTree: tree, withLexicalScopes: scopes) {
+      case Result.Ok(let (state, new_parser_scopes)):
+        parser.states = parser.states.append(state: state)
+        parser_scopes = new_parser_scopes
+      case Result.Error(let e): error = e
+      }
+    }
+
+    if let error = error {
+      return .Error(error)
+    }
+
+    return Result.Ok((parser, parser_scopes))
+  }
+}
@@ -0,0 +1,75 @@
+// p4rse, Copyright 2026, Will Hawkins
+//
+// This file is part of p4rse.
+//
+// This file is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import Common
+import P4Lang
+import P4Runtime
+import SwiftTreeSitter
+import TreeSitterExtensions
+import TreeSitterP4
+
+public struct Program {
+  public static func Parse(_ source: String) -> Result<P4Lang.Program> {
+    let p = SwiftTreeSitter.Parser.init()
+
+    do {
+      try p.setLanguage(p4lang)
+    } catch {
+      return Result.Error(Error(withMessage: "Could not configure the P4 parser"))
+    }
+
+    let result = p.parse(source)
+    guard let tree = result,
+      !tree.isError(lang: p4lang),
+      !tree.containsMissing(lang: p4lang)
+    else {
+      return Result.Error(Error(withMessage: "Could not compile the P4 program"))
+    }
+
+    guard
+      let parser_declaration_query = try? SwiftTreeSitter.Query(
+        language: p4lang,
+        data: String(
+          "(parserDeclaration (parserType parser_name: (identifier) @parser-name) (parserStates) @parser-states)"
+        ).data(using: String.Encoding.utf8)!)
+    else {
+      return Result.Error(
+        Error(withMessage: "Could not compile the parser declaration tree sitter query"))
+    }
+
+    var program = P4Lang.Program()
+
+    // Set up a lexical scope for parsing.
+    var program_scope = LexicalScopes().enter()
+
+    let parser_qc = parser_declaration_query.execute(in: tree)
+
+    for parser_declaration in parser_qc {
+      switch Parser.Parse(
+        withName: Identifier(name: parser_declaration.nodes[0].text!),
+        node: parser_declaration.nodes[1], inTree: tree, withLexicalScopes: program_scope)
+      {
+      case Result.Ok((let parser, let new_program_scope)):
+        program.types.append(parser)
+        program_scope = new_program_scope
+      case Result.Error(let error): return Result.Error(error)
+      }
+    }
+
+    return Result.Ok(program)
+  }
+}
@@ -0,0 +1,37 @@
+// p4rse, Copyright 2026, Will Hawkins
+//
+// This file is part of p4rse.
+//
+// This file is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import Common
+import P4Lang
+import P4Runtime
+import SwiftTreeSitter
+import TreeSitterExtensions
+import TreeSitterP4
+
+public protocol ParseableStatement {
+  static func Parse(
+    node: Node, inTree tree: MutableTree, withScopes scopes: LexicalScopes
+  ) -> Result<(EvaluatableStatement?, LexicalScopes)>
+}
+
+public protocol ParseableValue {
+  static func ParseValue(withValue value: String) -> Result<P4Value>
+}
+
+public protocol ParseableType {
+  static func ParseType(type: String) -> Result<P4Type?>
+}
@@ -0,0 +1,86 @@
+// p4rse, Copyright 2026, Will Hawkins
+//
+// This file is part of p4rse.
+//
+// This file is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import Common
+import P4Lang
+import P4Runtime
+import SwiftTreeSitter
+import TreeSitterExtensions
+import TreeSitterP4
+
+extension VariableDeclarationStatement: ParseableStatement {
+  public static func Parse(
+    node: Node, inTree tree: MutableTree, withScopes scopes: LexicalScopes
+  ) -> Result<(EvaluatableStatement?, LexicalScopes)> {
+    guard
+      let variable_declaration_query = try? SwiftTreeSitter.Query(
+        language: p4lang,
+        data: String(
+          "(variableDeclaration (annotations)? (typeRef) @type-name variable_name: (identifier) @identifier ((assignment) (expression) @value)?)"
+        ).data(using: String.Encoding.utf8)!)
+    else {
+      return Result.Ok((.none, scopes))
+    }
+
+    let qr = variable_declaration_query.execute(node: node, in: tree)
+    guard let variable_declaration = qr.next() else {
+      return .Ok((.none, scopes))
+    }
+
+    let type_name_capture = variable_declaration.captures(named: "type-name")
+    let variable_name_capture = variable_declaration.captures(named: "identifier")
+    let value_capture = variable_declaration.captures(named: "value")
+
+    // There must be a type name and a variable name
+    guard !type_name_capture.isEmpty,
+      !variable_name_capture.isEmpty,
+      !value_capture.isEmpty,
+      let variable_name = variable_name_capture[0].node.text,
+      let type_name = type_name_capture[0].node.text
+    else {
+      return Result.Error(
+        Error(withMessage: "Could not parse a parser variable declaration statement"))
+    }
+
+    guard case .Ok(let declaration_p4_type) = Types.ParseBasicType(type: type_name) else {
+      return Result.Error(
+        Error(withMessage: "Could not parse a P4 type from \(type_name)"))
+    }
+
+    let rvalue_raw = value_capture[0].node
+    let maybe_parsed_rvalue = Expression.Parse(node: rvalue_raw, inTree: tree, withScopes: scopes)
+    guard case Result.Ok(let rvalue) = maybe_parsed_rvalue else {
+      return Result.Error(maybe_parsed_rvalue.error()!)
+    }
+
+    if rvalue.type().eq(rhs: declaration_p4_type) {
+      return Result.Ok(
+        (
+          VariableDeclarationStatement(identifier: Identifier(name: variable_name), withInitializer: rvalue),
+          scopes.declare(identifier: Identifier(name: variable_name), withValue: declaration_p4_type)
+        ))
+
+    } else {
+      return Result.Error(
+        Error(
+          withMessage:
+            "Cannot initialize \(variable_name) (with type \(declaration_p4_type)) from rvalue with type \(rvalue.type())"
+        ))
+
+    }
+  }
+}
@@ -0,0 +1,54 @@
+// p4rse, Copyright 2026, Will Hawkins
+//
+// This file is part of p4rse.
+//
+// This file is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import Common
+import P4Lang
+import P4Runtime
+import SwiftTreeSitter
+import TreeSitterExtensions
+import TreeSitterP4
+
+extension P4Boolean: ParseableType {
+  public static func ParseType(type: String) -> Common.Result<(any Common.P4Type)?> {
+    return type == "bool" ? .Ok(P4Boolean.create()) : .Ok(.none)
+  }
+}
+
+extension P4Int: ParseableType {
+  public static func ParseType(type: String) -> Common.Result<(any Common.P4Type)?> {
+    return type == "int" ? .Ok(P4Int.create()) : .Ok(.none)
+  }
+}
+
+extension P4String: ParseableType {
+  public static func ParseType(type: String) -> Common.Result<(any Common.P4Type)?> {
+    return type == "string" ? .Ok(P4String.create()) : .Ok(.none)
+  }
+}
+public struct Types {
+  static func ParseBasicType(type: String) -> Result<P4Type> {
+    let type_parsers: [ParseableType.Type] = [P4Boolean.self, P4Int.self, P4String.self]
+    for type_parser in type_parsers {
+      switch type_parser.ParseType(type: type) {
+      case .Ok(.some(let type)): return .Ok(type)
+      case .Ok(.none): continue
+      case .Error(let e): return .Error(e)
+      }
+    }
+    return Result.Error(Error(withMessage: "Type name not recognized"))
+  }
+}