Make Formatter Happy

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

Sources/Common/DataTypes.swift

@@ -775,3 +775,71 @@ public class P4SetDefaultValue: P4DataValue {
     "Default of P4Set of \(self.type()) type"
   }
 }
+
+public struct P4HitMiss: P4DataType {
+  public func eq(rhs: any P4DataType) -> Bool {
+    return switch rhs {
+    case is P4HitMiss: true
+    default: false
+    }
+  }
+
+  public func def() -> any P4DataValue {
+    return P4TableHitMissValue.Miss
+  }
+
+  public var description: String {
+    return "HitMiss"
+  }
+}
+
+public enum P4TableHitMissValue: P4DataValue, Equatable, Comparable, CustomStringConvertible {
+  public func type() -> any P4DataType {
+    return P4HitMiss()
+  }
+
+  public func eq(rhs: any P4DataValue) -> Bool {
+    return switch rhs {
+    case let hmrhs as P4TableHitMissValue: hmrhs == self
+    default: false
+    }
+  }
+
+  public func lt(rhs: any P4DataValue) -> Bool {
+    return switch rhs {
+    case let hmrhs as P4TableHitMissValue: self < hmrhs
+    default: false
+    }
+  }
+
+  public func lte(rhs: any P4DataValue) -> Bool {
+    return switch rhs {
+    case let hmrhs as P4TableHitMissValue: self <= hmrhs
+    default: false
+    }
+  }
+
+  public func gt(rhs: any P4DataValue) -> Bool {
+    return switch rhs {
+    case let hmrhs as P4TableHitMissValue: self > hmrhs
+    default: false
+    }
+  }
+
+  public func gte(rhs: any P4DataValue) -> Bool {
+    return switch rhs {
+    case let hmrhs as P4TableHitMissValue: self >= hmrhs
+    default: false
+    }
+  }
+
+  case Hit
+  case Miss
+
+  public var description: String {
+    return switch self {
+    case P4TableHitMissValue.Hit: "Hit"
+    case P4TableHitMissValue.Miss: "Miss"
+    }
+  }
+}

Sources/P4Compiler/Declarations.swift

@@ -691,7 +691,6 @@ extension TableKeys: Compilable {
     walker.next()  // 3
 
     var current_node: Node? = .none
-    var current_context = context
 
     #MustOr(
       result: current_node, thing: walker.getNext(),
@@ -700,28 +699,24 @@ extension TableKeys: Compilable {
           node: node, withError: "Missing table keys declaration component in control declaration"))
     )
 
-    var entries: [TableKeyEntry] = Array()
+    let (keys, errors) = walker.try_map(n: node.childCount - 1, onlyNamed: true) { current_node in
-    var errors: [Error] = Array()
+      return switch TableKeyEntry.Compile(node: current_node, withContext: context) {
-
+      case .Ok((let keyset_expression, _)): .Ok(keyset_expression)
-    current_node!.enumerateNamedChildren { entry in
+      case .Error(let e): .Error(e)
-      switch TableKeyEntry.Compile(node: current_node!, withContext: current_context) {
-      case .Ok((let keyset_expression, let updated_context)):
-        entries.append(keyset_expression)
-        current_context = updated_context
-      case .Error(let e): errors.append(e)
       }
     }
 
     if !errors.isEmpty {
       return .Error(
-        Error(
+        ErrorOnNode(
-          withMessage: "Error(s) parsing table key: "
+          node: node,
+          withError: "Error(s) parsing table key: "
             + (errors.map { error in
               return "\(error.msg)"
             }.joined(separator: ";"))))
     }
 
-    return .Ok((TableKeys(withEntries: entries), current_context))
+    return .Ok((TableKeys(withEntries: keys), context))
   }
 }
 
@@ -747,10 +742,12 @@ extension TableActionsProperty: Compilable {
       result: current_node, thing: walker.getNext(),
       or: Result<(TableActionsProperty, CompilerContext)>.Error(
         ErrorOnNode(
-          node: node, withError: "Missing table actions declaration component in control declaration"))
+          node: node,
+          withError: "Missing table actions declaration component in control declaration"))
     )
 
