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

Make Formatter Happy

Browse Source 
Signed-off-by: Will Hawkins <hawkinsw@obs.cr>
This commit is contained in:
Will Hawkins
2026-03-06 08:03:07 -05:00
parent c3b3be77eb
commit f96350f89d
5 changed files with 79 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Sources/Common/Support.swift
+3 -1
View File
@@ -143,7 +143,9 @@ extension Result: CustomStringConvertible {
#externalMacro(module: "Macros", type: "UseErrorResult")
@freestanding(codeItem) public macro RequireNodeType<N, T>(node: N, type: String, msg: String) =
#externalMacro(module: "Macros", type: "RequireNodeType")
@freestanding(codeItem) public macro RequireNodesType<N, T>(nodes: N, type: [String], msg: [String]) =
@freestanding(codeItem) public macro RequireNodesType<N, T>(
nodes: N, type: [String], msg: [String]
) =
#externalMacro(module: "Macros", type: "RequireNodesType")
@freestanding(codeItem) public macro SkipUnlessNodeType<N, T>(node: N, type: String) =
#externalMacro(module: "Macros", type: "SkipUnlessNodeType")
Sources/Macros/Macros.swift
+29 -16
View File
@@ -26,10 +26,8 @@ public func remove_embedded_quotes(_ from: String) -> String {
struct MacroError: Error, CustomStringConvertible {
var message: String
var description: String {
get {
return message
}
}
public init(withMessage _message: String) {
message = _message
}
@@ -138,7 +136,9 @@ public struct RequireErrorResult: ExpressionMacro {
}
public struct RequireNodeType: CodeItemMacro {
public static func expansion(of node: some FreestandingMacroExpansionSyntax, in context: some MacroExpansionContext) throws -> [CodeBlockItemSyntax] {
public static func expansion(
of node: some FreestandingMacroExpansionSyntax, in context: some MacroExpansionContext
) throws -> [CodeBlockItemSyntax] {
let arguments = node.arguments.indices
var arg_index = arguments.startIndex
let node_to_check = node.arguments[arg_index].expression
@@ -147,19 +147,24 @@ public struct RequireNodeType: CodeItemMacro {
arg_index = arguments.index(after: arg_index)
let expected_type_nice_name = node.arguments[arg_index].expression
let error_message = "Did not find " + remove_embedded_quotes(expected_type_nice_name.description)
let error_message =
"Did not find " + remove_embedded_quotes(expected_type_nice_name.description)
return [CodeBlockItemSyntax(
return [
CodeBlockItemSyntax(
"""
if \(node_to_check).nodeType != \(expected_type) {
return Result.Error(
ErrorOnNode(node: \(node_to_check), withError: "\(raw: error_message)"))
}
""")]
""")
]
}
}
public struct RequireNodesType: CodeItemMacro {
public static func expansion(of node: some FreestandingMacroExpansionSyntax, in context: some MacroExpansionContext) throws -> [CodeBlockItemSyntax] {
public static func expansion(
of node: some FreestandingMacroExpansionSyntax, in context: some MacroExpansionContext
) throws -> [CodeBlockItemSyntax] {
let arguments = node.arguments.indices
var arg_index = arguments.startIndex
@@ -177,44 +182,52 @@ public struct RequireNodesType: CodeItemMacro {
throw MacroError(withMessage: "Node nice names must be in an array")
}
let error_message = "Did not find one of the expected types: " + expected_type_nice_names.elements.map(){ l in
let error_message =
"Did not find one of the expected types: "
+ expected_type_nice_names.elements.map { l in
remove_embedded_quotes("\(l.expression)")
}.joined(separator: ",")
let ifs = expected_types.elements.map(){ l in
let ifs = expected_types.elements.map { l in
"\(node_to_check).nodeType != \(l.expression)"
}.joined(separator: " && ")
return [CodeBlockItemSyntax(
return [
CodeBlockItemSyntax(
"""
if \(raw: ifs) {
return Result.Error(
ErrorOnNode(node: \(node_to_check), withError: "\(raw: error_message)"))
}
""")]
""")
]
}
}
public struct SkipUnlessNodeType: CodeItemMacro {
public static func expansion(of node: some FreestandingMacroExpansionSyntax, in context: some MacroExpansionContext) throws -> [CodeBlockItemSyntax] {
public static func expansion(
of node: some FreestandingMacroExpansionSyntax, in context: some MacroExpansionContext
) throws -> [CodeBlockItemSyntax] {
let arguments = node.arguments.indices
var arg_index = arguments.startIndex
let node_to_check = node.arguments[arg_index].expression
arg_index = arguments.index(after: arg_index)
let expected_type = node.arguments[arg_index].expression
return [CodeBlockItemSyntax(
return [
CodeBlockItemSyntax(
"""
if \(node_to_check).nodeType != \(expected_type) {
return Result.Ok(.none)
}
""")]
""")
]
}
}
@main
struct P4Macros: CompilerPlugin {
var providingMacros: [Macro.Type] = [
RequireResult.self, RequireErrorResult.self, UseOkResult.self, UseErrorResult.self, RequireNodeType.self, SkipUnlessNodeType.self, RequireNodesType.self
RequireResult.self, RequireErrorResult.self, UseOkResult.self, UseErrorResult.self,
RequireNodeType.self, SkipUnlessNodeType.self, RequireNodesType.self,
]
}
Sources/P4Compiler/Expression.swift
+11 -5
View File
@@ -33,7 +33,8 @@ extension TypedIdentifier: CompilableExpression {
) -> Result<EvaluatableExpression?> {
let node = node.child(at: 0)!
#SkipUnlessNodeType<SwiftTreeSitter.Node, EvaluatableExpression?>(node: node, type: "identifier")
#SkipUnlessNodeType<SwiftTreeSitter.Node, EvaluatableExpression?>(
node: node, type: "identifier")
guard
case Result.Ok(let type) = scopes.lookup(
@@ -52,7 +53,8 @@ extension P4BooleanValue: CompilableExpression {
withScopes scopes: LexicalScopes
) -> Result<EvaluatableExpression?> {
let node = node.child(at: 0)!
#SkipUnlessNodeType<SwiftTreeSitter.Node, EvaluatableExpression?>(node: node, type: "booleanLiteralExpression")
#SkipUnlessNodeType<SwiftTreeSitter.Node, EvaluatableExpression?>(
node: node, type: "booleanLiteralExpression")
if node.text == "false" {
return .Ok(P4BooleanValue(withValue: false))
@@ -60,7 +62,8 @@ extension P4BooleanValue: CompilableExpression {
return .Ok(P4BooleanValue(withValue: true))
}
return .Error(ErrorOnNode(node: node, withError: "Failed to parse boolean literal: \(node.text!)"))
return .Error(
ErrorOnNode(node: node, withError: "Failed to parse boolean literal: \(node.text!)"))
}
}
@@ -85,7 +88,8 @@ extension P4StringValue: CompilableExpression {
withScopes scopes: LexicalScopes
) -> Result<EvaluatableExpression?> {
let node = node.child(at: 0)!
#SkipUnlessNodeType<SwiftTreeSitter.Node, EvaluatableExpression?>(node: node, type: "string_literal")
#SkipUnlessNodeType<SwiftTreeSitter.Node, EvaluatableExpression?>(
node: node, type: "string_literal")
return .Ok(P4StringValue(withValue: node.text!))
}
}
@@ -95,7 +99,9 @@ struct Expression {
node: Node, inTree: MutableTree, withScopes scopes: LexicalScopes
) -> Result<EvaluatableExpression> {
#RequireNodesType<Node, EvaluatableExpression>(nodes: node, type: ["expression", "keysetExpression"], msg: ["expression", "keyset expression"])
#RequireNodesType<Node, EvaluatableExpression>(
nodes: node, type: ["expression", "keysetExpression"],
msg: ["expression", "keyset expression"])
// If the node is a keyset expression, then dig out the expression:
let node =
Sources/P4Compiler/Parser.swift
+7 -3
View File
@@ -27,7 +27,8 @@ extension ParserAssignmentStatement: CompilableStatement {
node: Node, inTree tree: MutableTree, withScopes scopes: LexicalScopes
) -> Result<(EvaluatableStatement, LexicalScopes)> {
#RequireNodeType<Node, (EvaluatableStatement, LexicalScopes)>(node: node, type: "assignmentStatement", msg: "assignment statement")
#RequireNodeType<Node, (EvaluatableStatement, LexicalScopes)>(
node: node, type: "assignmentStatement", msg: "assignment statement")
guard let lvalue_node = node.child(at: 0),
lvalue_node.nodeType == "expression"
@@ -92,7 +93,8 @@ public struct Parser {
guard let parser = localElementsParsers[node.nodeType ?? ""] else {
return Result.Error(
ErrorOnNode(
node: node, withError: "Unparseable statement type (\(node.nodeType ?? "Unknown Statement Type"))"))
node: node,
withError: "Unparseable statement type (\(node.nodeType ?? "Unknown Statement Type"))"))
}
switch parser.Compile(node: node, inTree: tree, withScopes: scopes) {
@@ -126,7 +128,9 @@ public struct Parser {
guard let parser = statementParsers[statement.nodeType ?? ""] else {
return Result.Error(
ErrorOnNode(
node: statement, withError: "Unparseable statement type (\(statement.nodeType ?? "Unknown Statement Type"))"))
node: statement,
withError:
"Unparseable statement type (\(statement.nodeType ?? "Unknown Statement Type"))"))
}
switch parser.Compile(node: statement, inTree: tree, withScopes: scopes) {
case Result.Ok(let (parsed, updatedLexicalScopes)):