Add update Methods for Compilation Context

update method will allow the creation of a new compilation context
based on the current one with new types/names.

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

Sources/P4Compiler/Compiler.swift

@@ -40,10 +40,40 @@ public func ErrorOnNode(node: Node, withError error: String) -> Error {
   return Error(withMessage: "\(node.range): \(error)")
 }
 
+/// Context for compilation.
 public struct CompilerContext {
-  public let names: LexicalScopes
+  let names: LexicalScopes
+  let types: LexicalScopes
 
   public init(withNames _names: LexicalScopes) {
     names = _names
+    types = LexicalScopes()
   }
+
+  public init(withNames _names: LexicalScopes, withTypes _types: LexicalScopes) {
+    names = _names
+    types = _types
+  }
+
+  /// Update a compiler context
+  ///
+  /// Create a new compiler context based on the current with the same types and new names.
+  /// 
+  /// - Parameter names: a ``LexicalScopes`` with the updated names for the newly created compiler context.
+  /// - Returns: A new compiler context based on the current with the same types and new names.
+  public func update(newNames names: LexicalScopes) -> CompilerContext {
+    return CompilerContext(withNames: names, withTypes: self.types)
+  }
+
+  /// Update a compiler context
+  ///
+  /// Create a new compiler context based on the current with the same names and new types.
+  /// 
+  /// - Parameter types: a ``LexicalScopes`` with the updated types for the newly created compiler context.
+  /// - Returns: A new compiler context based on the current with the same names and new types.
+  public func update(newTypes types: LexicalScopes) -> CompilerContext {
+    return CompilerContext(withNames: self.names, withTypes: types)
+  }
+
+
 }

Sources/P4Compiler/Parser.swift

@@ -338,7 +338,7 @@ public struct Parser {
 
       // Parse a state in a nested scope.
       switch Parser.State.Compile(
-        node: parser_state, withContext: CompilerContext(withNames: current_context.names.enter()))
+        node: parser_state, withContext: context.update(newNames: current_context.names.enter()))
       {
       case Result.Ok(let (state, updated_context)):
         parser.states = parser.states.append(state: state)

Sources/P4Compiler/Program.swift

@@ -168,7 +168,7 @@ public struct Program {
       {
       case Result.Ok((let parser, let updated_context)):
         // Create a new context with the name of the parser that was just compiled in scope.
-        compilation_context = CompilerContext(withNames: updated_context.names.declare(identifier: parser.name, withValue: parser))
+        compilation_context = compilation_context.update(newNames: updated_context.names.declare(identifier: parser.name, withValue: parser))
       case Result.Error(let error): errors.append(error)
       }
 

Sources/P4Compiler/Statement.swift

@@ -220,7 +220,7 @@ extension VariableDeclarationStatement: CompilableStatement {
           VariableDeclarationStatement(
             identifier: parsed_variablename, withInitializer: parsed_rvalue),
           // Context with updated names to include the newly declared name.
-          CompilerContext(withNames: context.names.declare(
+          context.update(newNames: context.names.declare(
             identifier: parsed_variablename, withValue: declaration_p4_type))
         ))