-    let (actions, errors) = walker.try_map(n: node.childCount - 1, onlyNamed: true) { current_node in
+    let (actions, errors) = walker.try_map(n: node.childCount - 1, onlyNamed: true) {
+      current_node in
       switch Identifier.Compile(node: current_node, withContext: context) {
       case .Ok(let listed_action):
         switch context.types.lookup(identifier: listed_action) {
@@ -768,7 +765,9 @@ extension TableActionsProperty: Compilable {
 
     if !errors.isEmpty {
       return .Error(
-        ErrorOnNode(node: node, withError: "Error(s) parsing table actions: "
+        ErrorOnNode(
+          node: node,
+          withError: "Error(s) parsing table actions: "
             + (errors.map { error in
               return "\(error.msg)"
             }.joined(separator: ";"))))
@@ -815,7 +814,9 @@ extension TablePropertyList: Compilable {
 
     if !errors.isEmpty {
       return .Error(
-        ErrorOnNode(node: node, withError: "Error(s) parsing property list: "
+        ErrorOnNode(
+          node: node,
+          withError: "Error(s) parsing property list: "
             + (errors.map { error in
               return "\(error.msg)"
             }.joined(separator: ";"))))
@@ -828,7 +829,7 @@ extension TablePropertyList: Compilable {
         ErrorOnNode(node: node, withError: "More than one key set in table property list"))
     }
 
-    // There should be only one table keys!
+    // There should be only one table actions!
     if actions.count > 1 {
       // Todo: Make this error message better.
       return .Error(

Sources/P4Compiler/Walker.swift

@@ -52,7 +52,9 @@ public struct Walker {
     return Result.Ok(())
   }
 
-  public func try_map<T>(n: Int, onlyNamed: Bool = false, todo: (Node) -> Result<T>) -> ([T], [Error]) {
+  public func try_map<T>(
+    n: Int, onlyNamed: Bool = false, todo: (Node) -> Result<T>
+  ) -> ([T], [Error]) {
     var errors: [Error] = Array()
     var results: [T] = Array()
 
@@ -62,8 +64,8 @@ public struct Walker {
         continue
       }
       switch todo(currentChild) {
-        case .Ok(let r): results.append(r)
+      case .Ok(let r): results.append(r)
-        case .Error(let e): errors.append(e)
+      case .Error(let e): errors.append(e)
       }
     }
     return (results, errors)

Sources/P4Lang/Control.swift

@@ -78,7 +78,8 @@ public struct Action: CustomStringConvertible, P4DataType, P4DataValue {
   public var name: Identifier
 
   public init(
-    named name: Identifier = Identifier(name: ""), withParameters parameters: ParameterList = ParameterList([]),
+    named name: Identifier = Identifier(name: ""),
+    withParameters parameters: ParameterList = ParameterList([]),
     withBody body: BlockStatement? = .none
   ) {
     self.name = name
@@ -89,7 +90,7 @@ public struct Action: CustomStringConvertible, P4DataType, P4DataValue {
 }
 
 public struct Actions: CustomStringConvertible {
-  let actions: [Action]
+  public let actions: [Action]
   public init(withActions actions: [Action]) {
     self.actions = actions
   }
@@ -107,8 +108,8 @@ public enum TableKeyMatchType {
 }
 
 public struct TableKeyEntry: CustomStringConvertible {
-  let key: KeysetExpression
+  public let key: KeysetExpression
-  let match_type: TableKeyMatchType
+  public let match_type: TableKeyMatchType
 
   public init(_ key: KeysetExpression, _ match: TableKeyMatchType) {
     self.key = key
@@ -121,19 +122,19 @@ public struct TableKeyEntry: CustomStringConvertible {
 }
 
 public struct TableKeys: CustomStringConvertible {
-  let entries: [TableKeyEntry]
+  public let keys: [TableKeyEntry]
 
   public init(withEntries entries: [TableKeyEntry]) {
-    self.entries = entries
+    self.keys = entries
   }
   public init() {
-    self.entries = []
+    self.keys = []
   }
 
   public var description: String {
     return "Table Keys: "
-      + self.entries.map { entry in
+      + self.keys.map { key in
-        return "\(entry)"
+        return "\(key)"
       }.joined(separator: ";")
   }
 }
@@ -153,8 +154,8 @@ public struct TableActionsProperty: CustomStringConvertible {
 }
 
 public struct TablePropertyList: CustomStringConvertible {
-  let actions: TableActionsProperty
+  public let actions: TableActionsProperty
-  let keys: TableKeys
+  public let keys: TableKeys
   public init(withActions actions: TableActionsProperty, withKeys keys: TableKeys) {
     self.actions = actions
     self.keys = keys
@@ -166,17 +167,31 @@ public struct TablePropertyList: CustomStringConvertible {
 }
 
 public struct Table: CustomStringConvertible {
-  let properties: TablePropertyList
+  public let properties: TablePropertyList
   let name: Identifier
+  public let entries: [(P4Value, TypedIdentifier)]
 
-  public init(withName name: Identifier, withPropertyList property_list: TablePropertyList) {
+  public init(
+    withName name: Identifier, withPropertyList property_list: TablePropertyList,
+    withEntries entries: [(P4Value, TypedIdentifier)] = []
+  ) {
     self.name = name
     self.properties = property_list
+    self.entries = entries
   }
 
   public var description: String {
     return "Table named: \(self.name) \(self.properties)"
   }
+
+  /// When the control is evaluated, the value of the x in the table is
+  /// compared to the entries and the match is assocated with an action
+  /// that is invoked when the match occurs!
+
+  public func update(addEntry entry: (P4Value, TypedIdentifier)) -> Table {
+    return Table(
+      withName: self.name, withPropertyList: self.properties, withEntries: self.entries + [entry])
+  }
 }
 
 public struct Control: P4DataType, P4DataValue, Equatable, CustomStringConvertible {
@@ -236,8 +251,8 @@ public struct Control: P4DataType, P4DataValue, Equatable, CustomStringConvertib
     return "Control named \(self._name) \(self.parameters) \(self.actions) \(self.table)"
   }
 
-  let actions: Actions
+  public let actions: Actions
-  let table: Table
+  public let table: Table
   let _parameters: ParameterList
   let _name: Identifier
   let apply: ApplyStatement
@@ -261,6 +276,14 @@ public struct Control: P4DataType, P4DataValue, Equatable, CustomStringConvertib
     self.apply = apply
   }
 
+  public func updateTable(addEntry entry: (P4Value, TypedIdentifier)) -> Control {
+    let table = self.table.update(addEntry: entry)
+
+    return Control(
+      named: self.name, withParameters: self.parameters, withTable: table,
+      withActions: self.actions, withApply: self.apply)
+  }
+
   public func def() -> any P4DataValue {
     return Control(
       named: Identifier(name: ""),

Sources/P4Runtime/Control.swift

@@ -0,0 +1,104 @@
+// 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
+
+extension Control: LibraryCallable {
+  public typealias T = P4TableHitMissValue
+  public func call(
+    execution: Common.ProgramExecution, arguments: ArgumentList
+  ) -> (P4TableHitMissValue, Common.ProgramExecution) {
+
+    var control_execution = execution.enter_scope()
+
+    // Add initial values to the global scope
+    for (name, value) in execution.getGlobalValues() {
+      control_execution = control_execution.declare(identifier: name, withValue: value)
+    }
+
+    let call_body: (ProgramExecution) -> (Result<P4TableHitMissValue>, ProgramExecution) = {
+      execution in
+      var control_execution = execution
+
+      for action in self.actions.actions {
+        control_execution = control_execution.declare(
+          identifier: action.name, withValue: P4Value(action))
+      }
+
+      for key in self.table.properties.keys.keys {
+        // Every evaluation of the key starts from an unchanged execution context.
+        let (key_eval, updated_execution) = key.key.evaluate(execution: control_execution)
+
+        guard case .Ok(let key_val) = key_eval else {
+          return (.Error(key_eval.error()!), updated_execution)
+        }
+
+        /// ASSUME: The first matching entry is the one to do.
+        /// TODO: Check whether this matches architecture.
+        for (val, action) in self.table.entries {
+
+          // Skip those with mismatching types.
+
+          if !val.type().eq(key_val.type()) {
+            continue
+          }
+
+          /// ASSUME: All matches are exact.
+          if val.eq(key_val) {
+            // Lookup action!
+
+            let maybe_action = updated_execution.scopes.lookup(identifier: action)
+            guard case .Ok(let action) = maybe_action else {
+              return (.Error(maybe_action.error()!), updated_execution)
+            }
+
+            let aaction = (action.dataValue() as! Action)
+
+            return switch aaction.evaluate(execution: updated_execution) {
+            case (ControlFlow.Error, let updated_execution):
+              (.Error(updated_execution.getError()!), updated_execution)
+            case (_, let updated_execution): (.Ok(P4TableHitMissValue.Hit), updated_execution)
+            }
+          }
+        }
+      }
+      return (.Ok(P4TableHitMissValue.Miss), control_execution)
+    }
+
+    switch Call(
+      body: call_body, withArguments: arguments, withParameters: self.parameters,
+      inExecution: control_execution)
+    {
+    case (.Ok(let r), let updated_execution): return (r, updated_execution)
+    case (.Error(let e), let updated_execution):
+      return (P4TableHitMissValue.Miss, updated_execution.setError(error: e))
+    }
+  }
+}
+
+extension Action: EvaluatableStatement {
+  public func evaluate(
+    execution: Common.ProgramExecution
+  ) -> (Common.ControlFlow, Common.ProgramExecution) {
+    if let body = self.body {
+      return body.evaluate(execution: execution)
+    }
+
+    return (ControlFlow.Next, execution)
+  }
+}

Sources/P4Runtime/Runtime.swift

@@ -19,67 +19,66 @@ import Common
 import P4Lang
 
 /// The runtime for a parser
-public struct ParserRuntime: CustomStringConvertible {
+public struct Runtime<U, T: LibraryCallable<U>>: CustomStringConvertible {
-  public var parser: Parser
+  public var callable: T
 
   let initialValues: VarValueScopes?
 
-  init(parser: Parser) {
+  init(callable: T) {
-    self.parser = parser
+    self.callable = callable
     self.initialValues = .none
   }
 
-  init(parser: Parser, withGlobalValues initial: VarValueScopes?) {
+  init(callable: T, withGlobalValues initial: VarValueScopes?) {
-    self.parser = parser
+    self.callable = callable
     self.initialValues = initial
   }
 
   /// Create a parser runtime from a P4 program
-  public static func create(program: P4Lang.Program) -> Result<ParserRuntime> {
+  public static func create(
-    return ParserRuntime.create(program: program, withGlobalValues: .none)
+    program: P4Lang.Program
+  ) -> Result<Runtime<InstantiatedParserState, Parser>> {
+    return Runtime.create(program: program, withGlobalValues: .none)
   }
 
   public static func create(
     program: P4Lang.Program, withGlobalValues initial: VarValueScopes?
-  ) -> Result<ParserRuntime> {
+  ) -> Result<Runtime<InstantiatedParserState, Parser>> {
     return switch program.starting_parser() {
     case .Ok(let parser):
-      .Ok(P4Runtime.ParserRuntime(parser: parser, withGlobalValues: initial))
+      .Ok(
+        P4Runtime.Runtime<InstantiatedParserState, Parser>(
+          callable: parser, withGlobalValues: initial))
     case .Error(let error): .Error(error)
     }
   }
 
+  public static func create(
+    control: P4Lang.Control, withGlobalValues initial: VarValueScopes?
+  ) -> Result<Runtime<P4TableHitMissValue, Control>> {
+    return .Ok(
+      P4Runtime.Runtime<P4TableHitMissValue, Control>(callable: control, withGlobalValues: initial))
+  }
+
   /// Run a P4 parser with no arguments
-  public func run() -> Result<(ParserState, ProgramExecution)> {
+  public func run() -> Result<(U, ProgramExecution)> {
     return self.run(withArguments: ArgumentList([]))
 
   }
 
-  public func run(withArguments arguments: ArgumentList) -> Result<(ParserState, ProgramExecution)>
-  {
-    let pe =
-      if let initial = initialValues {
-        ProgramExecution().setGlobalValues(initial)
-      } else {
-        ProgramExecution()
-      }
-
-    return self.run(withArguments: arguments, inExecution: pe)
-  }
-
   /// Run the P4 parser on a given packet
   public func run(
-    withArguments arguments: ArgumentList, inExecution pe: ProgramExecution
+    withArguments arguments: ArgumentList, inExecution pe: ProgramExecution = ProgramExecution()
-  ) -> Result<(ParserState, ProgramExecution)> {
+  ) -> Result<(U, ProgramExecution)> {
 
-    let pe =
+    let npe =
       if let globals = initialValues {
         pe.setGlobalValues(globals)
       } else {
         pe
       }
 
-    let (end_state, execution) = parser.call(execution: pe, arguments: arguments)
+    let (end_state, execution) = callable.call(execution: npe, arguments: arguments)
     if let error = execution.getError() {
       return .Error(error)
     }
@@ -87,6 +86,6 @@ public struct ParserRuntime: CustomStringConvertible {
   }
 
   public var description: String {
-    return "Runtime:\nExecution: \(parser)"
+    return "Runtime:\nExecution: \(callable)"
   }
 }

Tests/p4rseTests/ArrayTests.swift

@@ -49,7 +49,7 @@ import TreeSitterP4
     ])))
   let program = try #UseOkResult(
     Program.Compile(simple_parser_declaration, withGlobalInstances: test_declarations))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program, withGlobalValues: test_values))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program, withGlobalValues: test_values))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
@@ -101,7 +101,7 @@ import TreeSitterP4
     ])))
   let program = try #UseOkResult(
     Program.Compile(simple_parser_declaration, withGlobalInstances: test_declarations))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program, withGlobalValues: test_values))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program, withGlobalValues: test_values))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.reject)
@@ -128,7 +128,7 @@ import TreeSitterP4
     ])))
   let program = try #UseOkResult(
     Program.Compile(simple_parser_declaration, withGlobalInstances: test_declarations))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program, withGlobalValues: test_values))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program, withGlobalValues: test_values))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
