compiler, language, runtime: Separate Parser Type From Instances

In P4, parsers are considered types. Those parsers are instantiated.
The instantiated parsers are values. Previously, gp4 treated a parser
type and a parser value as identical. This PR makes that difference
clear _and_ sets the stage for the future.

TODO: Make the same distinction between control and action types and
values.

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

Sources/P4Compiler/Parser.swift

@@ -90,7 +90,7 @@ public struct Parser {
     static func Compile(
       node: Node, forState state_identifier: Common.Identifier,
       withStatements stmts: [EvaluatableStatement], withContext context: CompilerContext
-    ) -> Result<(InstantiatedParserState, CompilerContext)> {
+    ) -> Result<(ParserState, CompilerContext)> {
 
       #RequireNodeType<Node, (EvaluatableStatement, CompilerContext)>(
         node: node, type: "parserTransitionStatement", nice_type_name: "parser transition statement"
@@ -114,19 +114,40 @@ public struct Parser {
 
       // If the next node is an identifier, we have the simple form ...
       if next_node.nodeType == "identifier" {
-        let maybe_parsed_next_state = Identifier.Compile(
+        let maybe_parsed_next_state_id = Identifier.Compile(
           node: next_node, withContext: context)
-        if case .Ok(let next_state) = maybe_parsed_next_state {
-          return .Ok(
-            (
-              ParserStateDirectTransition(
-                name: state_identifier, withStatements: stmts, withNextState: next_state), context
-            ))
+        if case .Ok(let next_state_id) = maybe_parsed_next_state_id {
+          if case .Ok(let next_state) = context.instances.lookup(identifier: next_state_id) {
+            switch next_state {
+            case (_, .some(let instance)):
+              return .Ok(
+                (
+                  ParserStateDirectTransition(
+                    name: state_identifier,
+                    withNextState: instance.dataValue() as! InstantiatedParserState,
+                    withStatements: stmts), context
+                ))
+            case (_, .none):
+              return .Ok(
+                (
+                  ParserStateDirectTransition(
+                    name: state_identifier,
+                    withNextStateIdentifier: next_state_id, withStatements: stmts), context
+                ))
+            }
+          } else {
+
+            return .Error(
+              Error(
+                withMessage:
+                  "\(next_state_id) does not name a parser state in scope"
+              ))
+          }
         } else {
           return .Error(
             Error(
               withMessage:
-                "Could not parse the next state in a transition statement: \(maybe_parsed_next_state.error()!)"
+                "Could not parse the next state in a transition statement: \(maybe_parsed_next_state_id.error()!)"
             ))
         }
       }
@@ -139,8 +160,9 @@ public struct Parser {
         .Ok(
           (
             ParserStateSelectTransition(
-              name: state_identifier, withStatements: stmts,
-              withTransitioniExpression: tse as! SelectExpression), context
+              name: state_identifier, withTransitionExpression: tse as! SelectExpression,
+              withStatements: stmts,
+            ), context
           ))
       case .Error(let e): .Error(e)
       }
@@ -189,7 +211,7 @@ public struct Parser {
   public struct State {
     static func Compile(
       node: Node, withContext context: CompilerContext
-    ) -> Result<(InstantiatedParserState, CompilerContext)> {
+    ) -> Result<(ParserState, CompilerContext)> {
       var walker = Walker(node: node)
 
       var current_node: Node? = .none
@@ -205,7 +227,7 @@ public struct Parser {
 
       #MustOr(
         result: current_node, thing: walker.getNext(),
-        or: Result<(InstantiatedParserState, CompilerContext)>.Error(
+        or: Result<(ParserState, CompilerContext)>.Error(
           ErrorWithLocation(
             sourceLocation: node.toSourceLocation(),
             withError: "Missing elements in parser state declaration")))
@@ -223,7 +245,7 @@ public struct Parser {
       walker.next()
       #MustOr(
         result: current_node, thing: walker.getNext(),
-        or: Result<(InstantiatedParserState, CompilerContext)>.Error(
+        or: Result<(ParserState, CompilerContext)>.Error(
           ErrorWithLocation(
             sourceLocation: node.toSourceLocation(),
             withError: "Missing elements in parser state declaration")))
@@ -239,7 +261,7 @@ public struct Parser {
       walker.next()
       #MustOr(
         result: current_node, thing: walker.getNext(),
-        or: Result<(InstantiatedParserState, CompilerContext)>.Error(
+        or: Result<(ParserState, CompilerContext)>.Error(
           ErrorWithLocation(
             sourceLocation: node.toSourceLocation(), withError: "Missing body of state declaration")
         ))
@@ -272,7 +294,7 @@ public struct Parser {
 
       #MustOr(
         result: current_node, thing: walker.getNext(),
-        or: Result<(InstantiatedParserState, CompilerContext)>.Error(
+        or: Result<(ParserState, CompilerContext)>.Error(
           ErrorWithLocation(
             sourceLocation: node.toSourceLocation(),
             withError: "Missing transition statement of state declaration")))