hawkinsw/gp4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor Compilation Interface

Browse Source 
Compilation interface(s) now contain a compilation context.
The change will make it easier to expand on what each step
of the compilation process needs to know to complete its task
without having to make major changes to the interface.

Signed-off-by: Will Hawkins <hawkinsw@obs.cr>
This commit is contained in:
Will Hawkins
2026-03-13 06:25:30 -04:00
parent df841a0a1b
commit 2f7d05a3fd
7 changed files with 111 additions and 98 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Sources/P4Compiler/Compiler.swift
+8
View File
@@ -39,3 +39,11 @@ public func ConfigureP4Parser() -> Result<SwiftTreeSitter.Parser> {
public func ErrorOnNode(node: Node, withError error: String) -> Error {
return Error(withMessage: "\(node.range): \(error)")
}
public struct CompilerContext {
public let names: LexicalScopes
public init(withNames _names: LexicalScopes) {
names = _names
}
}
Sources/P4Compiler/Expression.swift
+17 -17
View File
@@ -22,13 +22,13 @@ import TreeSitterP4
protocol CompilableExpression {
static func compile(
node: Node, withTypesInScope scopes: LexicalScopes
node: Node, withContext context: CompilerContext
) -> Result<EvaluatableExpression?>
}
extension TypedIdentifier: CompilableExpression {
static func compile(
node: SwiftTreeSitter.Node, withTypesInScope scopes: LexicalScopes
node: SwiftTreeSitter.Node, withContext context: CompilerContext
) -> Result<EvaluatableExpression?> {
let node = node.child(at: 0)!
@@ -36,7 +36,7 @@ extension TypedIdentifier: CompilableExpression {
node: node, type: "identifier")
guard
case Result.Ok(let type) = scopes.lookup(
case Result.Ok(let type) = context.names.lookup(
identifier: Common.Identifier(name: node.text!))
else {
return .Error(ErrorOnNode(node: node, withError: "Cannot find \(node.text!) in scope"))
@@ -48,7 +48,7 @@ extension TypedIdentifier: CompilableExpression {
extension P4BooleanValue: CompilableExpression {
static func compile(
node: SwiftTreeSitter.Node, withTypesInScope scopes: LexicalScopes
node: SwiftTreeSitter.Node, withContext context: CompilerContext
) -> Result<EvaluatableExpression?> {
let node = node.child(at: 0)!
#SkipUnlessNodeType<SwiftTreeSitter.Node, EvaluatableExpression?>(
@@ -67,7 +67,7 @@ extension P4BooleanValue: CompilableExpression {
extension P4IntValue: CompilableExpression {
static func compile(
node: SwiftTreeSitter.Node, withTypesInScope scopes: LexicalScopes
node: SwiftTreeSitter.Node, withContext context: CompilerContext
) -> Result<EvaluatableExpression?> {
let node = node.child(at: 0)!
#SkipUnlessNodeType<SwiftTreeSitter.Node, EvaluatableExpression?>(node: node, type: "integer")
@@ -81,7 +81,7 @@ extension P4IntValue: CompilableExpression {
extension P4StringValue: CompilableExpression {
static func compile(
node: SwiftTreeSitter.Node, withTypesInScope scopes: LexicalScopes
node: SwiftTreeSitter.Node, withContext scopes: CompilerContext
) -> Result<EvaluatableExpression?> {
let node = node.child(at: 0)!
#SkipUnlessNodeType<SwiftTreeSitter.Node, EvaluatableExpression?>(
@@ -92,7 +92,7 @@ extension P4StringValue: CompilableExpression {
struct Expression {
public static func Compile(
node: Node, withTypesInScope: LexicalScopes
node: Node, withContext: CompilerContext
) -> Result<EvaluatableExpression> {
#RequireNodesType<Node, EvaluatableExpression>(
@@ -113,7 +113,7 @@ struct Expression {
for le_parser in localElementsParsers {
switch le_parser.compile(
node: node, withTypesInScope: withTypesInScope)
node: node, withContext: withContext)
{
case .Ok(.some(let parsed)): return .Ok(parsed)
case .Error(let e): return .Error(e)
@@ -127,7 +127,7 @@ struct Expression {
struct LValue {
public static func Compile(
node: Node, withTypesInScope: LexicalScopes
node: Node, withContext: CompilerContext
) -> Result<Common.Identifier> {
return if let node_text_value = node.text {
.Ok(Common.Identifier(name: node_text_value))
@@ -139,7 +139,7 @@ struct LValue {
struct Identifier {
public static func Compile(
node: Node, withTypesInScopes scopes: LexicalScopes
node: Node, withContext context: CompilerContext
) -> Result<Common.Identifier> {
return if let node_text_value = node.text {
.Ok(Common.Identifier(name: node_text_value))
@@ -151,9 +151,9 @@ struct Identifier {
extension SelectExpression: CompilableExpression {
static func compile(
node: Node, withTypesInScope scopes: LexicalScopes
node: Node, withContext context: CompilerContext
) -> Result<EvaluatableExpression?> {
#RequireNodeType<Node, (SelectExpression, LexicalScopes)>(
#RequireNodeType<Node, (SelectExpression, CompilerContext)>(
node: node, type: "selectExpression", nice_type_name: "parser select expression")
guard let selector_node = node.child(at: 2),
@@ -168,7 +168,7 @@ extension SelectExpression: CompilableExpression {
return .Error(ErrorOnNode(node: node, withError: "Could not find select expression body"))
}
let maybe_selector = Expression.Compile(node: selector_node, withTypesInScope: scopes)
let maybe_selector = Expression.Compile(node: selector_node, withContext: context)
guard case .Ok(let selector) = maybe_selector else {
return .Error(
Error(
@@ -182,7 +182,7 @@ extension SelectExpression: CompilableExpression {
select_body_node.enumerateNamedChildren { current_node in
let maybe_parsed_kse = KeysetExpression.compile(
node: current_node, withTypesInScope: scopes)
node: current_node, withContext: context)
if case .Ok(let parsed_kse) = maybe_parsed_kse {
kses.append(parsed_kse as! KeysetExpression)
} else {
@@ -206,7 +206,7 @@ extension SelectExpression: CompilableExpression {
extension KeysetExpression: CompilableExpression {
static func compile(
node: Node, withTypesInScope scopes: LexicalScopes
node: Node, withContext context: CompilerContext
) -> Result<EvaluatableExpression?> {
if node.nodeType != "selectCase" {
return Result.Error(Error(withMessage: "Expected select case not found"))
@@ -225,13 +225,13 @@ extension KeysetExpression: CompilableExpression {
}
let maybe_parsed_keysetexpression = Expression.Compile(
node: keysetexpression_node, withTypesInScope: scopes)
node: keysetexpression_node, withContext: context)
guard case Result.Ok(let keysetexpression) = maybe_parsed_keysetexpression else {
return Result.Error(maybe_parsed_keysetexpression.error()!)
}
let maybe_parsed_targetstate = Identifier.Compile(
node: targetstate_node, withTypesInScopes: scopes)
node: targetstate_node, withContext: context)
guard case .Ok(let targetstate) = maybe_parsed_targetstate else {
return Result.Error(maybe_parsed_targetstate.error()!)
}
Sources/P4Compiler/Parser.swift
+45 -42
View File
@@ -24,10 +24,10 @@ import TreeSitterP4
extension ParserAssignmentStatement: CompilableStatement {
public static func Compile(
node: Node, withTypesInScope scopes: LexicalScopes
) -> Result<(EvaluatableStatement, LexicalScopes)> {
node: Node, withContext context: CompilerContext
) -> Result<(EvaluatableStatement, CompilerContext)> {
#RequireNodeType<Node, (EvaluatableStatement, LexicalScopes)>(
#RequireNodeType<Node, (EvaluatableStatement, CompilerContext)>(
node: node, type: "assignmentStatement", nice_type_name: "assignment statement")
guard let lvalue_node = node.child(at: 0),
@@ -45,16 +45,16 @@ extension ParserAssignmentStatement: CompilableStatement {
}
let maybe_parsed_rvalue = Expression.Compile(
node: rvalue_node, withTypesInScope: scopes)
node: rvalue_node, withContext: context)
guard case Result.Ok(let rvalue) = maybe_parsed_rvalue else {
return Result.Error(maybe_parsed_rvalue.error()!)
}
let maybe_parsed_lvalue = LValue.Compile(node: lvalue_node, withTypesInScope: scopes)
let maybe_parsed_lvalue = LValue.Compile(node: lvalue_node, withContext: context)
guard case .Ok(let lvalue_identifier) = maybe_parsed_lvalue else {
return Result.Error(maybe_parsed_lvalue.error()!)
}
guard case Result.Ok(let lvalue_type) = scopes.lookup(identifier: lvalue_identifier) else {
guard case Result.Ok(let lvalue_type) = context.names.lookup(identifier: lvalue_identifier) else {
return Result.Error(
ErrorOnNode(
node: lvalue_node,
@@ -67,7 +67,7 @@ extension ParserAssignmentStatement: CompilableStatement {
ParserAssignmentStatement(
withLValue: TypedIdentifier(name: lvalue_node.text!, withType: lvalue_type),
withValue: rvalue
), scopes
), context
))
} else {
@@ -84,8 +84,8 @@ extension ParserAssignmentStatement: CompilableStatement {
public struct Parser {
public struct LocalElements {
static func Compile(
node: Node, withTypesInScope scopes: LexicalScopes
) -> Result<(EvaluatableStatement, LexicalScopes)> {
node: Node, withContext context: CompilerContext
) -> Result<(EvaluatableStatement, CompilerContext)> {
let localElementsParsers: [String: CompilableStatement.Type] = [
"variableDeclaration": VariableDeclarationStatement.self
]
@@ -97,7 +97,7 @@ public struct Parser {
withError: "Unparseable statement type (\(node.nodeType ?? "Unknown Statement Type"))"))
}
switch parser.Compile(node: node, withTypesInScope: scopes) {
switch parser.Compile(node: node, withContext: context) {
case Result.Ok(let (parsed, parsed_updated_scopes)):
return Result.Ok((parsed, parsed_updated_scopes))
case Result.Error(let e):
@@ -108,8 +108,8 @@ public struct Parser {
public struct Statement {
static func Compile(
node: Node, withTypesInScope scopes: LexicalScopes
) -> Result<(EvaluatableStatement, LexicalScopes)> {
node: Node, withContext context: CompilerContext
) -> Result<(EvaluatableStatement, CompilerContext)> {
if node.nodeType != "parserStatement" && node.nodeType != "statement" {
return Result.Error(ErrorOnNode(node: node, withError: "Missing expected parser statement"))
}
@@ -132,9 +132,9 @@ public struct Parser {
withError:
"Unparseable statement type (\(statement.nodeType ?? "Unknown Statement Type"))"))
}
switch parser.Compile(node: statement, withTypesInScope: scopes) {
case Result.Ok(let (parsed, updatedLexicalScopes)):
return .Ok((parsed, updatedLexicalScopes))
switch parser.Compile(node: statement, withContext: context) {
case Result.Ok(let (parsed, updated_context)):
return .Ok((parsed, updated_context))
case Result.Error(let e):
return .Error(
ErrorOnNode(node: node, withError: "Failed to parse a statement element: \(e)"))
@@ -145,10 +145,10 @@ public struct Parser {
public struct TransitionStatement {
static func Compile(
node: Node, forState state_identifier: Common.Identifier,
withStatements stmts: [EvaluatableStatement], withTypesInScope scopes: LexicalScopes
) -> Result<(ParserState, LexicalScopes)> {
withStatements stmts: [EvaluatableStatement], withContext context: CompilerContext
) -> Result<(ParserState, CompilerContext)> {
#RequireNodeType<Node, (EvaluatableStatement, LexicalScopes)>(
#RequireNodeType<Node, (EvaluatableStatement, CompilerContext)>(
node: node, type: "parserTransitionStatement", nice_type_name: "parser transition statement"
)
@@ -169,12 +169,12 @@ 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(
node: next_node, withTypesInScopes: scopes)
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), scopes
name: state_identifier, withStatements: stmts, withNextState: next_state), context
))
} else {
return .Error(
@@ -187,14 +187,14 @@ public struct Parser {
// We know that the next node is a select expression.
return
switch SelectExpression.compile(node: next_node, withTypesInScope: scopes)
switch SelectExpression.compile(node: next_node, withContext: context)
{
case .Ok(let tse):
.Ok(
(
ParserStateSelectTransition(
name: state_identifier, withStatements: stmts,
withTransitioniExpression: tse as! SelectExpression), scopes
withTransitioniExpression: tse as! SelectExpression), context
))
case .Error(let e): .Error(e)
}
@@ -203,22 +203,22 @@ public struct Parser {
public struct Statements {
static func Compile(
node: Node, withTypesInScope scopes: LexicalScopes
) -> Result<([EvaluatableStatement], LexicalScopes)> {
node: Node, withContext context: CompilerContext
) -> Result<([EvaluatableStatement], CompilerContext)> {
if node.nodeType != "statements" && node.nodeType != "parserStatements" {
return Result.Error(ErrorOnNode(node: node, withError: "Did not find expected statements"))
}
var parse_err: Error? = .none
var current_scopes = scopes
var current_context = context
var parsed_s: [EvaluatableStatement] = Array()
node.enumerateNamedChildren { node in
switch Statement.Compile(
node: node, withTypesInScope: current_scopes)
node: node, withContext: current_context)
{
case .Ok((let parsed_statement, let updated_scopes)):
current_scopes = updated_scopes
case .Ok((let parsed_statement, let updated_context)):
current_context = updated_context
parsed_s.append(parsed_statement)
case .Error(let e):
parse_err = e
@@ -228,14 +228,14 @@ public struct Parser {
if let parse_err = parse_err {
return Result.Error(parse_err)
}
return Result.Ok((parsed_s, current_scopes))
return Result.Ok((parsed_s, current_context))
}
}
public struct State {
static func Compile(
node: Node, withTypesInScope scopes: LexicalScopes
) -> Result<(ParserState, LexicalScopes)> {
node: Node, withContext context: CompilerContext
) -> Result<(ParserState, CompilerContext)> {
var currentChildIdx = 0
var currentChildIdxSafe = 1
@@ -273,7 +273,7 @@ public struct Parser {
currentChild = node.child(at: currentChildIdx)
let maybe_state_identifier = Identifier.Compile(
node: currentChild!, withTypesInScopes: scopes)
node: currentChild!, withContext: context)
guard case Result.Ok(let state_identifier) = maybe_state_identifier else {
return Result.Error(maybe_state_identifier.error()!)
}
@@ -283,7 +283,7 @@ public struct Parser {
currentChildIdxSafe += 2
var parse_err: Error? = .none
var current_scopes: LexicalScopes = LexicalScopes()
var current_context = context
var parsed_s: [EvaluatableStatement] = Array()
if node.childCount < currentChildIdxSafe {
@@ -292,11 +292,11 @@ public struct Parser {
currentChild = node.child(at: currentChildIdx)
if currentChild!.nodeType == "parserStatements" {
switch Statements.Compile(
node: currentChild!, withTypesInScope: scopes.enter())
node: currentChild!, withContext: current_context)
{
case .Ok(let (state_statements, updated_scopes)):
case .Ok(let (state_statements, updated_context)):
parsed_s = state_statements
current_scopes = updated_scopes
current_context = updated_context
case .Error(let error):
parse_err = error
}
@@ -315,31 +315,34 @@ public struct Parser {
currentChild = node.child(at: currentChildIdx)
return TransitionStatement.Compile(
node: currentChild!, forState: state_identifier, withStatements: parsed_s,
withTypesInScope: current_scopes)
withContext: current_context)
}
}
static func Compile(
withName name: Common.Identifier, node: Node,
withTypesInScope scopes: LexicalScopes
) -> Result<(P4Lang.Parser, LexicalScopes)> {
withContext context: CompilerContext
) -> Result<(P4Lang.Parser, CompilerContext)> {
var parser = P4Lang.Parser(withName: name)
// Build a state from each one listed.
var error: Error? = .none
var current_context = context
// TODO: Assert that there is only one.
node.enumerateNamedChildren { parser_state in
if parser_state.nodeType != "parserState" {
return
}
// Parse a state in a nested scope.
switch Parser.State.Compile(
node: parser_state, withTypesInScope: scopes.enter())
node: parser_state, withContext: CompilerContext(withNames: current_context.names.enter()))
{
case Result.Ok(let (state, _)):
case Result.Ok(let (state, updated_context)):
parser.states = parser.states.append(state: state)
current_context = updated_context
case Result.Error(let e): error = e
}
}
@@ -348,6 +351,6 @@ public struct Parser {
return .Error(error)
}
return Result.Ok((parser, scopes))
return Result.Ok((parser, current_context))
}
}
Sources/P4Compiler/Program.swift
+8 -7
View File
@@ -40,8 +40,8 @@ public struct Program {
var program = P4Lang.Program()
// Set up a lexical scope for parsing.
var program_scope = LexicalScopes().enter()
// Set up a context for parsing.
var compilation_context = CompilerContext(withNames: LexicalScopes().enter())
var errors: [Error] = Array()
@@ -107,7 +107,7 @@ public struct Program {
}
currentChild = type_node?.child(at: currentChildIdx)
switch Identifier.Compile(node: currentChild!, withTypesInScopes: program_scope) {
switch Identifier.Compile(node: currentChild!, withContext: compilation_context) {
case .Ok(let id): parser_name = id
case .Error(let e):
errors.append(e)
@@ -164,10 +164,11 @@ public struct Program {
}
switch Parser.Compile(
withName: parser_name!, node: currentChild!, withTypesInScope: program_scope)
withName: parser_name!, node: currentChild!, withContext: compilation_context)
{
case Result.Ok((let parser, let new_program_scope)):
program_scope = new_program_scope.declare(identifier: parser.name, withValue: parser)
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))
case Result.Error(let error): errors.append(error)
}
@@ -183,7 +184,7 @@ public struct Program {
}
// Any of the types that are in the top-level scope should go into the program!
program.types = Array(program_scope)
program.types = Array(compilation_context.names)
return Result.Ok(program)
}
}
Sources/P4Compiler/Protocols.swift
+2 -2
View File
@@ -24,8 +24,8 @@ import TreeSitterP4
public protocol CompilableStatement {
static func Compile(
node: Node, withTypesInScope scopes: LexicalScopes
) -> Result<(EvaluatableStatement, LexicalScopes)>
node: Node, withContext context: CompilerContext
) -> Result<(EvaluatableStatement, CompilerContext)>
}
public protocol CompilableValue {
Sources/P4Compiler/Statement.swift
+29 -28
View File
@@ -24,9 +24,9 @@ import TreeSitterP4
extension BlockStatement: CompilableStatement {
public static func Compile(
node: Node, withTypesInScope scopes: LexicalScopes
) -> Result<(EvaluatableStatement, LexicalScopes)> {
#RequireNodeType<Node, (EvaluatableStatement, LexicalScopes)>(
node: Node, withContext context: CompilerContext
) -> Result<(EvaluatableStatement, CompilerContext)> {
#RequireNodeType<Node, (EvaluatableStatement, CompilerContext)>(
node: node, type: "blockStatement", nice_type_name: "block statement")
var currentChildIdx = 0
@@ -47,7 +47,7 @@ extension BlockStatement: CompilableStatement {
var statements: [EvaluatableStatement] = Array()
var parse_err: Error? = .none
var new_scopes: LexicalScopes = LexicalScopes()
var current_context = context
if node.childCount < currentChildIdxSafe {
return Result.Error(
@@ -56,10 +56,10 @@ extension BlockStatement: CompilableStatement {
currentChild = node.child(at: currentChildIdx)
if currentChild!.nodeType == "statements" {
switch Parser.Statements.Compile(
node: currentChild!, withTypesInScope: scopes.enter())
node: currentChild!, withContext: current_context)
{
case .Ok(let (parsed_statements, parsed_scopes)):
new_scopes = parsed_scopes
case .Ok(let (parsed_statements, updated_context)):
current_context = updated_context
statements = parsed_statements
case .Error(let error):
parse_err = error
@@ -83,16 +83,16 @@ extension BlockStatement: CompilableStatement {
ErrorOnNode(node: currentChild!, withError: "Missing } on block statement"))
}
return .Ok((BlockStatement(statements), new_scopes))
return .Ok((BlockStatement(statements), current_context))
}
}
extension ConditionalStatement: CompilableStatement {
public static func Compile(
node: Node, withTypesInScope scopes: LexicalScopes
) -> Result<(EvaluatableStatement, LexicalScopes)> {
node: Node, withContext context: CompilerContext
) -> Result<(EvaluatableStatement, CompilerContext)> {
#RequireNodeType<Node, (EvaluatableStatement, LexicalScopes)>(
#RequireNodeType<Node, (EvaluatableStatement, CompilerContext)>(
node: node, type: "conditionalStatement", nice_type_name: "conditional statement")
let maybe_condition_expression = node.child(at: 2)
@@ -114,7 +114,7 @@ extension ConditionalStatement: CompilableStatement {
guard
case .Ok(let condition) = Expression.Compile(
node: condition_expression, withTypesInScope: scopes)
node: condition_expression, withContext: context)
else {
return Result.Error(
Error(withMessage: "Could not parse a conditional expression in a conditional statement"))
@@ -122,7 +122,7 @@ extension ConditionalStatement: CompilableStatement {
guard
case .Ok((let thenns, _)) = Parser.Statement.Compile(
node: thens, withTypesInScope: scopes)
node: thens, withContext: context)
else {
return Result.Error(
Error(
@@ -130,11 +130,11 @@ extension ConditionalStatement: CompilableStatement {
"Could not parse the then block in a conditional statement"))
}
let optional_elss: Result<(any EvaluatableStatement, LexicalScopes)>? =
let optional_elss: Result<(any EvaluatableStatement, CompilerContext)>? =
if let elss = node.child(at: 6) {
.some(
Parser.Statement.Compile(
node: elss, withTypesInScope: scopes))
node: elss, withContext: context))
} else {
.none
}
@@ -149,18 +149,18 @@ extension ConditionalStatement: CompilableStatement {
"Could not parse the else block in a conditional statement"))
}
return .Ok(
(ConditionalStatement(condition: condition, withThen: thenns, andElse: elss), scopes))
(ConditionalStatement(condition: condition, withThen: thenns, andElse: elss), context))
}
return .Ok((ConditionalStatement(condition: condition, withThen: thenns), scopes))
return .Ok((ConditionalStatement(condition: condition, withThen: thenns), context))
}
}
extension VariableDeclarationStatement: CompilableStatement {
public static func Compile(
node: Node, withTypesInScope scopes: LexicalScopes
) -> Result<(EvaluatableStatement, LexicalScopes)> {
node: Node, withContext context: CompilerContext
) -> Result<(EvaluatableStatement, CompilerContext)> {
#RequireNodeType<Node, (EvaluatableStatement, LexicalScopes)>(
#RequireNodeType<Node, (EvaluatableStatement, CompilerContext)>(
node: node, type: "variableDeclaration", nice_type_name: "variable declaration statement")
let maybe_typeref = node.child(at: 0)
@@ -193,7 +193,7 @@ extension VariableDeclarationStatement: CompilableStatement {
guard
case .Ok(let parsed_variablename) = Identifier.Compile(
node: variablename, withTypesInScopes: scopes.enter())
node: variablename, withContext: context)
else {
return Result.Error(
Error(withMessage: "Could not parse variable name"))
@@ -201,7 +201,7 @@ extension VariableDeclarationStatement: CompilableStatement {
guard
case .Ok(let parsed_rvalue) = Expression.Compile(
node: rvalue, withTypesInScope: scopes.enter())
node: rvalue, withContext: context)
else {
return Result.Error(
Error(
@@ -219,8 +219,9 @@ extension VariableDeclarationStatement: CompilableStatement {
(
VariableDeclarationStatement(
identifier: parsed_variablename, withInitializer: parsed_rvalue),
scopes.declare(
identifier: parsed_variablename, withValue: declaration_p4_type)
// Context with updated names to include the newly declared name.
CompilerContext(withNames: context.names.declare(
identifier: parsed_variablename, withValue: declaration_p4_type))
))
} else {
@@ -236,13 +237,13 @@ extension VariableDeclarationStatement: CompilableStatement {
extension ExpressionStatement: CompilableStatement {
public static func Compile(
node: Node, withTypesInScope scopes: LexicalScopes
) -> Result<(EvaluatableStatement, LexicalScopes)> {
#RequireNodeType<Node, (EvaluatableStatement, LexicalScopes)>(
node: Node, withContext context: CompilerContext
) -> Result<(EvaluatableStatement, CompilerContext)> {
#RequireNodeType<Node, (EvaluatableStatement, CompilerContext)>(
node: node, type: "expressionStatement", nice_type_name: "expression statement")
let _ = node.child(at: 0)
return Result.Ok((ExpressionStatement(), scopes))
return Result.Ok((ExpressionStatement(), context))
}
}
Tests/p4rseTests/ParserTests.swift
+2 -2
View File
@@ -111,8 +111,8 @@ import P4Lang
let result = try! #require(p.parse(simple))
#expect(
#RequireErrorResult<(EvaluatableStatement, LexicalScopes)>(
#RequireErrorResult<(EvaluatableStatement, CompilerContext)>(
Error(withMessage: "{2, 154}: Did not find assignment statement"),
ParserAssignmentStatement.Compile(
node: result.rootNode!, withTypesInScope: LexicalScopes())))
node: result.rootNode!, withContext: CompilerContext(withNames: LexicalScopes()))))
}