@@ -155,7 +155,7 @@ import TreeSitterP4
     ])))
   let program = try #UseOkResult(
     Program.Compile(simple_parser_declaration, withGlobalInstances: test_declarations))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program, withGlobalValues: test_values))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program, withGlobalValues: test_values))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
@@ -187,7 +187,7 @@ import TreeSitterP4
 
   let program = try #UseOkResult(
     Program.Compile(simple_parser_declaration, withGlobalInstances: test_declarations))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program, withGlobalValues: test_values))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program, withGlobalValues: test_values))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
@@ -216,7 +216,7 @@ import TreeSitterP4
     ])))
   let program = try #UseOkResult(
     Program.Compile(simple_parser_declaration, withGlobalInstances: test_declarations))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program, withGlobalValues: test_values))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program, withGlobalValues: test_values))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
@@ -249,7 +249,7 @@ import TreeSitterP4
 
   let program = try #UseOkResult(
     Program.Compile(simple_parser_declaration, withGlobalInstances: test_declarations))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program, withGlobalValues: test_values))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program, withGlobalValues: test_values))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)

Tests/p4rseTests/BinaryOperatorTests/AndOr.swift

@@ -42,7 +42,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
@@ -61,7 +61,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.reject)
@@ -80,7 +80,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.reject)
@@ -99,7 +99,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.reject)
@@ -118,7 +118,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
@@ -137,7 +137,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
@@ -156,7 +156,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
@@ -175,7 +175,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.reject)
@@ -194,7 +194,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
@@ -213,7 +213,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.reject)

