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

Refactor Parser Interfaces

Browse Source 
Do not pass around the MutableTree -- now that we are not
using queries for walking the AST, it is unnecessary.

Signed-off-by: Will Hawkins <hawkinsw@obs.cr>
This commit is contained in:
Will Hawkins
2026-03-10 05:50:28 -04:00
parent 829bfb6ac8
commit 4269104379
4 changed files with 72 additions and 68 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Sources/P4Compiler/Expression.swift
+15 -19
View File
@@ -22,14 +22,13 @@ import TreeSitterP4
protocol CompilableExpression { protocol CompilableExpression {
static func compile( static func compile(
node: Node, inTree tree: MutableTree, withScopes scopes: LexicalScopes node: Node, withTypesInScope scopes: LexicalScopes
) -> Result<EvaluatableExpression?> ) -> Result<EvaluatableExpression?>
} }
extension TypedIdentifier: CompilableExpression { extension TypedIdentifier: CompilableExpression {
static func compile( static func compile(
node: SwiftTreeSitter.Node, inTree tree: SwiftTreeSitter.MutableTree, node: SwiftTreeSitter.Node, withTypesInScope scopes: LexicalScopes
withScopes scopes: LexicalScopes
) -> Result<EvaluatableExpression?> { ) -> Result<EvaluatableExpression?> {
let node = node.child(at: 0)! let node = node.child(at: 0)!
@@ -49,8 +48,7 @@ extension TypedIdentifier: CompilableExpression {
extension P4BooleanValue: CompilableExpression { extension P4BooleanValue: CompilableExpression {
static func compile( static func compile(
node: SwiftTreeSitter.Node, inTree tree: SwiftTreeSitter.MutableTree, node: SwiftTreeSitter.Node, withTypesInScope scopes: LexicalScopes
withScopes scopes: LexicalScopes
) -> Result<EvaluatableExpression?> { ) -> Result<EvaluatableExpression?> {
let node = node.child(at: 0)! let node = node.child(at: 0)!
#SkipUnlessNodeType<SwiftTreeSitter.Node, EvaluatableExpression?>( #SkipUnlessNodeType<SwiftTreeSitter.Node, EvaluatableExpression?>(
@@ -69,8 +67,7 @@ extension P4BooleanValue: CompilableExpression {
extension P4IntValue: CompilableExpression { extension P4IntValue: CompilableExpression {
static func compile( static func compile(
node: SwiftTreeSitter.Node, inTree tree: SwiftTreeSitter.MutableTree, node: SwiftTreeSitter.Node, withTypesInScope scopes: LexicalScopes
withScopes scopes: LexicalScopes
) -> Result<EvaluatableExpression?> { ) -> Result<EvaluatableExpression?> {
let node = node.child(at: 0)! let node = node.child(at: 0)!
#SkipUnlessNodeType<SwiftTreeSitter.Node, EvaluatableExpression?>(node: node, type: "integer") #SkipUnlessNodeType<SwiftTreeSitter.Node, EvaluatableExpression?>(node: node, type: "integer")
@@ -84,8 +81,7 @@ extension P4IntValue: CompilableExpression {
extension P4StringValue: CompilableExpression { extension P4StringValue: CompilableExpression {
static func compile( static func compile(
node: SwiftTreeSitter.Node, inTree tree: SwiftTreeSitter.MutableTree, node: SwiftTreeSitter.Node, withTypesInScope scopes: LexicalScopes
withScopes scopes: LexicalScopes
) -> Result<EvaluatableExpression?> { ) -> Result<EvaluatableExpression?> {
let node = node.child(at: 0)! let node = node.child(at: 0)!
#SkipUnlessNodeType<SwiftTreeSitter.Node, EvaluatableExpression?>( #SkipUnlessNodeType<SwiftTreeSitter.Node, EvaluatableExpression?>(
@@ -96,7 +92,7 @@ extension P4StringValue: CompilableExpression {
struct Expression { struct Expression {
public static func Compile( public static func Compile(
node: Node, inTree: MutableTree, withScopes scopes: LexicalScopes node: Node, withTypesInScope: LexicalScopes
) -> Result<EvaluatableExpression> { ) -> Result<EvaluatableExpression> {
#RequireNodesType<Node, EvaluatableExpression>( #RequireNodesType<Node, EvaluatableExpression>(
@@ -117,7 +113,7 @@ struct Expression {
for le_parser in localElementsParsers { for le_parser in localElementsParsers {
switch le_parser.compile( switch le_parser.compile(
node: node, inTree: inTree, withScopes: scopes) node: node, withTypesInScope: withTypesInScope)
{ {
case .Ok(.some(let parsed)): return .Ok(parsed) case .Ok(.some(let parsed)): return .Ok(parsed)
case .Error(let e): return .Error(e) case .Error(let e): return .Error(e)
@@ -131,7 +127,7 @@ struct Expression {
struct LValue { struct LValue {
public static func Compile( public static func Compile(
node: Node, inTree: MutableTree, withScopes scopes: LexicalScopes node: Node, withTypesInScope: LexicalScopes
) -> Result<Common.Identifier> { ) -> Result<Common.Identifier> {
return if let node_text_value = node.text { return if let node_text_value = node.text {
.Ok(Common.Identifier(name: node_text_value)) .Ok(Common.Identifier(name: node_text_value))
@@ -143,7 +139,7 @@ struct LValue {
struct Identifier { struct Identifier {
public static func Compile( public static func Compile(
node: Node, inTree: MutableTree, withScopes scopes: LexicalScopes node: Node, withTypesInScopes scopes: LexicalScopes
) -> Result<Common.Identifier> { ) -> Result<Common.Identifier> {
return if let node_text_value = node.text { return if let node_text_value = node.text {
.Ok(Common.Identifier(name: node_text_value)) .Ok(Common.Identifier(name: node_text_value))
@@ -155,7 +151,7 @@ struct Identifier {
extension SelectExpression: CompilableExpression { extension SelectExpression: CompilableExpression {
static func compile( static func compile(
node: Node, inTree tree: MutableTree, withScopes scopes: LexicalScopes node: Node, withTypesInScope scopes: LexicalScopes
) -> Result<EvaluatableExpression?> { ) -> Result<EvaluatableExpression?> {
#RequireNodeType<Node, (SelectExpression, LexicalScopes)>( #RequireNodeType<Node, (SelectExpression, LexicalScopes)>(
node: node, type: "selectExpression", nice_type_name: "parser select expression") node: node, type: "selectExpression", nice_type_name: "parser select expression")
@@ -172,7 +168,7 @@ extension SelectExpression: CompilableExpression {
return .Error(ErrorOnNode(node: node, withError: "Could not find select expression body")) return .Error(ErrorOnNode(node: node, withError: "Could not find select expression body"))
} }
let maybe_selector = Expression.Compile(node: selector_node, inTree: tree, withScopes: scopes) let maybe_selector = Expression.Compile(node: selector_node, withTypesInScope: scopes)
guard case .Ok(let selector) = maybe_selector else { guard case .Ok(let selector) = maybe_selector else {
return .Error( return .Error(
Error( Error(
@@ -186,7 +182,7 @@ extension SelectExpression: CompilableExpression {
select_body_node.enumerateNamedChildren { current_node in select_body_node.enumerateNamedChildren { current_node in
let maybe_parsed_kse = KeysetExpression.compile( let maybe_parsed_kse = KeysetExpression.compile(
node: current_node, inTree: tree, withScopes: scopes) node: current_node, withTypesInScope: scopes)
if case .Ok(let parsed_kse) = maybe_parsed_kse { if case .Ok(let parsed_kse) = maybe_parsed_kse {
kses.append(parsed_kse as! KeysetExpression) kses.append(parsed_kse as! KeysetExpression)
} else { } else {
@@ -210,7 +206,7 @@ extension SelectExpression: CompilableExpression {
extension KeysetExpression: CompilableExpression { extension KeysetExpression: CompilableExpression {
static func compile( static func compile(
node: Node, inTree tree: MutableTree, withScopes scopes: LexicalScopes node: Node, withTypesInScope scopes: LexicalScopes
) -> Result<EvaluatableExpression?> { ) -> Result<EvaluatableExpression?> {
if node.nodeType != "selectCase" { if node.nodeType != "selectCase" {
return Result.Error(Error(withMessage: "Expected select case not found")) return Result.Error(Error(withMessage: "Expected select case not found"))
@@ -229,13 +225,13 @@ extension KeysetExpression: CompilableExpression {
} }
let maybe_parsed_keysetexpression = Expression.Compile( let maybe_parsed_keysetexpression = Expression.Compile(
node: keysetexpression_node, inTree: tree, withScopes: scopes) node: keysetexpression_node, withTypesInScope: scopes)
guard case Result.Ok(let keysetexpression) = maybe_parsed_keysetexpression else { guard case Result.Ok(let keysetexpression) = maybe_parsed_keysetexpression else {
return Result.Error(maybe_parsed_keysetexpression.error()!) return Result.Error(maybe_parsed_keysetexpression.error()!)
} }
let maybe_parsed_targetstate = Identifier.Compile( let maybe_parsed_targetstate = Identifier.Compile(
node: targetstate_node, inTree: tree, withScopes: scopes) node: targetstate_node, withTypesInScopes: scopes)
guard case .Ok(let targetstate) = maybe_parsed_targetstate else { guard case .Ok(let targetstate) = maybe_parsed_targetstate else {
return Result.Error(maybe_parsed_targetstate.error()!) return Result.Error(maybe_parsed_targetstate.error()!)
} }
Sources/P4Compiler/Parser.swift
+46 -38
View File
@@ -24,7 +24,7 @@ import TreeSitterP4
extension ParserAssignmentStatement: CompilableStatement { extension ParserAssignmentStatement: CompilableStatement {
public static func Compile( public static func Compile(
node: Node, inTree tree: MutableTree, withScopes scopes: LexicalScopes node: Node, withTypesInScope scopes: LexicalScopes
) -> Result<(EvaluatableStatement, LexicalScopes)> { ) -> Result<(EvaluatableStatement, LexicalScopes)> {
#RequireNodeType<Node, (EvaluatableStatement, LexicalScopes)>( #RequireNodeType<Node, (EvaluatableStatement, LexicalScopes)>(
@@ -45,12 +45,12 @@ extension ParserAssignmentStatement: CompilableStatement {
} }
let maybe_parsed_rvalue = Expression.Compile( let maybe_parsed_rvalue = Expression.Compile(
node: rvalue_node, inTree: tree, withScopes: scopes) node: rvalue_node, withTypesInScope: scopes)
guard case Result.Ok(let rvalue) = maybe_parsed_rvalue else { guard case Result.Ok(let rvalue) = maybe_parsed_rvalue else {
return Result.Error(maybe_parsed_rvalue.error()!) return Result.Error(maybe_parsed_rvalue.error()!)
} }
let maybe_parsed_lvalue = LValue.Compile(node: lvalue_node, inTree: tree, withScopes: scopes) let maybe_parsed_lvalue = LValue.Compile(node: lvalue_node, withTypesInScope: scopes)
guard case .Ok(let lvalue_identifier) = maybe_parsed_lvalue else { guard case .Ok(let lvalue_identifier) = maybe_parsed_lvalue else {
return Result.Error(maybe_parsed_lvalue.error()!) return Result.Error(maybe_parsed_lvalue.error()!)
} }
@@ -84,7 +84,7 @@ extension ParserAssignmentStatement: CompilableStatement {
public struct Parser { public struct Parser {
public struct LocalElements { public struct LocalElements {
static func Compile( static func Compile(
node: Node, inTree tree: MutableTree, withScope scopes: LexicalScopes node: Node, withTypesInScope scopes: LexicalScopes
) -> Result<(EvaluatableStatement, LexicalScopes)> { ) -> Result<(EvaluatableStatement, LexicalScopes)> {
let localElementsParsers: [String: CompilableStatement.Type] = [ let localElementsParsers: [String: CompilableStatement.Type] = [
"variableDeclaration": VariableDeclarationStatement.self "variableDeclaration": VariableDeclarationStatement.self
@@ -97,7 +97,7 @@ public struct Parser {
withError: "Unparseable statement type (\(node.nodeType ?? "Unknown Statement Type"))")) withError: "Unparseable statement type (\(node.nodeType ?? "Unknown Statement Type"))"))
} }
switch parser.Compile(node: node, inTree: tree, withScopes: scopes) { switch parser.Compile(node: node, withTypesInScope: scopes) {
case Result.Ok(let (parsed, parsed_updated_scopes)): case Result.Ok(let (parsed, parsed_updated_scopes)):
return Result.Ok((parsed, parsed_updated_scopes)) return Result.Ok((parsed, parsed_updated_scopes))
case Result.Error(let e): case Result.Error(let e):
@@ -108,7 +108,7 @@ public struct Parser {
public struct Statement { public struct Statement {
static func Compile( static func Compile(
node: Node, inTree tree: MutableTree, withScope scopes: LexicalScopes node: Node, withTypesInScope scopes: LexicalScopes
) -> Result<(EvaluatableStatement, LexicalScopes)> { ) -> Result<(EvaluatableStatement, LexicalScopes)> {
if node.nodeType != "parserStatement" && node.nodeType != "statement" { if node.nodeType != "parserStatement" && node.nodeType != "statement" {
return Result.Error(ErrorOnNode(node: node, withError: "Missing expected parser statement")) return Result.Error(ErrorOnNode(node: node, withError: "Missing expected parser statement"))
@@ -132,7 +132,7 @@ public struct Parser {
withError: withError:
"Unparseable statement type (\(statement.nodeType ?? "Unknown Statement Type"))")) "Unparseable statement type (\(statement.nodeType ?? "Unknown Statement Type"))"))
} }
switch parser.Compile(node: statement, inTree: tree, withScopes: scopes) { switch parser.Compile(node: statement, withTypesInScope: scopes) {
case Result.Ok(let (parsed, updatedLexicalScopes)): case Result.Ok(let (parsed, updatedLexicalScopes)):
return .Ok((parsed, updatedLexicalScopes)) return .Ok((parsed, updatedLexicalScopes))
case Result.Error(let e): case Result.Error(let e):
@@ -144,7 +144,7 @@ public struct Parser {
public struct TransitionStatement { public struct TransitionStatement {
static func Compile( static func Compile(
node: Node, inTree tree: MutableTree, forState state_identifier: Common.Identifier, withStatements stmts: [EvaluatableStatement], withScope scopes: LexicalScopes node: Node, forState state_identifier: Common.Identifier, withStatements stmts: [EvaluatableStatement], withTypesInScope scopes: LexicalScopes
) -> Result<(ParserState, LexicalScopes)> { ) -> Result<(ParserState, LexicalScopes)> {
#RequireNodeType<Node, (EvaluatableStatement, LexicalScopes)>( #RequireNodeType<Node, (EvaluatableStatement, LexicalScopes)>(
@@ -168,7 +168,7 @@ public struct Parser {
// If the next node is an identifier, we have the simple form ... // If the next node is an identifier, we have the simple form ...
if next_node.nodeType == "identifier" { if next_node.nodeType == "identifier" {
let maybe_parsed_next_state = Identifier.Compile( let maybe_parsed_next_state = Identifier.Compile(
node: next_node, inTree: tree, withScopes: scopes) node: next_node, withTypesInScopes: scopes)
if case .Ok(let next_state) = maybe_parsed_next_state { if case .Ok(let next_state) = maybe_parsed_next_state {
return .Ok( return .Ok(
(ParserStateDirectTransition(name: state_identifier, withStatements: stmts, withNextState: next_state), scopes)) (ParserStateDirectTransition(name: state_identifier, withStatements: stmts, withNextState: next_state), scopes))
@@ -183,7 +183,7 @@ public struct Parser {
// We know that the next node is a select expression. // We know that the next node is a select expression.
return return
switch SelectExpression.compile(node: next_node, inTree: tree, withScopes: scopes) switch SelectExpression.compile(node: next_node, withTypesInScope: scopes)
{ {
case .Ok(let tse): case .Ok(let tse):
.Ok( .Ok(
@@ -195,7 +195,7 @@ public struct Parser {
public struct Statements { public struct Statements {
static func Compile( static func Compile(
node: Node, inTree tree: MutableTree, withLexicalScopes scopes: LexicalScopes node: Node, withTypesInScope scopes: LexicalScopes
) -> Result<([EvaluatableStatement], LexicalScopes)> { ) -> Result<([EvaluatableStatement], LexicalScopes)> {
if node.nodeType != "statements" && node.nodeType != "parserStatements" { if node.nodeType != "statements" && node.nodeType != "parserStatements" {
return Result.Error(ErrorOnNode(node: node, withError: "Did not find expected statements")) return Result.Error(ErrorOnNode(node: node, withError: "Did not find expected statements"))
@@ -207,7 +207,7 @@ public struct Parser {
node.enumerateNamedChildren { node in node.enumerateNamedChildren { node in
switch Statement.Compile( switch Statement.Compile(
node: node, inTree: tree, withScope: current_scopes) node: node, withTypesInScope: current_scopes)
{ {
case .Ok((let parsed_statement, let updated_scopes)): case .Ok((let parsed_statement, let updated_scopes)):
current_scopes = updated_scopes current_scopes = updated_scopes
@@ -226,11 +226,11 @@ public struct Parser {
public struct State { public struct State {
static func Compile( static func Compile(
node: Node, inTree tree: MutableTree, withLexicalScopes scopes: LexicalScopes node: Node, withTypesInScope scopes: LexicalScopes
) -> Result<(ParserState, LexicalScopes)> { ) -> Result<(ParserState, LexicalScopes)> {
var currentChildIdx = 1 var currentChildIdx = 0
var currentChildIdxSafe = 2 var currentChildIdxSafe = 1
var currentChild: Node? = .none var currentChild: Node? = .none
@@ -243,11 +243,29 @@ public struct Parser {
if node.childCount < currentChildIdxSafe { if node.childCount < currentChildIdxSafe {
return Result.Error( return Result.Error(
ErrorOnNode(node: node, withError: "Missing state name in state declaration")) ErrorOnNode(node: node, withError: "Missing elements in parser state declaration"))
} }
currentChild = node.child(at: 1)
currentChild = node.child(at: currentChildIdx)
if currentChild!.nodeType == "annotations" {
return Result.Error(
ErrorOnNode(node: currentChild!, withError: "Annotations in parser state are not yet handled."))
// Would increment here.
}
// Skip the keyword state
currentChildIdx += 1
currentChildIdxSafe += 1
if node.childCount < currentChildIdxSafe {
return Result.Error(
ErrorOnNode(node: node, withError: "Missing elements in parser state declaration"))
}
currentChild = node.child(at: currentChildIdx)
let maybe_state_identifier = Identifier.Compile( let maybe_state_identifier = Identifier.Compile(
node: currentChild!, inTree: tree, withScopes: scopes) node: currentChild!, withTypesInScopes: scopes)
guard case Result.Ok(let state_identifier) = maybe_state_identifier else { guard case Result.Ok(let state_identifier) = maybe_state_identifier else {
return Result.Error(maybe_state_identifier.error()!) return Result.Error(maybe_state_identifier.error()!)
} }
@@ -266,7 +284,7 @@ public struct Parser {
currentChild = node.child(at: currentChildIdx) currentChild = node.child(at: currentChildIdx)
if currentChild!.nodeType == "parserStatements" { if currentChild!.nodeType == "parserStatements" {
switch Statements.Compile( switch Statements.Compile(
node: currentChild!, inTree: tree, withLexicalScopes: scopes.enter()) node: currentChild!, withTypesInScope: scopes.enter())
{ {
case .Ok(let (state_statements, updated_scopes)): case .Ok(let (state_statements, updated_scopes)):
parsed_s = state_statements parsed_s = state_statements
@@ -288,38 +306,28 @@ public struct Parser {
} }
currentChild = node.child(at: currentChildIdx) currentChild = node.child(at: currentChildIdx)
return TransitionStatement.Compile( return TransitionStatement.Compile(
node: currentChild!, inTree: tree, forState: state_identifier, withStatements: parsed_s, withScope: current_scopes) node: currentChild!, forState: state_identifier, withStatements: parsed_s, withTypesInScope: current_scopes)
} }
} }
static func Compile( static func Compile(
withName name: Common.Identifier, node: Node, inTree tree: MutableTree, withName name: Common.Identifier, node: Node,
withLexicalScopes scopes: LexicalScopes withTypesInScope scopes: LexicalScopes
) -> Result<(P4Lang.Parser, LexicalScopes)> { ) -> Result<(P4Lang.Parser, LexicalScopes)> {
guard
let parser_state_query = try? SwiftTreeSitter.Query(
language: p4lang,
data: String(
"(parserStates) @parser-states"
).data(using: String.Encoding.utf8)!)
else {
return Result.Error(
Error(withMessage: "Could not compile the parser state tree sitter query"))
}
var parser = P4Lang.Parser(withName: name) var parser = P4Lang.Parser(withName: name)
// Build a state from each one listed. // Build a state from each one listed.
let qr = parser_state_query.execute(node: node, in: tree)
let qr_value = qr.next()!
let captures = qr_value.captures(named: "parser-states")
var error: Error? = .none var error: Error? = .none
// TODO: Assert that there is only one. // TODO: Assert that there is only one.
captures[0].node.enumerateChildren { parser_state in node.enumerateNamedChildren() { parser_state in
if parser_state.nodeType != "parserState" {
return
}
switch Parser.State.Compile( switch Parser.State.Compile(
node: parser_state, inTree: tree, withLexicalScopes: scopes.enter()) node: parser_state, withTypesInScope: scopes.enter())
{ {
case Result.Ok(let (state, _)): case Result.Ok(let (state, _)):
parser.states = parser.states.append(state: state) parser.states = parser.states.append(state: state)
Sources/P4Compiler/Protocols.swift
+1 -1
View File
@@ -24,7 +24,7 @@ import TreeSitterP4
public protocol CompilableStatement { public protocol CompilableStatement {
static func Compile( static func Compile(
node: Node, inTree tree: MutableTree, withScopes scopes: LexicalScopes node: Node, withTypesInScope scopes: LexicalScopes
) -> Result<(EvaluatableStatement, LexicalScopes)> ) -> Result<(EvaluatableStatement, LexicalScopes)>
} }
Sources/P4Compiler/Statement.swift
+10 -10
View File
@@ -24,7 +24,7 @@ import TreeSitterP4
extension BlockStatement: CompilableStatement { extension BlockStatement: CompilableStatement {
public static func Compile( public static func Compile(
node: Node, inTree tree: MutableTree, withScopes scopes: LexicalScopes node: Node, withTypesInScope scopes: LexicalScopes
) -> Result<(EvaluatableStatement, LexicalScopes)> { ) -> Result<(EvaluatableStatement, LexicalScopes)> {
#RequireNodeType<Node, (EvaluatableStatement, LexicalScopes)>( #RequireNodeType<Node, (EvaluatableStatement, LexicalScopes)>(
node: node, type: "blockStatement", nice_type_name: "block statement") node: node, type: "blockStatement", nice_type_name: "block statement")
@@ -56,7 +56,7 @@ extension BlockStatement: CompilableStatement {
currentChild = node.child(at: currentChildIdx) currentChild = node.child(at: currentChildIdx)
if currentChild!.nodeType == "statements" { if currentChild!.nodeType == "statements" {
switch Parser.Statements.Compile( switch Parser.Statements.Compile(
node: currentChild!, inTree: tree, withLexicalScopes: scopes.enter()) node: currentChild!, withTypesInScope: scopes.enter())
{ {
case .Ok(let (parsed_statements, parsed_scopes)): case .Ok(let (parsed_statements, parsed_scopes)):
new_scopes = parsed_scopes new_scopes = parsed_scopes
@@ -89,7 +89,7 @@ extension BlockStatement: CompilableStatement {
extension ConditionalStatement: CompilableStatement { extension ConditionalStatement: CompilableStatement {
public static func Compile( public static func Compile(
node: Node, inTree tree: MutableTree, withScopes scopes: LexicalScopes node: Node, withTypesInScope scopes: LexicalScopes
) -> Result<(EvaluatableStatement, LexicalScopes)> { ) -> Result<(EvaluatableStatement, LexicalScopes)> {
#RequireNodeType<Node, (EvaluatableStatement, LexicalScopes)>( #RequireNodeType<Node, (EvaluatableStatement, LexicalScopes)>(
@@ -114,7 +114,7 @@ extension ConditionalStatement: CompilableStatement {
guard guard
case .Ok(let condition) = Expression.Compile( case .Ok(let condition) = Expression.Compile(
node: condition_expression, inTree: tree, withScopes: scopes) node: condition_expression, withTypesInScope: scopes)
else { else {
return Result.Error( return Result.Error(
Error(withMessage: "Could not parse a conditional expression in a conditional statement")) Error(withMessage: "Could not parse a conditional expression in a conditional statement"))
@@ -122,7 +122,7 @@ extension ConditionalStatement: CompilableStatement {
guard guard
case .Ok((let thenns, _)) = Parser.Statement.Compile( case .Ok((let thenns, _)) = Parser.Statement.Compile(
node: thens, inTree: tree, withScope: scopes) node: thens, withTypesInScope: scopes)
else { else {
return Result.Error( return Result.Error(
Error( Error(
@@ -134,7 +134,7 @@ extension ConditionalStatement: CompilableStatement {
if let elss = node.child(at: 6) { if let elss = node.child(at: 6) {
.some( .some(
Parser.Statement.Compile( Parser.Statement.Compile(
node: elss, inTree: tree, withScope: scopes)) node: elss, withTypesInScope: scopes))
} else { } else {
.none .none
} }
@@ -157,7 +157,7 @@ extension ConditionalStatement: CompilableStatement {
extension VariableDeclarationStatement: CompilableStatement { extension VariableDeclarationStatement: CompilableStatement {
public static func Compile( public static func Compile(
node: Node, inTree tree: MutableTree, withScopes scopes: LexicalScopes node: Node, withTypesInScope scopes: LexicalScopes
) -> Result<(EvaluatableStatement, LexicalScopes)> { ) -> Result<(EvaluatableStatement, LexicalScopes)> {
#RequireNodeType<Node, (EvaluatableStatement, LexicalScopes)>( #RequireNodeType<Node, (EvaluatableStatement, LexicalScopes)>(
@@ -193,7 +193,7 @@ extension VariableDeclarationStatement: CompilableStatement {
guard guard
case .Ok(let parsed_variablename) = Identifier.Compile( case .Ok(let parsed_variablename) = Identifier.Compile(
node: variablename, inTree: tree, withScopes: scopes.enter()) node: variablename, withTypesInScopes: scopes.enter())
else { else {
return Result.Error( return Result.Error(
Error(withMessage: "Could not parse variable name")) Error(withMessage: "Could not parse variable name"))
@@ -201,7 +201,7 @@ extension VariableDeclarationStatement: CompilableStatement {
guard guard
case .Ok(let parsed_rvalue) = Expression.Compile( case .Ok(let parsed_rvalue) = Expression.Compile(
node: rvalue, inTree: tree, withScopes: scopes.enter()) node: rvalue, withTypesInScope: scopes.enter())
else { else {
return Result.Error( return Result.Error(
Error( Error(
@@ -236,7 +236,7 @@ extension VariableDeclarationStatement: CompilableStatement {
extension ExpressionStatement: CompilableStatement { extension ExpressionStatement: CompilableStatement {
public static func Compile( public static func Compile(
node: Node, inTree tree: MutableTree, withScopes scopes: LexicalScopes node: Node, withTypesInScope scopes: LexicalScopes
) -> Result<(EvaluatableStatement, LexicalScopes)> { ) -> Result<(EvaluatableStatement, LexicalScopes)> {
#RequireNodeType<Node, (EvaluatableStatement, LexicalScopes)>( #RequireNodeType<Node, (EvaluatableStatement, LexicalScopes)>(
node: node, type: "expressionStatement", nice_type_name: "expression statement") node: node, type: "expressionStatement", nice_type_name: "expression statement")