From 5dbb8d3d60aa53c2c21ff1ead6b9c98b4ac6bae0 Mon Sep 17 00:00:00 2001 From: Will Hawkins Date: Tue, 24 Feb 2026 00:44:04 -0500 Subject: [PATCH] Make Formatter Happy Signed-off-by: Will Hawkins --- README.md | 8 + Sources/Common/Execution.swift | 86 ++++----- Sources/Common/Protocols.swift | 30 ++-- Sources/Common/Scope.swift | 170 +++++++++--------- Sources/Macros/Macros.swift | 128 ++++++------- Sources/P4Lang/Instantiation.swift | 2 +- Sources/P4Lang/Parser.swift | 5 +- Sources/P4Lang/Program.swift | 40 ++--- Sources/P4Parser/Expression.swift | 13 +- Sources/P4Parser/LexicalScopes.swift | 2 +- Sources/P4Parser/Statement.swift | 6 +- Sources/P4Parser/Types.swift | 2 +- Sources/P4Runtime/Parser.swift | 25 +-- Sources/P4Runtime/Program.swift | 16 +- Sources/P4Runtime/Protocols.swift | 12 +- Sources/TreeSitterExtensions/Extensions.swift | 4 +- 16 files changed, 280 insertions(+), 269 deletions(-) diff --git a/README.md b/README.md index 494dc55..be46c95 100644 --- a/README.md +++ b/README.md @@ -27,3 +27,11 @@ $ swift package swift package --disable-sandbox preview-documentation --target ``` For more information, see the [documentation for the Swift-DocC plugin](https://swiftlang.github.io/swift-docc-plugin/documentation/swiftdoccplugin/). + +#### Checking Format + +To check the format: + +```console +$ swift package plugin --allow-writing-to-package-directory swiftformat +``` \ No newline at end of file diff --git a/Sources/Common/Execution.swift b/Sources/Common/Execution.swift index 63a8b8d..0ff24a6 100644 --- a/Sources/Common/Execution.swift +++ b/Sources/Common/Execution.swift @@ -16,62 +16,62 @@ // along with this program. If not, see . open class ProgramExecution: CustomStringConvertible { - public var scopes: ValueScopes = ValueScopes() - var error: Error? - var debug: DebugLevel = DebugLevel.Error + public var scopes: ValueScopes = ValueScopes() + var error: Error? + var debug: DebugLevel = DebugLevel.Error - public init() {} + public init() {} - open var description: String { - return "Runtime:\nScopes: \(scopes)" - } + open var description: String { + return "Runtime:\nScopes: \(scopes)" + } - public func hasError() -> Bool { - return self.error != nil - } + public func hasError() -> Bool { + return self.error != nil + } - public func getError() -> Error? { - return self.error - } + public func getError() -> Error? { + return self.error + } - public func setError(error: Error) -> ProgramExecution { - let npe = self - npe.error = error - return npe - } + public func setError(error: Error) -> ProgramExecution { + let npe = self + npe.error = error + return npe + } - public func getDebugLevel() -> DebugLevel { - return self.debug - } + public func getDebugLevel() -> DebugLevel { + return self.debug + } - public func setDebugLevel(_ dl: DebugLevel) -> ProgramExecution { - let pe = self - pe.debug = dl - return pe - } + public func setDebugLevel(_ dl: DebugLevel) -> ProgramExecution { + let pe = self + pe.debug = dl + return pe + } - open func isDone() -> Bool { - return false - } + open func isDone() -> Bool { + return false + } - open func setDone() -> ProgramExecution { - // For a bare ProgramExecution, setDone is a noop. - return self - } + open func setDone() -> ProgramExecution { + // For a bare ProgramExecution, setDone is a noop. + return self + } - public func enter_scope() -> ProgramExecution { - let new_pe = self - new_pe.scopes = self.scopes.enter() + public func enter_scope() -> ProgramExecution { + let new_pe = self + new_pe.scopes = self.scopes.enter() - return new_pe - } + return new_pe + } - public func exit_scope() -> ProgramExecution { - let new_pe = self - new_pe.scopes = self.scopes.exit() + public func exit_scope() -> ProgramExecution { + let new_pe = self + new_pe.scopes = self.scopes.exit() - return new_pe - } + return new_pe + } } diff --git a/Sources/Common/Protocols.swift b/Sources/Common/Protocols.swift index 210ecdf..a6edc9a 100644 --- a/Sources/Common/Protocols.swift +++ b/Sources/Common/Protocols.swift @@ -16,28 +16,28 @@ // along with this program. If not, see . public protocol EvaluatableExpression { - /// Evaluate an expression for a given execution - /// - Parameters - /// - execution: The execution context in which to evaluate the expression - /// - Returns: The value of expression - func evaluate(execution: ProgramExecution) -> Result - func type() -> any P4Type + /// Evaluate an expression for a given execution + /// - Parameters + /// - execution: The execution context in which to evaluate the expression + /// - Returns: The value of expression + func evaluate(execution: ProgramExecution) -> Result + func type() -> any P4Type } public protocol EvaluatableStatement { - /// Evaluate a statement for a given execution - /// - Parameters - /// - execution: The execution context in which to evaluate the parser statement - /// - Returns: An updated execution after evaluating the parser statement - func evaluate(execution: ProgramExecution) -> ProgramExecution + /// Evaluate a statement for a given execution + /// - Parameters + /// - execution: The execution context in which to evaluate the parser statement + /// - Returns: An updated execution after evaluating the parser statement + func evaluate(execution: ProgramExecution) -> ProgramExecution } public protocol P4Type: CustomStringConvertible { - static func create() -> any P4Type - func eq(rhs: any P4Type) -> Bool + static func create() -> any P4Type + func eq(rhs: any P4Type) -> Bool } public protocol P4Value: CustomStringConvertible { - func type() -> any P4Type - func eq(rhs: P4Value) -> Bool + func type() -> any P4Type + func eq(rhs: P4Value) -> Bool } diff --git a/Sources/Common/Scope.swift b/Sources/Common/Scope.swift index 36736bc..fd2ec4e 100644 --- a/Sources/Common/Scope.swift +++ b/Sources/Common/Scope.swift @@ -16,112 +16,106 @@ // along with this program. If not, see . public struct Scope: CustomStringConvertible { - var symbols: Dictionary = Dictionary() - public init() {} + var symbols: [Identifier: T] = Dictionary() + public init() {} - public var description: String { - var result = String() - for (k,v) in symbols { - result += "\(k): \(v)\n" - } - return result + public var description: String { + var result = String() + for (k, v) in symbols { + result += "\(k): \(v)\n" } + return result + } - public var count: Int { - get { - symbols.count - } - } + public var count: Int { + symbols.count + } - public func lookup(identifier: Identifier) -> T? { - if let symbol = symbols[identifier] { - return symbol - } - return .none + public func lookup(identifier: Identifier) -> T? { + if let symbol = symbols[identifier] { + return symbol } + return .none + } - public func declare(identifier: Identifier, withValue value: T) -> Scope { - var s = self - s.symbols[identifier] = value - return s - } + public func declare(identifier: Identifier, withValue value: T) -> Scope { + var s = self + s.symbols[identifier] = value + return s + } } public struct Scopes: CustomStringConvertible { - var scopes: [Scope] = Array() + var scopes: [Scope] = Array() - public init() {} + public init() {} - init(withScopes scopes: [Scope]) { - self.scopes = scopes + init(withScopes scopes: [Scope]) { + self.scopes = scopes + } + + public func enter() -> Scopes { + var new_scopes = scopes + new_scopes.append(Scope()) + + return Scopes(withScopes: new_scopes) + } + + public func exit() -> Scopes { + var old_scopes = scopes + _ = old_scopes.popLast() + return Scopes(withScopes: old_scopes) + } + + public var description: String { + var result = String() + for s in scopes { + result += "LexicalScope:\n\(s)\n" } - public func enter() -> Scopes { - var new_scopes = scopes - new_scopes.append(Scope()) + return result + } - return Scopes(withScopes: new_scopes) + public var current: Scope? { + scopes.last + } + + public func set(identifier: Identifier, withValue value: T) -> Scopes { + var scopes = self.scopes + var scopes_to_read: [Scope] = Array() + + // Find the scope that has `identifier` + while let scope = scopes.popLast() { + if scope.lookup(identifier: identifier) != nil { + // Update that scope and add it to scopes + scopes.append(scope.declare(identifier: identifier, withValue: value)) + break + } else { + // If there was no match, we'll put it back + scopes_to_read.append(scope) + } } + return Scopes(withScopes: (scopes + scopes_to_read)) + } - public func exit() -> Scopes { - var old_scopes = scopes - _ = old_scopes.popLast() - return Scopes(withScopes: old_scopes) + public func declare(identifier: Identifier, withValue value: T) -> Scopes { + var s = self + if let scope = s.scopes.popLast() { + s.scopes.append(scope.declare(identifier: identifier, withValue: value)) } + return s + } - public var description: String { - var result = String() - for s in scopes { - result += "LexicalScope:\n\(s)\n" - } - - return result + public func lookup(identifier: Identifier) -> Result { + for scope in scopes { + if let vari = scope.lookup(identifier: identifier) { + return .Ok(vari) + } } + return .Error(Error(withMessage: "Cannot find \(identifier) in lexical scope.")) + } - public var current: Scope? { - get { - scopes.last - } - } - - public func set(identifier: Identifier, withValue value: T) -> Scopes { - var scopes = self.scopes - var scopes_to_read: [Scope] = Array() - - // Find the scope that has `identifier` - while let scope = scopes.popLast() { - if scope.lookup(identifier: identifier) != nil { - // Update that scope and add it to scopes - scopes.append(scope.declare(identifier: identifier, withValue: value)) - break - } else { - // If there was no match, we'll put it back - scopes_to_read.append(scope) - } - } - return Scopes(withScopes: (scopes + scopes_to_read)) - } - - public func declare(identifier: Identifier, withValue value: T) -> Scopes { - var s = self - if let scope = s.scopes.popLast() { - s.scopes.append(scope.declare(identifier: identifier, withValue: value)) - } - return s - } - - public func lookup(identifier: Identifier) -> Result { - for scope in scopes { - if let vari = scope.lookup(identifier: identifier) { - return .Ok(vari) - } - } - return .Error(Error(withMessage: "Cannot find \(identifier) in lexical scope.")) - } - - public var count: Int { - get { - scopes.count - } - } + public var count: Int { + scopes.count + } } diff --git a/Sources/Macros/Macros.swift b/Sources/Macros/Macros.swift index 52a636d..bcf84b9 100644 --- a/Sources/Macros/Macros.swift +++ b/Sources/Macros/Macros.swift @@ -20,87 +20,87 @@ import SwiftSyntax import SwiftSyntaxMacros public struct UseOkResult: ExpressionMacro { - public static func expansion( - of node: some FreestandingMacroExpansionSyntax, - in context: some MacroExpansionContext - ) throws -> ExprSyntax { + public static func expansion( + of node: some FreestandingMacroExpansionSyntax, + in context: some MacroExpansionContext + ) throws -> ExprSyntax { - guard let argument = node.argumentList.first?.expression else { - throw Require.Error.SyntaxError - } - - return """ - { - switch \(argument) { - case Result.Ok(let __good): return __good - case Result.Error(let __error): - print("Unexpected result: \\(__error)") - throw Require.Error.UnexpectedResult - } - }() - """ + guard let argument = node.argumentList.first?.expression else { + throw Require.Error.SyntaxError } + + return """ + { + switch \(argument) { + case Result.Ok(let __good): return __good + case Result.Error(let __error): + print("Unexpected result: \\(__error)") + throw Require.Error.UnexpectedResult + } + }() + """ + } } public struct Require { - public enum Error: Swift.Error { - case UnexpectedResult - case SyntaxError - } + public enum Error: Swift.Error { + case UnexpectedResult + case SyntaxError + } } public struct RequireResult: ExpressionMacro { - public static func expansion( - of node: some FreestandingMacroExpansionSyntax, - in context: some MacroExpansionContext - ) throws -> ExprSyntax { + public static func expansion( + of node: some FreestandingMacroExpansionSyntax, + in context: some MacroExpansionContext + ) throws -> ExprSyntax { - guard let argument = node.argumentList.first?.expression else { - throw Require.Error.SyntaxError - } - - return """ - { - switch \(argument) { - case Result.Ok(_): return true - case Result.Error(let __error): - print("Unexpected result: \\(__error)") - return false - } - }() - """ + guard let argument = node.argumentList.first?.expression else { + throw Require.Error.SyntaxError } + + return """ + { + switch \(argument) { + case Result.Ok(_): return true + case Result.Error(let __error): + print("Unexpected result: \\(__error)") + return false + } + }() + """ + } } public struct RequireErrorResult: ExpressionMacro { - public static func expansion( - of node: some FreestandingMacroExpansionSyntax, - in context: some MacroExpansionContext - ) throws -> ExprSyntax { + public static func expansion( + of node: some FreestandingMacroExpansionSyntax, + in context: some MacroExpansionContext + ) throws -> ExprSyntax { - let arguments = node.argumentList.indices - let expected_error = node.argumentList[arguments.startIndex].expression - let error_producer = node.argumentList[arguments.index(after: arguments.startIndex)].expression + let arguments = node.argumentList.indices + let expected_error = node.argumentList[arguments.startIndex].expression + let error_producer = node.argumentList[arguments.index(after: arguments.startIndex)].expression - return ExprSyntax(""" - { - let __expected_error = \(expected_error) - let __actual_error = \(error_producer) - if case Result.Error(__expected_error) = __actual_error { - return true - } else { - print("Expected Error: \\(__expected_error) but got Error: \\(__actual_error)") - return false - } - }() - """) - } + return ExprSyntax( + """ + { + let __expected_error = \(expected_error) + let __actual_error = \(error_producer) + if case Result.Error(__expected_error) = __actual_error { + return true + } else { + print("Expected Error: \\(__expected_error) but got Error: \\(__actual_error)") + return false + } + }() + """) + } } - @main struct P4Macros: CompilerPlugin { - var providingMacros: [Macro.Type] = [ - RequireResult.self, RequireErrorResult.self, UseOkResult.self, - ] + var providingMacros: [Macro.Type] = [ + RequireResult.self, RequireErrorResult.self, UseOkResult.self, + ] } diff --git a/Sources/P4Lang/Instantiation.swift b/Sources/P4Lang/Instantiation.swift index 2136251..7a0899d 100644 --- a/Sources/P4Lang/Instantiation.swift +++ b/Sources/P4Lang/Instantiation.swift @@ -19,4 +19,4 @@ import Common public struct Instantiation { -} \ No newline at end of file +} diff --git a/Sources/P4Lang/Parser.swift b/Sources/P4Lang/Parser.swift index 2f682eb..769b736 100644 --- a/Sources/P4Lang/Parser.swift +++ b/Sources/P4Lang/Parser.swift @@ -113,7 +113,7 @@ public class ParserState: Equatable, CustomStringConvertible, Comparable { public private(set) var next_state: ParserState? public static func < (lhs: ParserState, rhs: ParserState) -> Bool { - // If lhs transitions to rhs, then return true. Otherwise, return false. + // If lhs transitions to rhs, then return true. Otherwise, return false. // TODO!! return false @@ -141,7 +141,7 @@ public class ParserState: Equatable, CustomStringConvertible, Comparable { public func semantic_check(states: ParserStates) -> Bool { guard let transition = transition else { - return self == accept || self == reject + return self == accept || self == reject } if let next_state_name = transition.next_state_name, @@ -226,7 +226,6 @@ public struct ParserStates { } } - public struct Parser: P4Type { public var states: ParserStates diff --git a/Sources/P4Lang/Program.swift b/Sources/P4Lang/Program.swift index 98c9044..600640a 100644 --- a/Sources/P4Lang/Program.swift +++ b/Sources/P4Lang/Program.swift @@ -22,26 +22,26 @@ public struct ExpressionStatement { } public struct Program { - public var types: [P4Type] = Array() + public var types: [P4Type] = Array() - /// Find the program's main parser - /// - /// Note: For now, the main parser is expected to be named main_parser. - public func starting_parser() -> Result { - return self.find_parser(withName: Identifier(name: "main_parser")) + /// Find the program's main parser + /// + /// Note: For now, the main parser is expected to be named main_parser. + public func starting_parser() -> Result { + return self.find_parser(withName: Identifier(name: "main_parser")) + } + + public func find_parser(withName name: Identifier) -> Result { + for type in self.types { + guard let parser = type as? Parser else { + continue + } + if parser.name == name { + return .Ok(parser) + } } + return .Error(Error(withMessage: "Could not find parser named \(name)")) + } - public func find_parser(withName name: Identifier) -> Result { - for type in self.types { - guard let parser = type as? Parser else { - continue - } - if parser.name == name { - return .Ok(parser) - } - } - return .Error(Error(withMessage: "Could not find parser named \(name)")) - } - - public init() {} -} \ No newline at end of file + public init() {} +} diff --git a/Sources/P4Parser/Expression.swift b/Sources/P4Parser/Expression.swift index 1b4aa66..d40714a 100644 --- a/Sources/P4Parser/Expression.swift +++ b/Sources/P4Parser/Expression.swift @@ -28,7 +28,8 @@ protocol ParseableEvaluatableExpression { extension TypedIdentifier: ParseableEvaluatableExpression { static func parse( - node: SwiftTreeSitter.Node, inTree tree: SwiftTreeSitter.MutableTree, withScopes scopes: LexicalScopes + node: SwiftTreeSitter.Node, inTree tree: SwiftTreeSitter.MutableTree, + withScopes scopes: LexicalScopes ) -> Result { guard @@ -61,7 +62,8 @@ extension TypedIdentifier: ParseableEvaluatableExpression { extension P4BooleanValue: ParseableEvaluatableExpression { static func parse( - node: SwiftTreeSitter.Node, inTree tree: SwiftTreeSitter.MutableTree, withScopes scopes: LexicalScopes + node: SwiftTreeSitter.Node, inTree tree: SwiftTreeSitter.MutableTree, + withScopes scopes: LexicalScopes ) -> Result { guard @@ -101,7 +103,8 @@ extension P4BooleanValue: ParseableEvaluatableExpression { extension P4IntValue: ParseableEvaluatableExpression { static func parse( - node: SwiftTreeSitter.Node, inTree tree: SwiftTreeSitter.MutableTree, withScopes scopes: LexicalScopes + node: SwiftTreeSitter.Node, inTree tree: SwiftTreeSitter.MutableTree, + withScopes scopes: LexicalScopes ) -> Result { guard @@ -132,7 +135,8 @@ extension P4IntValue: ParseableEvaluatableExpression { extension P4StringValue: ParseableEvaluatableExpression { static func parse( - node: SwiftTreeSitter.Node, inTree tree: SwiftTreeSitter.MutableTree, withScopes scopes: LexicalScopes + node: SwiftTreeSitter.Node, inTree tree: SwiftTreeSitter.MutableTree, + withScopes scopes: LexicalScopes ) -> Result { guard @@ -202,4 +206,3 @@ extension ExpressionStatement: ParseableStatement { return Result.Ok((.none, scopes)) } } - diff --git a/Sources/P4Parser/LexicalScopes.swift b/Sources/P4Parser/LexicalScopes.swift index cf06a5e..ec35f3e 100644 --- a/Sources/P4Parser/LexicalScopes.swift +++ b/Sources/P4Parser/LexicalScopes.swift @@ -18,4 +18,4 @@ import Common public typealias LexicalScope = Scope -public typealias LexicalScopes = Scopes \ No newline at end of file +public typealias LexicalScopes = Scopes diff --git a/Sources/P4Parser/Statement.swift b/Sources/P4Parser/Statement.swift index 8f29d6a..64ea791 100644 --- a/Sources/P4Parser/Statement.swift +++ b/Sources/P4Parser/Statement.swift @@ -70,8 +70,10 @@ extension VariableDeclarationStatement: ParseableStatement { if rvalue.type().eq(rhs: declaration_p4_type) { return Result.Ok( ( - VariableDeclarationStatement(identifier: Identifier(name: variable_name), withInitializer: rvalue), - scopes.declare(identifier: Identifier(name: variable_name), withValue: declaration_p4_type) + VariableDeclarationStatement( + identifier: Identifier(name: variable_name), withInitializer: rvalue), + scopes.declare( + identifier: Identifier(name: variable_name), withValue: declaration_p4_type) )) } else { diff --git a/Sources/P4Parser/Types.swift b/Sources/P4Parser/Types.swift index 9279ffd..fe0d67c 100644 --- a/Sources/P4Parser/Types.swift +++ b/Sources/P4Parser/Types.swift @@ -51,4 +51,4 @@ public struct Types { } return Result.Error(Error(withMessage: "Type name not recognized")) } -} \ No newline at end of file +} diff --git a/Sources/P4Runtime/Parser.swift b/Sources/P4Runtime/Parser.swift index ad1d8b3..12bc148 100644 --- a/Sources/P4Runtime/Parser.swift +++ b/Sources/P4Runtime/Parser.swift @@ -98,7 +98,6 @@ public struct ParserStateSelectTransition: ParserStateInstance { program = statement.evaluate(execution: program) } - switch self.selector.evaluate(execution: program) { case .Ok(let selector_value): for (key, target) in zip(self.keys, self.states) { @@ -138,27 +137,33 @@ extension ParserState: Compilable { return .Ok(ParserStateNoTransition(currrent_state: state)) } - if state.direct_transition(), - let transition_statement = state.transition { + if state.direct_transition(), + let transition_statement = state.transition + { return .Ok( ParserStateDirectTransition( currrent_state: state, next_state: current[transition_statement.next_state_name!]!)) } if let transition_select_statement = state.transition, - let transition_select_expression = transition_select_statement.transition_expression { + let transition_select_expression = transition_select_statement.transition_expression + { - var keys: Array = Array() - var states: Array = Array() + var keys: [any EvaluatableExpression] = Array() + var states: [any ParserStateInstance] = Array() for kse in transition_select_expression.keyset_expressions { guard let next_state = current[kse.next_state_name] else { - return .Error(Error(withMessage: "Cannot find \(kse.next_state_name) as transition target")) + return .Error( + Error(withMessage: "Cannot find \(kse.next_state_name) as transition target")) } keys.append(kse.key) states.append(next_state) } - return .Ok(ParserStateSelectTransition(keys: keys, states: states, selector: transition_select_expression.selector, currrent_state: state)) + return .Ok( + ParserStateSelectTransition( + keys: keys, states: states, selector: transition_select_expression.selector, + currrent_state: state)) } return .Error(Error(withMessage: "Invalid parser state: No meaningful transition")) @@ -177,8 +182,8 @@ extension ParserStates: Compilable { // TODO: We assume that states are in transition-order! for state in parser.states { switch ParserState.compile((state, compiled_states)) { - case .Ok(let compiled): compiled_states[state.state_name] = compiled - case .Error(let e): return .Error(e) + case .Ok(let compiled): compiled_states[state.state_name] = compiled + case .Error(let e): return .Error(e) } } diff --git a/Sources/P4Runtime/Program.swift b/Sources/P4Runtime/Program.swift index 9eb566f..905beaa 100644 --- a/Sources/P4Runtime/Program.swift +++ b/Sources/P4Runtime/Program.swift @@ -15,8 +15,8 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -import P4Lang import Common +import P4Lang extension VariableDeclarationStatement: EvaluatableStatement { public func evaluate(execution: ProgramExecution) -> ProgramExecution { @@ -37,11 +37,11 @@ extension ExpressionStatement: EvaluatableStatement { // Variables are evaluatable because they can be looked up by identifiers. extension TypedIdentifier: EvaluatableExpression { - public func type() -> any Common.P4Type { - return self.parsed_type - } + public func type() -> any Common.P4Type { + return self.parsed_type + } - public func evaluate(execution: Common.ProgramExecution) -> Result { - return execution.scopes.lookup(identifier: self) - } -} \ No newline at end of file + public func evaluate(execution: Common.ProgramExecution) -> Result { + return execution.scopes.lookup(identifier: self) + } +} diff --git a/Sources/P4Runtime/Protocols.swift b/Sources/P4Runtime/Protocols.swift index dc19563..742d4e9 100644 --- a/Sources/P4Runtime/Protocols.swift +++ b/Sources/P4Runtime/Protocols.swift @@ -27,7 +27,7 @@ protocol EvaluatableParserTransitionStatement { } public protocol Execution { - func execute() -> (ParserState, ProgramExecution) + func execute() -> (ParserState, ProgramExecution) } public protocol Compilable { @@ -37,11 +37,11 @@ public protocol Compilable { } public protocol ParserStateInstance { - func execute(program: ProgramExecution) -> (ParserStateInstance, ProgramExecution) - func done() -> Bool - func current() -> ParserState + func execute(program: ProgramExecution) -> (ParserStateInstance, ProgramExecution) + func done() -> Bool + func current() -> ParserState } public protocol ParserExecution { - func execute() -> (ParserState, ProgramExecution) -} \ No newline at end of file + func execute() -> (ParserState, ProgramExecution) +} diff --git a/Sources/TreeSitterExtensions/Extensions.swift b/Sources/TreeSitterExtensions/Extensions.swift index 6adeb14..d787986 100644 --- a/Sources/TreeSitterExtensions/Extensions.swift +++ b/Sources/TreeSitterExtensions/Extensions.swift @@ -37,7 +37,7 @@ extension MutableTree { } public func containsMissing(lang: Language) -> Bool { guard - let parser_error_query = try? SwiftTreeSitter.Query( + let parser_error_query = try? SwiftTreeSitter.Query( language: lang, data: String( "(MISSING)" @@ -52,4 +52,4 @@ extension MutableTree { } return false } -} \ No newline at end of file +}