Tests/p4rseTests/BinaryOperatorTests/Bool.swift

@@ -42,7 +42,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
@@ -61,7 +61,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.reject)
@@ -80,7 +80,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
@@ -99,7 +99,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
@@ -118,7 +118,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
@@ -137,7 +137,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
@@ -156,7 +156,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
@@ -175,7 +175,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
@@ -194,7 +194,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.reject)
@@ -213,7 +213,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.reject)
@@ -232,7 +232,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.reject)
@@ -251,7 +251,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.reject)
@@ -270,7 +270,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.reject)
@@ -289,7 +289,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.reject)

Tests/p4rseTests/BinaryOperatorTests/Integer.swift

@@ -42,7 +42,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
@@ -61,7 +61,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.reject)
@@ -80,7 +80,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
@@ -99,7 +99,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
@@ -118,7 +118,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
@@ -137,7 +137,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
@@ -156,7 +156,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
@@ -175,7 +175,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
@@ -194,7 +194,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.reject)
@@ -213,7 +213,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.reject)
@@ -232,7 +232,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.reject)
@@ -251,7 +251,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.reject)
@@ -270,7 +270,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.reject)
@@ -289,7 +289,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.reject)
@@ -311,7 +311,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
@@ -395,7 +395,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
@@ -480,7 +480,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
@@ -564,7 +564,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)

Tests/p4rseTests/BinaryOperatorTests/String.swift

@@ -42,7 +42,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
@@ -61,7 +61,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.reject)
@@ -80,7 +80,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
@@ -99,7 +99,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
@@ -118,7 +118,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
@@ -137,7 +137,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
@@ -156,7 +156,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.reject)
@@ -175,7 +175,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.reject)
@@ -194,7 +194,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.reject)
@@ -213,7 +213,7 @@ import TreeSitterP4
   """
 
   let program = try #UseOkResult(Program.Compile(simple))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.reject)

Tests/p4rseTests/BinaryOperatorTests/Struct.swift

@@ -52,7 +52,7 @@ import TreeSitterP4
   let program = try #UseOkResult(
     Program.Compile(simple_parser_declaration, withGlobalInstances: test_declarations, withGlobalTypes: test_types))
 
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
 }
@@ -85,7 +85,7 @@ import TreeSitterP4
   let program = try #UseOkResult(
     Program.Compile(simple_parser_declaration, withGlobalInstances: test_declarations, withGlobalTypes: test_types))
 
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
   #expect(AsInstantiatedParserState(state_result) == P4Lang.reject)
 }
@@ -119,7 +119,7 @@ import TreeSitterP4
   let program = try #UseOkResult(
     Program.Compile(simple_parser_declaration, withGlobalInstances: test_declarations, withGlobalTypes: test_types))
 
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
 }
@@ -156,7 +156,7 @@ import TreeSitterP4
   let program = try #UseOkResult(
     Program.Compile(simple_parser_declaration, withGlobalInstances: test_declarations, withGlobalTypes: test_types))
 
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
 }
@@ -193,7 +193,7 @@ import TreeSitterP4
   let program = try #UseOkResult(
     Program.Compile(simple_parser_declaration, withGlobalInstances: test_declarations, withGlobalTypes: test_types))
 
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
   #expect(AsInstantiatedParserState(state_result) == P4Lang.reject)
 }

Tests/p4rseTests/ConditionalTests.swift

@@ -46,7 +46,7 @@ import TreeSitterP4
     """
 
   let program = try #UseOkResult(Program.Compile(simple_parser_declaration))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.reject)
@@ -74,7 +74,7 @@ import TreeSitterP4
     """
 
   let program = try #UseOkResult(Program.Compile(simple_parser_declaration))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)

Tests/p4rseTests/ControlTests/Runtime.swift

@@ -0,0 +1,384 @@
+// 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 Foundation
+import Macros
+import P4Lang
+import P4Runtime
+import SwiftTreeSitter
+import Testing
+import TreeSitter
+import TreeSitterP4
+
+@testable import P4Compiler
+
+@Test func test_control_single_key() async throws {
+  let simple_parser_declaration = """
+    control simple(inout int result, bool x) {
+      action a() {
+        result = 5;
+      }
+      action b() {
+        result = 7;
+      }
+      table t {
+        key = {
+          x: exact;
+        }
+        actions = {
+          a;
+          b;
+        }
+      }
+      apply {
+      }
+    };
+    """
+
+  let program = try! #UseOkResult(Program.Compile(simple_parser_declaration))
+
+  // Pull the control out of the compiled program.
+  let controls = program.InstancesWithTypes() { (tipe: P4Type) -> Bool in
+    switch tipe.dataType() {
+    case let c as Control: c.name == "simple"
+    default: false
+    }
+  }
+  var control = ((controls[0].dataType() as P4DataType) as! Control)
+
+  // Add entries to the table.
+  control = control.updateTable(
+    addEntry: (
+      P4Value(P4BooleanValue(withValue: true)),
+      TypedIdentifier(name: "a", withType: P4Type(Action()))
+    )
+  ).updateTable(
+    addEntry: (
+      P4Value(P4BooleanValue(withValue: false)),
+      TypedIdentifier(name: "b", withType: P4Type(Action()))
+    ))
+
+  // Set a variable in the global scope for the inout first parameter.
+  var global_values = VarValueScopes().enter()
+  global_values = global_values.declare(
+    identifier: Identifier(name: "result_arg"),
+    withValue: P4Value(
+          P4IntValue(withValue: 0),
+          P4Type(P4Int())))
+
+  let runtime = try #UseOkResult(
+    P4Runtime.Runtime<P4TableHitMissValue, Control>.create(control: control, withGlobalValues: global_values))
+
+  let (hit_miss, updated_execution) = try #UseOkResult(runtime.run(
+    withArguments: ArgumentList([
+      Argument(TypedIdentifier(name: "result_arg", withType: P4Type(P4Int())), atIndex: 0),
+      Argument(P4Value(P4BooleanValue(withValue: true)), atIndex: 1),
+    ])))
+
+  // We expect there to be a hit.
+  #expect(hit_miss == P4TableHitMissValue.Hit)
+
+  // And that the proper action was invoked.
+  let result_arg = try #UseOkResult(updated_execution.scopes.lookup(identifier: Identifier(name: "result_arg")))
+  #expect(result_arg.eq(P4Value(P4IntValue(withValue: 5))))
+}
+
+@Test func test_control_single_key_false() async throws {
+  let simple_parser_declaration = """
+    control simple(inout int result, bool x) {
+      action a() {
+        result = 5;
+      }
+      action b() {
+        result = 7;
+      }
+      table t {
+        key = {
+          x: exact;
+        }
+        actions = {
+          a;
+          b;
+        }
+      }
+      apply {
+      }
+    };
+    """
+
+  let program = try! #UseOkResult(Program.Compile(simple_parser_declaration))
+
+  // Pull the control out of the compiled program.
+  let controls = program.InstancesWithTypes() { (tipe: P4Type) -> Bool in
+    switch tipe.dataType() {
+    case let c as Control: c.name == "simple"
+    default: false
+    }
+  }
+  var control = ((controls[0].dataType() as P4DataType) as! Control)
+
+  // Add entries to the table.
+  control = control.updateTable(
+    addEntry: (
+      P4Value(P4BooleanValue(withValue: true)),
+      TypedIdentifier(name: "a", withType: P4Type(Action()))
+    )
+  ).updateTable(
+    addEntry: (
+      P4Value(P4BooleanValue(withValue: false)),
+      TypedIdentifier(name: "b", withType: P4Type(Action()))
+    ))
+
+  // Set a variable in the global scope for the inout first parameter.
+  var global_values = VarValueScopes().enter()
+  global_values = global_values.declare(
+    identifier: Identifier(name: "result_arg"),
+    withValue: P4Value(
+          P4IntValue(withValue: 0),
+          P4Type(P4Int())))
+
+  let runtime = try #UseOkResult(
+    P4Runtime.Runtime<P4TableHitMissValue, Control>.create(control: control, withGlobalValues: global_values))
+
+  let (hit_miss, updated_execution) = try #UseOkResult(runtime.run(
+    withArguments: ArgumentList([
+      Argument(TypedIdentifier(name: "result_arg", withType: P4Type(P4Int())), atIndex: 0),
+      Argument(P4Value(P4BooleanValue(withValue: false)), atIndex: 1),
+    ])))
+
+  // We expect there to be a hit.
+  #expect(hit_miss == P4TableHitMissValue.Hit)
+
+  // And that the proper action was invoked.
+  let result_arg = try #UseOkResult(updated_execution.scopes.lookup(identifier: Identifier(name: "result_arg")))
+  #expect(result_arg.eq(P4Value(P4IntValue(withValue: 7))))
+}
+
+@Test func test_control_single_integer_key_hit() async throws {
+  let simple_parser_declaration = """
+    control simple(inout int result, int x) {
+      action a() {
+        result = 5;
+      }
+      action b() {
+        result = 7;
+      }
+      table t {
+        key = {
+          x: exact;
+        }
+        actions = {
+          a;
+          b;
+        }
+      }
+      apply {
+      }
+    };
+    """
+
+  let program = try! #UseOkResult(Program.Compile(simple_parser_declaration))
+
+  // Pull the control out of the compiled program.
+  let controls = program.InstancesWithTypes() { (tipe: P4Type) -> Bool in
+    switch tipe.dataType() {
+    case let c as Control: c.name == "simple"
+    default: false
+    }
+  }
+  var control = ((controls[0].dataType() as P4DataType) as! Control)
+
+  // Add entries to the table.
+  control = control.updateTable(
+    addEntry: (
+      P4Value(P4IntValue(withValue: 5)),
+      TypedIdentifier(name: "a", withType: P4Type(Action()))
+    )
+  ).updateTable(
+    addEntry: (
+      P4Value(P4IntValue(withValue: 2)),
+      TypedIdentifier(name: "b", withType: P4Type(Action()))
+    ))
+
+  // Set a variable in the global scope for the inout first parameter.
+  var global_values = VarValueScopes().enter()
+  global_values = global_values.declare(
+    identifier: Identifier(name: "result_arg"),
+    withValue: P4Value(
+          P4IntValue(withValue: 0),
+          P4Type(P4Int())))
+
+  let runtime = try #UseOkResult(
+    P4Runtime.Runtime<P4TableHitMissValue, Control>.create(control: control, withGlobalValues: global_values))
+
+  let (hit_miss, updated_execution) = try #UseOkResult(runtime.run(
+    withArguments: ArgumentList([
+      Argument(TypedIdentifier(name: "result_arg", withType: P4Type(P4Int())), atIndex: 0),
+      Argument(P4Value(P4IntValue(withValue: 5)), atIndex: 1),
+    ])))
+
+  // We expect there to be a hit.
+  #expect(hit_miss == P4TableHitMissValue.Hit)
+
+  let result_arg = try #UseOkResult(updated_execution.scopes.lookup(identifier: Identifier(name: "result_arg")))
+  #expect(result_arg.eq(P4Value(P4IntValue(withValue: 5))))
+}
+
+@Test func test_control_single_integer_key_miss() async throws {
+  let simple_parser_declaration = """
+    control simple(inout int result, int x) {
+      action a() {
+        result = 5;
+      }
+      action b() {
+        result = 7;
+      }
+      table t {
+        key = {
+          x: exact;
+        }
+        actions = {
+          a;
+          b;
+        }
+      }
+      apply {
+      }
+    };
+    """
+
+  let program = try! #UseOkResult(Program.Compile(simple_parser_declaration))
+
+  // Pull the control out of the compiled program.
+  let controls = program.InstancesWithTypes() { (tipe: P4Type) -> Bool in
+    switch tipe.dataType() {
+    case let c as Control: c.name == "simple"
+    default: false
+    }
+  }
+  var control = ((controls[0].dataType() as P4DataType) as! Control)
+
+  // Add entries to the table.
+  control = control.updateTable(
+    addEntry: (
+      P4Value(P4IntValue(withValue: 1)),
+      TypedIdentifier(name: "a", withType: P4Type(Action()))
+    )
+  ).updateTable(
+    addEntry: (
+      P4Value(P4IntValue(withValue: 2)),
+      TypedIdentifier(name: "b", withType: P4Type(Action()))
+    ))
+
+  // Set a variable in the global scope for the inout first parameter.
+  var global_values = VarValueScopes().enter()
+  global_values = global_values.declare(
+    identifier: Identifier(name: "result_arg"),
+    withValue: P4Value(
+          P4IntValue(withValue: 0),
+          P4Type(P4Int())))
+
+  let runtime = try #UseOkResult(
+    P4Runtime.Runtime<P4TableHitMissValue, Control>.create(control: control, withGlobalValues: global_values))
+
+  let (hit_miss, updated_execution) = try #UseOkResult(runtime.run(
+    withArguments: ArgumentList([
+      Argument(TypedIdentifier(name: "result_arg", withType: P4Type(P4Int())), atIndex: 0),
+      Argument(P4Value(P4IntValue(withValue: 3)), atIndex: 1),
+    ])))
+
+  // We expect there to be a hit.
+  #expect(hit_miss == P4TableHitMissValue.Miss)
+
+  let result_arg = try #UseOkResult(updated_execution.scopes.lookup(identifier: Identifier(name: "result_arg")))
+  #expect(result_arg.eq(P4Value(P4IntValue(withValue: 0))))
+}
+
+@Test func test_control_multiple_keys() async throws {
+  let simple_parser_declaration = """
+    control simple(inout int result, bool x, int f) {
+      action a() {
+        result = 5;
+      }
+      action b() {
+        result = 7;
+      }
+      table t {
+        key = {
+          x: exact;
+          f: exact;
+        }
+        actions = {
+          a;
+          b;
+        }
+      }
+      apply {
+      }
+    };
+    """
+
+  let program = try! #UseOkResult(Program.Compile(simple_parser_declaration))
+
+  // Pull the control out of the compiled program.
+  let controls = program.InstancesWithTypes() { (tipe: P4Type) -> Bool in
+    switch tipe.dataType() {
+    case let c as Control: c.name == "simple"
+    default: false
+    }
+  }
+  var control = ((controls[0].dataType() as P4DataType) as! Control)
+
+  // Add entries to the table.
+  control = control.updateTable(
+    addEntry: (
+      P4Value(P4BooleanValue(withValue: true)),
+      TypedIdentifier(name: "a", withType: P4Type(Action()))
+    )
+  ).updateTable(
+    addEntry: (
+      P4Value(P4IntValue(withValue: 5)),
+      TypedIdentifier(name: "b", withType: P4Type(Action()))
+    ))
+
+  // Set a variable in the global scope for the inout first parameter.
+  var global_values = VarValueScopes().enter()
+  global_values = global_values.declare(
+    identifier: Identifier(name: "result_arg"),
+    withValue: P4Value(
+          P4IntValue(withValue: 0),
+          P4Type(P4Int())))
+
+  let runtime = try #UseOkResult(
+    P4Runtime.Runtime<P4TableHitMissValue, Control>.create(control: control, withGlobalValues: global_values))
+
+  let (hit_miss, updated_execution) = try #UseOkResult(runtime.run(
+    withArguments: ArgumentList([
+      Argument(TypedIdentifier(name: "result_arg", withType: P4Type(P4Int())), atIndex: 0),
+      Argument(P4Value(P4BooleanValue(withValue: false)), atIndex: 1),
+      Argument(P4Value(P4IntValue(withValue: 5)), atIndex: 2),
+    ])))
+
+  // We expect there to be a hit.
+  #expect(hit_miss == P4TableHitMissValue.Hit)
+
+  // And that the proper action was invoked.
+  let result_arg = try #UseOkResult(updated_execution.scopes.lookup(identifier: Identifier(name: "result_arg")))
+  #expect(result_arg.eq(P4Value(P4IntValue(withValue: 7))))
+
+}

Tests/p4rseTests/Declarations.swift

@@ -47,7 +47,7 @@ import TreeSitterP4
     """
   let program = try #UseOkResult(
     Program.Compile(simple_parser_declaration))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
 }
@@ -72,7 +72,7 @@ import TreeSitterP4
     """
   let program = try #UseOkResult(
     Program.Compile(simple_parser_declaration))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
 }
@@ -95,7 +95,7 @@ import TreeSitterP4
     """
   let program = try #UseOkResult(
     Program.Compile(simple_parser_declaration))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
 }
@@ -118,7 +118,7 @@ import TreeSitterP4
     """
   let program = try #UseOkResult(
     Program.Compile(simple_parser_declaration))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
 }
@@ -142,7 +142,7 @@ import TreeSitterP4
     """
   let program = try #UseOkResult(
     Program.Compile(simple_parser_declaration))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
   #expect(AsInstantiatedParserState(state_result) == P4Lang.reject)
 }

Tests/p4rseTests/ExpressionTests.swift

@@ -41,7 +41,7 @@ import TreeSitterP4
     """
 
   let program = try #UseOkResult(Program.Compile(simple_parser_declaration))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
@@ -61,7 +61,7 @@ import TreeSitterP4
     """
 
   let program = try #UseOkResult(Program.Compile(simple_parser_declaration))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
@@ -81,7 +81,7 @@ import TreeSitterP4
     """
 
   let program = try #UseOkResult(Program.Compile(simple_parser_declaration))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.reject)

Tests/p4rseTests/ExpressionTests/FunctionCall.swift

@@ -46,7 +46,7 @@ import TreeSitterP4
 
   let program = try #UseOkResult(Program.Compile(simple_parser_declaration))
   let parser = try #UseOkResult(program.find_parser(withName: Identifier(name: "main_parser")))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(parser.states.count() == 1)
@@ -75,7 +75,7 @@ import TreeSitterP4
 
   let program = try #UseOkResult(Program.Compile(simple_parser_declaration))
   let parser = try #UseOkResult(program.find_parser(withName: Identifier(name: "main_parser")))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(parser.states.count() == 1)
@@ -103,7 +103,7 @@ import TreeSitterP4
 
   let program = try #UseOkResult(Program.Compile(simple_parser_declaration))
   let parser = try #UseOkResult(program.find_parser(withName: Identifier(name: "main_parser")))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(parser.states.count() == 1)
@@ -130,7 +130,7 @@ import TreeSitterP4
 
   let program = try #UseOkResult(Program.Compile(simple_parser_declaration))
   let parser = try #UseOkResult(program.find_parser(withName: Identifier(name: "main_parser")))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(parser.states.count() == 1)
@@ -156,7 +156,7 @@ import TreeSitterP4
 
   let program = try #UseOkResult(Program.Compile(simple_parser_declaration))
   let parser = try #UseOkResult(program.find_parser(withName: Identifier(name: "main_parser")))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(parser.states.count() == 1)

Tests/p4rseTests/ExpressionTests/SelectExpression.swift

@@ -41,7 +41,7 @@ import TreeSitterP4
 
   let program = try #UseOkResult(Program.Compile(simple_parser_declaration))
   let parser = try #UseOkResult(program.find_parser(withName: Identifier(name: "main_parser")))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(parser.states.count() == 1)
@@ -63,7 +63,7 @@ import TreeSitterP4
 
   let program = try #UseOkResult(Program.Compile(simple_parser_declaration))
   let parser = try #UseOkResult(program.find_parser(withName: Identifier(name: "main_parser")))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(parser.states.count() == 1)
@@ -85,7 +85,7 @@ import TreeSitterP4
 
   let program = try #UseOkResult(Program.Compile(simple_parser_declaration))
   let parser = try #UseOkResult(program.find_parser(withName: Identifier(name: "main_parser")))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(parser.states.count() == 1)
@@ -107,7 +107,7 @@ import TreeSitterP4
     """
   let program = try #UseOkResult(Program.Compile(simple_parser_declaration))
   let parser = try #UseOkResult(program.find_parser(withName: Identifier(name: "main_parser")))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(parser.states.count() == 1)
@@ -151,7 +151,7 @@ import TreeSitterP4
     """
   let program = try #UseOkResult(Program.Compile(simple_parser_declaration))
   let parser = try #UseOkResult(program.find_parser(withName: Identifier(name: "main_parser")))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(parser.states.count() == 1)
@@ -172,7 +172,7 @@ import TreeSitterP4
       };
     """
   let program = try #UseOkResult(Program.Compile(simple_parser_declaration))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
 
   let args = ArgumentList([
     Argument(P4Value(P4BooleanValue(withValue: false)), atIndex: 1), Argument(P4Value(P4StringValue(withValue: "Testing")), atIndex: 2), Argument(P4Value(P4IntValue(withValue: 5)), atIndex: 3),
@@ -193,7 +193,7 @@ import TreeSitterP4
       };
     """
   let program = try #UseOkResult(Program.Compile(simple_parser_declaration))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
 
   let args = ArgumentList([
     Argument(P4Value(P4BooleanValue(withValue: false)), atIndex: 1), Argument(P4Value(P4StringValue(withValue: "Testing")), atIndex: 2), Argument(P4Value(P4IntValue(withValue: 5)), atIndex: 3),

Tests/p4rseTests/ExternDeclarations.swift

@@ -89,7 +89,7 @@ public struct Return6: P4FFI {
       simple_parser_declaration, withGlobalInstances: .none, withGlobalTypes: .none,
       withFFIs: [externally]))
 
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
@@ -117,7 +117,7 @@ public struct Return6: P4FFI {
       simple_parser_declaration, withGlobalInstances: .none, withGlobalTypes: .none,
       withFFIs: [externally]))
 
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.reject)

Tests/p4rseTests/InterloperTests.swift

@@ -47,7 +47,7 @@ import TreeSitterP4
     """
   
   let program = try #UseOkResult(Program.Compile(simple_parser_declaration))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
 
   var statements_executed: [String] = Array()
 
@@ -86,7 +86,7 @@ import TreeSitterP4
     """
   
   let program = try #UseOkResult(Program.Compile(simple_parser_declaration))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
 
   var expressions_evaluated: [String] = Array()
 

Tests/p4rseTests/RuntimeTests.swift

@@ -38,7 +38,7 @@ import TreeSitterP4
     """
 
   let program = try #UseOkResult(Program.Compile(simple_parser_declaration))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   // We should be in the accept state.
@@ -56,7 +56,7 @@ import TreeSitterP4
     """
 
   let program = try #UseOkResult(Program.Compile(simple_parser_declaration))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
   // We should be in the accept state.
   #expect(AsInstantiatedParserState(state_result) == P4Lang.reject)
@@ -73,10 +73,10 @@ import TreeSitterP4
     """
 
   let program = try #UseOkResult(Program.Compile(simple_parser_declaration))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
 
   #expect(
-    #RequireErrorResult<(ParserState, ProgramExecution)>(
+    #RequireErrorResult<(InstantiatedParserState, ProgramExecution)>(
       Error(withMessage: "Could not find the start state"),
       runtime.run()))
 }
@@ -93,7 +93,7 @@ import TreeSitterP4
       };
     """
   let program = try #UseOkResult(Program.Compile(simple_parser_declaration))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
 
   let args = ArgumentList([
     Argument(P4Value(P4BooleanValue(withValue: true)), atIndex: 1), Argument(P4Value(P4StringValue(withValue: "Testing")), atIndex: 2), Argument(P4Value(P4IntValue(withValue: 5)), atIndex: 3),
@@ -115,14 +115,14 @@ import TreeSitterP4
       };
     """
   let program = try #UseOkResult(Program.Compile(simple_parser_declaration))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
 
   let args = ArgumentList([
     Argument(P4Value(P4BooleanValue(withValue: true)), atIndex: 1), Argument(P4Value(P4BooleanValue(withValue: false)), atIndex: 2), Argument(P4Value(P4IntValue(withValue: 5)), atIndex: 3),
   ])
 
   #expect(
-    #RequireErrorResult<(ParserState, ProgramExecution)>(
+    #RequireErrorResult<(InstantiatedParserState, ProgramExecution)>(
       Error(withMessage: "Cannot call parser: Argument 2's type (Boolean) is incompatible with the parameter type (String)"),
       runtime.run(withArguments: args)))
 }
@@ -139,14 +139,14 @@ import TreeSitterP4
       };
     """
   let program = try #UseOkResult(Program.Compile(simple_parser_declaration))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
 
   let args = ArgumentList([
     Argument(P4Value(P4IntValue(withValue: 5)), atIndex: 1), Argument(P4Value(P4StringValue(withValue: "Testing")), atIndex: 2), Argument(P4Value(P4IntValue(withValue: 5)), atIndex: 3),
   ])
 
   #expect(
-    #RequireErrorResult<(ParserState, ProgramExecution)>(
+    #RequireErrorResult<(InstantiatedParserState, ProgramExecution)>(
       Error(withMessage: "Cannot call parser: Argument 1's type (Int) is incompatible with the parameter type (Boolean)"),
       runtime.run(withArguments: args)))
 }
@@ -163,11 +163,11 @@ import TreeSitterP4
       };
     """
   let program = try #UseOkResult(Program.Compile(simple_parser_declaration))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let args = ArgumentList([Argument(P4Value(P4BooleanValue(withValue: true)), atIndex: 0)])
 
   #expect(
-    #RequireErrorResult<(ParserState, ProgramExecution)>(
+    #RequireErrorResult<(InstantiatedParserState, ProgramExecution)>(
       Error(withMessage: "Cannot call parser: 1 arguments found but 3 required"),
       runtime.run(withArguments: args)))
 }

Tests/p4rseTests/ScopeRuntimeTests.swift

@@ -43,7 +43,7 @@ import TreeSitterP4
 
 
   let program = try #UseOkResult(Program.Compile(simple_parser_declaration))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.reject)
@@ -69,7 +69,7 @@ import TreeSitterP4
 
 
   let program = try #UseOkResult(Program.Compile(simple_parser_declaration))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
@@ -97,7 +97,7 @@ import TreeSitterP4
 
   
   let program = try #UseOkResult(Program.Compile(simple_parser_declaration))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.reject)
@@ -121,7 +121,7 @@ import TreeSitterP4
 
   
   let program = try #UseOkResult(Program.Compile(simple_parser_declaration))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.reject)
@@ -152,7 +152,7 @@ import TreeSitterP4
 
   
   let program = try #UseOkResult(Program.Compile(simple_parser_declaration))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(AsInstantiatedParserState(state_result) == P4Lang.reject)

Tests/p4rseTests/StructTests.swift

@@ -57,7 +57,7 @@ import TreeSitterP4
 
   let program = try #UseOkResult(
     Program.Compile(simple_parser_declaration, withGlobalInstances: test_declarations))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program, withGlobalValues: test_values))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program, withGlobalValues: test_values))
   let (state_result, _) = try! #UseOkResult(runtime.run())
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
 }
@@ -86,7 +86,7 @@ import TreeSitterP4
 
  let program = try #UseOkResult(
     Program.Compile(simple_parser_declaration, withGlobalInstances: .none, withGlobalTypes: test_types))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
 }
@@ -116,7 +116,7 @@ import TreeSitterP4
 
  let program = try #UseOkResult(
     Program.Compile(simple_parser_declaration, withGlobalInstances: .none, withGlobalTypes: test_types))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
 }
@@ -151,7 +151,7 @@ import TreeSitterP4
 
   let program = try #UseOkResult(
     Program.Compile(simple_parser_declaration, withGlobalInstances: test_declarations))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program, withGlobalValues: test_values))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program, withGlobalValues: test_values))
   let (state_result, _) = try! #UseOkResult(runtime.run())
   #expect(AsInstantiatedParserState(state_result) == P4Lang.reject)
 }
@@ -186,7 +186,7 @@ import TreeSitterP4
 
   let program = try #UseOkResult(
     Program.Compile(simple_parser_declaration, withGlobalInstances: test_declarations))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program, withGlobalValues: test_values))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program, withGlobalValues: test_values))
   let (state_result, _) = try! #UseOkResult(runtime.run())
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
 }
@@ -220,7 +220,7 @@ import TreeSitterP4
 
   let program = try #UseOkResult(
     Program.Compile(simple_parser_declaration, withGlobalInstances: test_declarations))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program, withGlobalValues: test_values))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program, withGlobalValues: test_values))
   let (state_result, _) = try! #UseOkResult(runtime.run())
   #expect(AsInstantiatedParserState(state_result) == P4Lang.reject)
 }
@@ -266,7 +266,7 @@ import TreeSitterP4
       ])))
   let program = try #UseOkResult(
     Program.Compile(simple_parser_declaration, withGlobalInstances: test_declarations))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program, withGlobalValues: test_values))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program, withGlobalValues: test_values))
   let (state_result, _) = try! #UseOkResult(runtime.run())
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
 }
@@ -302,7 +302,7 @@ import TreeSitterP4
 
   let program = try #UseOkResult(
     Program.Compile(simple_parser_declaration, withGlobalInstances: test_declarations))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program, withGlobalValues: test_values))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program, withGlobalValues: test_values))
   let (state_result, _) = try! #UseOkResult(runtime.run())
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
 }
@@ -375,7 +375,7 @@ import TreeSitterP4
       ])))
   let program = try #UseOkResult(
     Program.Compile(simple_parser_declaration, withGlobalInstances: test_declarations))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program, withGlobalValues: test_values))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program, withGlobalValues: test_values))
   let (state_result, _) = try! #UseOkResult(runtime.run())
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
 }
@@ -423,7 +423,7 @@ import TreeSitterP4
       ])))
   let program = try #UseOkResult(
     Program.Compile(simple_parser_declaration, withGlobalInstances: test_declarations))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program, withGlobalValues: test_values))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program, withGlobalValues: test_values))
   let (state_result, _) = try! #UseOkResult(runtime.run())
   #expect(AsInstantiatedParserState(state_result) == P4Lang.accept)
 }

Tests/p4rseTests/TransitionTests.swift

@@ -41,7 +41,7 @@ import TreeSitterP4
 
   let program = try #UseOkResult(Program.Compile(simple_parser_declaration))
   let parser = try #UseOkResult(program.find_parser(withName: Identifier(name: "main_parser")))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(parser.states.count() == 1)
@@ -63,7 +63,7 @@ import TreeSitterP4
 
   let program = try #UseOkResult(Program.Compile(simple_parser_declaration))
   let parser = try #UseOkResult(program.find_parser(withName: Identifier(name: "main_parser")))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   #expect(parser.states.count() == 1)
@@ -82,10 +82,10 @@ import TreeSitterP4
     """
 
   let program = try #UseOkResult(Program.Compile(simple_parser_declaration))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
 
   #expect(
-    #RequireErrorResult<(ParserState, ProgramExecution)>(
+    #RequireErrorResult<(InstantiatedParserState, ProgramExecution)>(
       Error(withMessage: "No key matched the selector"),
       runtime.run()))
 }

Tests/p4rseTests/ValueTypeParserTests.swift

@@ -141,7 +141,7 @@ import TreeSitterP4
       };
     """
   let program = try #UseOkResult(Program.Compile(simple_parser_declaration))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   // 5 == 5 == true
@@ -163,7 +163,7 @@ import TreeSitterP4
       };
     """
   let program = try #UseOkResult(Program.Compile(simple_parser_declaration))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   // 5 == 5 == true
@@ -185,7 +185,7 @@ import TreeSitterP4
       };
     """
   let program = try #UseOkResult(Program.Compile(simple_parser_declaration))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   // 6 == 5 == true
@@ -207,7 +207,7 @@ import TreeSitterP4
       };
     """
   let program = try #UseOkResult(Program.Compile(simple_parser_declaration))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   // 6 == 5 == false
@@ -229,7 +229,7 @@ import TreeSitterP4
       };
     """
   let program = try #UseOkResult(Program.Compile(simple_parser_declaration))
-  let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program))
+  let runtime = try #UseOkResult(P4Runtime.Runtime<InstantiatedParserState, P4Lang.Parser>.create(program: program))
   let (state_result, _) = try! #UseOkResult(runtime.run())
 
   // TODO: This test should throw an error.