This is a staging environment. For live and up-to-date package information, visit swiftpackageindex.com.

The Swift Package Index logo.Swift Package Index

Track the adoption of Swift 6 strict concurrency checks for data race safety. How many packages are Ready for Swift 6?

Build Information

Successful build of OysterKit with Swift 6.0 for Linux.

Swift 6 data race errors: 24

Build Command

bash -c docker run --rm -v "checkouts-4606859-1":/host -w "$workDir" registry.gitlab.com/finestructure/spi-images:basic-6.0-latest swift build --triple x86_64-unknown-linux-gnu -Xswiftc -Xfrontend -Xswiftc -stats-output-dir -Xswiftc -Xfrontend -Xswiftc .stats -Xswiftc -strict-concurrency=complete 2>&1

Build Log

29 |     public let minimumMatches : Int
   :
58 |
59 |     /// A pre-specified constant for one and exactly one matches
60 |     public static let one = Cardinality(1...1)
   |                       |- warning: static property 'one' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'one' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
61 |
62 |     /// A pre-specified constant for optional matches (between 0 and 1 matches)
/host/spi-builder-workspace/Sources/OysterKit/Rules/Cadinality.swift:69:23: warning: static property 'oneOrMore' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
25 | /// Represents the cardinality of a rule. It can be specified as a closed range,
26 | /// including those with no upper bound (`PartialRangeFrom`)
27 | public struct Cardinality : Equatable {
   |               `- note: consider making struct 'Cardinality' conform to the 'Sendable' protocol
28 |     /// The minimum number of matches, must be >= 0
29 |     public let minimumMatches : Int
   :
67 |
68 |     /// A pre-specified constant for required but unbound matches (between 1 and infinity matches)
69 |     public static let oneOrMore = Cardinality(1...)
   |                       |- warning: static property 'oneOrMore' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'oneOrMore' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
70 |
71 |     /// The equality function
/host/spi-builder-workspace/Sources/OysterKit/Rules/Cadinality.swift:66:23: warning: static property 'zeroOrMore' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
25 | /// Represents the cardinality of a rule. It can be specified as a closed range,
26 | /// including those with no upper bound (`PartialRangeFrom`)
27 | public struct Cardinality : Equatable {
   |               `- note: consider making struct 'Cardinality' conform to the 'Sendable' protocol
28 |     /// The minimum number of matches, must be >= 0
29 |     public let minimumMatches : Int
   :
64 |
65 |     /// A pre-specified constant for optional but unbound matches (between 0 and infinity matches)
66 |     public static let zeroOrMore = Cardinality(0...)
   |                       |- warning: static property 'zeroOrMore' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'zeroOrMore' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
67 |
68 |     /// A pre-specified constant for required but unbound matches (between 1 and infinity matches)
/host/spi-builder-workspace/Sources/OysterKit/Rules/Cadinality.swift:63:23: warning: static property 'zeroOrOne' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
25 | /// Represents the cardinality of a rule. It can be specified as a closed range,
26 | /// including those with no upper bound (`PartialRangeFrom`)
27 | public struct Cardinality : Equatable {
   |               `- note: consider making struct 'Cardinality' conform to the 'Sendable' protocol
28 |     /// The minimum number of matches, must be >= 0
29 |     public let minimumMatches : Int
   :
61 |
62 |     /// A pre-specified constant for optional matches (between 0 and 1 matches)
63 |     public static let zeroOrOne = Cardinality(0...1)
   |                       |- warning: static property 'zeroOrOne' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'zeroOrOne' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
64 |
65 |     /// A pre-specified constant for optional but unbound matches (between 0 and infinity matches)
[68/89] Compiling STLR String.swift
/host/spi-builder-workspace/Sources/STLR/Extensions/String.swift:35:5: warning: 'public' modifier is redundant for instance method declared in a public extension
33 |     */
34 |     @available(*,deprecated,message: "Use .dynamicRule(Behaviour.Kind) instead")
35 |     public func  dynamicRule(token:TokenType)->Rule? {
   |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
36 |         return try? dynamicRule(Behaviour.Kind.structural(token: token))
37 |     }
/host/spi-builder-workspace/Sources/STLR/Extensions/String.swift:45:5: warning: 'public' modifier is redundant for instance method declared in a public extension
43 |      - Returns: `nil` if compilation failed
44 |      */
45 |     public func dynamicRule(_ kind:Behaviour.Kind) throws ->Rule{
   |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
46 |         let compiled = try STLR.build("grammar Dynamic\n_ = \(self)")
47 |
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+DynamicRules.swift:284:5: warning: 'public' modifier is redundant for property declared in a public extension
282 | public extension STLR.Grammar {
283 |     /// Builds a set of `Rule`s that can be used directly at run-time in your application
284 |     public var dynamicRules : [Rule] {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
285 |         let symbolTable = SymbolTable<Symbol>(self)
286 |
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+DynamicRules.swift:176:26: warning: This might be bogus, remove warning when tests pass
174 | //                return [singleElement.rule(symbolTable: symbolTable)].sequence.rule(with: element.behaviour, annotations: element.annotations?.ruleAnnotations ?? [:])
175 | //            } else {
176 |                 #warning("This might be bogus, remove warning when tests pass")
    |                          `- warning: This might be bogus, remove warning when tests pass
177 |                 return [group.expression.rule(using: symbolTable)].sequence.rule(with: element.behaviour,annotations: element.annotations?.ruleAnnotations ?? [:])
178 | //            }
/host/spi-builder-workspace/Sources/OysterKit/Rules/Cadinality.swift:60:23: warning: static property 'one' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
25 | /// Represents the cardinality of a rule. It can be specified as a closed range,
26 | /// including those with no upper bound (`PartialRangeFrom`)
27 | public struct Cardinality : Equatable {
   |               `- note: consider making struct 'Cardinality' conform to the 'Sendable' protocol
28 |     /// The minimum number of matches, must be >= 0
29 |     public let minimumMatches : Int
   :
58 |
59 |     /// A pre-specified constant for one and exactly one matches
60 |     public static let one = Cardinality(1...1)
   |                       |- warning: static property 'one' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'one' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
61 |
62 |     /// A pre-specified constant for optional matches (between 0 and 1 matches)
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+DynamicRules.swift:274:18: warning: This is only required whilst legacy rules may be involved, as it is formally captured in Behaviour.Kind
272 |
273 |     var ruleAnnotations : RuleAnnotations {
274 |         #warning("This is only required whilst legacy rules may be involved, as it is formally captured in Behaviour.Kind")
    |                  `- warning: This is only required whilst legacy rules may be involved, as it is formally captured in Behaviour.Kind
275 |         let assumed : RuleAnnotations = void != nil ? [.void : .set] : transient != nil ? [.transient : .set ] : [:]
276 |
[69/89] Compiling STLR STLR+CustomStringConvertable.swift
/host/spi-builder-workspace/Sources/STLR/Extensions/String.swift:35:5: warning: 'public' modifier is redundant for instance method declared in a public extension
33 |     */
34 |     @available(*,deprecated,message: "Use .dynamicRule(Behaviour.Kind) instead")
35 |     public func  dynamicRule(token:TokenType)->Rule? {
   |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
36 |         return try? dynamicRule(Behaviour.Kind.structural(token: token))
37 |     }
/host/spi-builder-workspace/Sources/STLR/Extensions/String.swift:45:5: warning: 'public' modifier is redundant for instance method declared in a public extension
43 |      - Returns: `nil` if compilation failed
44 |      */
45 |     public func dynamicRule(_ kind:Behaviour.Kind) throws ->Rule{
   |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
46 |         let compiled = try STLR.build("grammar Dynamic\n_ = \(self)")
47 |
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+DynamicRules.swift:284:5: warning: 'public' modifier is redundant for property declared in a public extension
282 | public extension STLR.Grammar {
283 |     /// Builds a set of `Rule`s that can be used directly at run-time in your application
284 |     public var dynamicRules : [Rule] {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
285 |         let symbolTable = SymbolTable<Symbol>(self)
286 |
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+DynamicRules.swift:176:26: warning: This might be bogus, remove warning when tests pass
174 | //                return [singleElement.rule(symbolTable: symbolTable)].sequence.rule(with: element.behaviour, annotations: element.annotations?.ruleAnnotations ?? [:])
175 | //            } else {
176 |                 #warning("This might be bogus, remove warning when tests pass")
    |                          `- warning: This might be bogus, remove warning when tests pass
177 |                 return [group.expression.rule(using: symbolTable)].sequence.rule(with: element.behaviour,annotations: element.annotations?.ruleAnnotations ?? [:])
178 | //            }
/host/spi-builder-workspace/Sources/OysterKit/Rules/Cadinality.swift:60:23: warning: static property 'one' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
25 | /// Represents the cardinality of a rule. It can be specified as a closed range,
26 | /// including those with no upper bound (`PartialRangeFrom`)
27 | public struct Cardinality : Equatable {
   |               `- note: consider making struct 'Cardinality' conform to the 'Sendable' protocol
28 |     /// The minimum number of matches, must be >= 0
29 |     public let minimumMatches : Int
   :
58 |
59 |     /// A pre-specified constant for one and exactly one matches
60 |     public static let one = Cardinality(1...1)
   |                       |- warning: static property 'one' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'one' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
61 |
62 |     /// A pre-specified constant for optional matches (between 0 and 1 matches)
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+DynamicRules.swift:274:18: warning: This is only required whilst legacy rules may be involved, as it is formally captured in Behaviour.Kind
272 |
273 |     var ruleAnnotations : RuleAnnotations {
274 |         #warning("This is only required whilst legacy rules may be involved, as it is formally captured in Behaviour.Kind")
    |                  `- warning: This is only required whilst legacy rules may be involved, as it is formally captured in Behaviour.Kind
275 |         let assumed : RuleAnnotations = void != nil ? [.void : .set] : transient != nil ? [.transient : .set ] : [:]
276 |
[70/89] Compiling STLR STLR+DynamicRules.swift
/host/spi-builder-workspace/Sources/STLR/Extensions/String.swift:35:5: warning: 'public' modifier is redundant for instance method declared in a public extension
33 |     */
34 |     @available(*,deprecated,message: "Use .dynamicRule(Behaviour.Kind) instead")
35 |     public func  dynamicRule(token:TokenType)->Rule? {
   |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
36 |         return try? dynamicRule(Behaviour.Kind.structural(token: token))
37 |     }
/host/spi-builder-workspace/Sources/STLR/Extensions/String.swift:45:5: warning: 'public' modifier is redundant for instance method declared in a public extension
43 |      - Returns: `nil` if compilation failed
44 |      */
45 |     public func dynamicRule(_ kind:Behaviour.Kind) throws ->Rule{
   |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
46 |         let compiled = try STLR.build("grammar Dynamic\n_ = \(self)")
47 |
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+DynamicRules.swift:284:5: warning: 'public' modifier is redundant for property declared in a public extension
282 | public extension STLR.Grammar {
283 |     /// Builds a set of `Rule`s that can be used directly at run-time in your application
284 |     public var dynamicRules : [Rule] {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
285 |         let symbolTable = SymbolTable<Symbol>(self)
286 |
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+DynamicRules.swift:176:26: warning: This might be bogus, remove warning when tests pass
174 | //                return [singleElement.rule(symbolTable: symbolTable)].sequence.rule(with: element.behaviour, annotations: element.annotations?.ruleAnnotations ?? [:])
175 | //            } else {
176 |                 #warning("This might be bogus, remove warning when tests pass")
    |                          `- warning: This might be bogus, remove warning when tests pass
177 |                 return [group.expression.rule(using: symbolTable)].sequence.rule(with: element.behaviour,annotations: element.annotations?.ruleAnnotations ?? [:])
178 | //            }
/host/spi-builder-workspace/Sources/OysterKit/Rules/Cadinality.swift:60:23: warning: static property 'one' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
25 | /// Represents the cardinality of a rule. It can be specified as a closed range,
26 | /// including those with no upper bound (`PartialRangeFrom`)
27 | public struct Cardinality : Equatable {
   |               `- note: consider making struct 'Cardinality' conform to the 'Sendable' protocol
28 |     /// The minimum number of matches, must be >= 0
29 |     public let minimumMatches : Int
   :
58 |
59 |     /// A pre-specified constant for one and exactly one matches
60 |     public static let one = Cardinality(1...1)
   |                       |- warning: static property 'one' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'one' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
61 |
62 |     /// A pre-specified constant for optional matches (between 0 and 1 matches)
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+DynamicRules.swift:274:18: warning: This is only required whilst legacy rules may be involved, as it is formally captured in Behaviour.Kind
272 |
273 |     var ruleAnnotations : RuleAnnotations {
274 |         #warning("This is only required whilst legacy rules may be involved, as it is formally captured in Behaviour.Kind")
    |                  `- warning: This is only required whilst legacy rules may be involved, as it is formally captured in Behaviour.Kind
275 |         let assumed : RuleAnnotations = void != nil ? [.void : .set] : transient != nil ? [.transient : .set ] : [:]
276 |
[71/89] Emitting module STLR
/host/spi-builder-workspace/Sources/STLR/Extensions/String.swift:35:5: warning: 'public' modifier is redundant for instance method declared in a public extension
33 |     */
34 |     @available(*,deprecated,message: "Use .dynamicRule(Behaviour.Kind) instead")
35 |     public func  dynamicRule(token:TokenType)->Rule? {
   |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
36 |         return try? dynamicRule(Behaviour.Kind.structural(token: token))
37 |     }
/host/spi-builder-workspace/Sources/STLR/Extensions/String.swift:45:5: warning: 'public' modifier is redundant for instance method declared in a public extension
43 |      - Returns: `nil` if compilation failed
44 |      */
45 |     public func dynamicRule(_ kind:Behaviour.Kind) throws ->Rule{
   |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
46 |         let compiled = try STLR.build("grammar Dynamic\n_ = \(self)")
47 |
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+DynamicRules.swift:284:5: warning: 'public' modifier is redundant for property declared in a public extension
282 | public extension STLR.Grammar {
283 |     /// Builds a set of `Rule`s that can be used directly at run-time in your application
284 |     public var dynamicRules : [Rule] {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
285 |         let symbolTable = SymbolTable<Symbol>(self)
286 |
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:149:5: warning: 'public' modifier is redundant for instance method declared in a public extension
147 |     }
148 |
149 |     public func defined(identifier:String)->Bool{
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
150 |         for rule in rules {
151 |             if rule.identifier == identifier {
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:209:5: warning: 'public' modifier is redundant for property declared in a public extension
207 |
208 |     /// All rules, including those defined inline
209 |     public var allRules : STLR.Rules {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
210 |         var all = STLR.Rules()
211 |         all.append(contentsOf: rules)
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:216:5: warning: 'public' modifier is redundant for subscript declared in a public extension
214 |     }
215 |
216 |     public subscript(_ identifier:String)->STLR.Rule{
    |     `- warning: 'public' modifier is redundant for subscript declared in a public extension
217 |         for rule in rules {
218 |             if rule.identifier == identifier {
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:242:5: warning: 'public' modifier is redundant for instance method declared in a public extension
240 |     }
241 |
242 |     public func isLeftHandRecursive(identifier:String)->Bool{
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
243 |         var closedList = [String]()
244 |         return self[identifier].expression.references(identifier, grammar: self, closedList: &closedList)
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:247:5: warning: 'public' modifier is redundant for instance method declared in a public extension
245 |     }
246 |
247 |     public func isDirectLeftHandRecursive(identifier:String)->Bool{
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
248 |         var closedList = [String]()
249 |         return self[identifier].expression.directlyReferences(identifier, grammar: self, closedList: &closedList)
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:252:5: warning: 'public' modifier is redundant for instance method declared in a public extension
250 |     }
251 |
252 |     public func isRoot(identifier:String)->Bool{
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
253 |         var closedList = [String]()
254 |         for rule in rules {
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:262:5: warning: 'public' modifier is redundant for instance method declared in a public extension
260 |     }
261 |
262 |     public func validate(rule:STLR.Rule) throws {
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
263 |         if isDirectLeftHandRecursive(identifier: rule.identifier){
264 |             throw ProcessingError.interpretation(message: "\(rule.identifier) is directly left hand recursive (references itself without moving scan head forward)", causes: [])
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:272:5: warning: 'public' modifier is redundant for property declared in a public extension
270 | public extension STLR.Rule {
271 |     /// True if the rule is skipping
272 |     public var isVoid : Bool {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
273 |         return void != nil || (annotations?.void ?? false)
274 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:277:5: warning: 'public' modifier is redundant for property declared in a public extension
275 |
276 |     /// True if it is a scanning rule
277 |     public var isTransient : Bool {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
278 |         return transient != nil || (annotations?.transient ?? false)
279 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:281:5: warning: 'public' modifier is redundant for property declared in a public extension
279 |     }
280 |
281 |     public var type : String? {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
282 |         return annotations?.type
283 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:288:5: warning: 'public' modifier is redundant for property declared in a public extension
286 | public extension STLR.Quantifier {
287 |     /// The minimum number of matches required to satisfy the quantifier
288 |     public var minimumMatches : Int {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
289 |         switch self {
290 |         case .star, .questionMark:
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:300:5: warning: 'public' modifier is redundant for property declared in a public extension
298 |
299 |     /// The maximum number of matches required to satisfy the quantifier
300 |     public var maximumMatches : Int? {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
301 |         switch self {
302 |         case .questionMark:
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:338:5: warning: 'public' modifier is redundant for instance method declared in a public extension
336 |     }
337 |
338 |     public func directlyReferences(_ identifier:String, grammar:STLR.Grammar, closedList:inout [String])->Bool {
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
339 |         for element in elements {
340 |             if element.directlyReferences(identifier, grammar: grammar, closedList: &closedList){
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:353:5: warning: 'public' modifier is redundant for instance method declared in a public extension
351 |
352 |
353 |     public func references(_ identifier:String, grammar:STLR.Grammar, closedList: inout [String])->Bool {
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
354 |         for element in elements {
355 |             if element.references(identifier, grammar: grammar, closedList: &closedList){
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:366:5: warning: 'public' modifier is redundant for property declared in a public extension
364 |
365 |     /// The annotations defined as `RuleAnnotations`
366 |     public var ruleAnnotations : RuleAnnotations {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
367 |         return annotations?.ruleAnnotations ?? [:]
368 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:371:5: warning: 'public' modifier is redundant for property declared in a public extension
369 |
370 |     /// True if the element is skipping
371 |     public var isVoid : Bool {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
372 |         return void != nil || (annotations?.void ?? false)
373 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:376:5: warning: 'public' modifier is redundant for property declared in a public extension
374 |
375 |     /// True if it is a scanning element
376 |     public var isTransient : Bool {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
377 |         return transient != nil || (annotations?.transient ?? false)
378 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:381:5: warning: 'public' modifier is redundant for property declared in a public extension
379 |
380 |     /// True if the element is lookahead
381 |     public var isLookahead : Bool {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
382 |         return lookahead != nil
383 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:386:5: warning: 'public' modifier is redundant for property declared in a public extension
384 |
385 |     /// True if the element is negated
386 |     public var isNegated : Bool {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
387 |         return negated != nil
388 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:391:5: warning: 'public' modifier is redundant for property declared in a public extension
389 |
390 |     /// Returns the token name (if any) of the element
391 |     public var token : TokenType? {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
392 |         if case let Behaviour.Kind.structural(token) = kind {
393 |             return token
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:400:5: warning: 'public' modifier is redundant for property declared in a public extension
398 |
399 |     /// The `Kind` of the rule
400 |     public var kind : Behaviour.Kind {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
401 |         if isVoid {
402 |             return .skipping
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:418:5: warning: 'public' modifier is redundant for property declared in a public extension
416 |
417 |     /// The `Cardinality` of the match
418 |     public var cardinality : Cardinality {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
419 |         guard let quantifier = quantifier else {
420 |             return .one
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:436:5: warning: 'public' modifier is redundant for property declared in a public extension
434 |
435 |     /// The `Behaviour` of the rule
436 |     public var behaviour : Behaviour {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
437 |         return Behaviour(kind, cardinality: cardinality, negated: isNegated, lookahead: isLookahead)
438 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:463:5: warning: 'public' modifier is redundant for instance method declared in a public extension
461 |      - Returns: `true` if the identifier could be referenced before the scan head has moved
462 |     */
463 |     public func directlyReferences(_ identifier:String, grammar:STLR.Grammar)->Bool{
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
464 |         var closedList = [String]()
465 |         return directlyReferences(identifier, grammar: grammar, closedList: &closedList)
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:620:5: warning: 'internal' modifier is redundant for property declared in an internal extension
618 | internal extension Array where Element == STLR.Annotation {
619 |     /// The annotations on the element with any that would be captured in `Behaviour` removed (@token, @transient, @void)
620 |     internal var unfilteredRuleAnnotationsForTesting : RuleAnnotations {
    |     `- warning: 'internal' modifier is redundant for property declared in an internal extension
621 |         var ruleAnnotations = [RuleAnnotation : RuleAnnotationValue]()
622 |         for annotation in self {
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:641:5: warning: 'public' modifier is redundant for property declared in a public extension
639 |
640 |     /// The annotations on the element with any that would be captured in `Behaviour` removed (@token, @transient, @void)
641 |     public var ruleAnnotations : RuleAnnotations {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
642 |         var ruleAnnotations = [RuleAnnotation : RuleAnnotationValue]()
643 |         for annotation in filter({!$0.label.isBehavioural}){
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:650:5: warning: 'public' modifier is redundant for property declared in a public extension
648 |
649 |     /// The token if any specified in the annotations
650 |     public var token : String? {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
651 |         guard let tokenAnnotationValue = self[RuleAnnotation.token] else {
652 |             return nil
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:665:5: warning: 'public' modifier is redundant for property declared in a public extension
663 |
664 |     /// `true` if the annotations include @void
665 |     public var void : Bool {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
666 |         return self[RuleAnnotation.void] != nil
667 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:670:5: warning: 'public' modifier is redundant for property declared in a public extension
668 |
669 |     /// `true` if the annotations include @transient
670 |     public var transient : Bool {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
671 |         return self[RuleAnnotation.transient] != nil
672 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:673:5: warning: 'public' modifier is redundant for property declared in a public extension
671 |         return self[RuleAnnotation.transient] != nil
672 |     }
673 |     public var type : String? {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
674 |         if let typeAnnotationValue = self[RuleAnnotation.type] {
675 |             if case let RuleAnnotationValue.string(value) =  typeAnnotationValue {
/host/spi-builder-workspace/Sources/STLR/Generated/STLR.swift:8:24: warning: static property 'regularExpressionCache' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
  6 |     typealias T = STLRTokens
  7 |     // Cache for compiled regular expressions
  8 |     private static var regularExpressionCache = [String : NSRegularExpression]()
    |                        |- warning: static property 'regularExpressionCache' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
    |                        |- note: convert 'regularExpressionCache' to a 'let' constant to make 'Sendable' shared state immutable
    |                        |- note: annotate 'regularExpressionCache' with '@MainActor' if property should only be accessed from the main actor
    |                        `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
  9 |
 10 |     /// Returns a pre-compiled pattern from the cache, or if not in the cache builds
/host/spi-builder-workspace/Sources/STLR/Generated/STLR.swift:301:24: warning: static property 'leftHandRecursiveRules' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
299 |
300 |     /// Cache for left-hand recursive rules
301 |     private static var leftHandRecursiveRules = [ Int : Rule ]()
    |                        |- warning: static property 'leftHandRecursiveRules' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
    |                        |- note: convert 'leftHandRecursiveRules' to a 'let' constant to make 'Sendable' shared state immutable
    |                        |- note: annotate 'leftHandRecursiveRules' with '@MainActor' if property should only be accessed from the main actor
    |                        `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
302 |
303 |     /// Create a language that can be used for parsing etc
/host/spi-builder-workspace/Sources/STLR/Generators/Generator.swift:34:14: warning: Make name optional and overriding
32 |     ///
33 |     ///  - Parameter scope: The scope
34 |     #warning("Make name optional and overriding")
   |              `- warning: Make name optional and overriding
35 |     static func generate(for scope:STLR, grammar name:String, accessLevel:String) throws ->[Operation]
36 | }
/host/spi-builder-workspace/Sources/STLR/Generators/GrammarStructure+STLR.swift:524:5: warning: 'fileprivate' modifier is redundant for subscript declared in a fileprivate extension
522 | fileprivate extension Array where Element == GrammarStructure.Node {
523 |
524 |     fileprivate subscript(_ name:String)->GrammarStructure.Node? {
    |     `- warning: 'fileprivate' modifier is redundant for subscript declared in a fileprivate extension
525 |         return self.filter({$0.name == name}).first
526 |     }
/host/spi-builder-workspace/Sources/STLR/Generators/GrammarStructure+STLR.swift:528:5: warning: 'fileprivate' modifier is redundant for instance method declared in a fileprivate extension
526 |     }
527 |
528 |     fileprivate func consolidate(accessLevel:String)->[Element]{
    |     `- warning: 'fileprivate' modifier is redundant for instance method declared in a fileprivate extension
529 |         var existingFields = [String : GrammarStructure.Node]()
530 |
/host/spi-builder-workspace/Sources/STLR/Generators/Swift/STLR+SwiftGrammar.swift:37:5: warning: 'public' modifier is redundant for instance method declared in a public extension
 35 |      - Returns: A `String` containing the Swift source or `nil` if an error occured.
 36 |      */
 37 |     public func swift(in file:TextFile){
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
 38 |         let grammarName = grammar.scopeName
 39 |
/host/spi-builder-workspace/Sources/STLR/STLR Validation.swift:32:5: warning: 'public' modifier is redundant for instance method declared in a public extension
30 |
31 |     /// Validates the AST throwing an exception if validation fails
32 |     public func validate() throws{
   |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
33 |     }
34 | }
/host/spi-builder-workspace/Sources/STLR/STLR+Optimization.swift:31:5: warning: 'public' modifier is redundant for instance method declared in a public extension
29 |
30 |     /// Optimizes the grammar using the optimizers registered by `register(optimizer:STLROptimizer)`
31 |     public func optimize(){
   |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
32 |     }
33 | }
/host/spi-builder-workspace/Sources/STLR/STLROptimizers.swift:46:13: warning: var 'optmizers' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
44 | }
45 |
46 | private var optmizers = [STLROptimizer]()
   |             |- warning: var 'optmizers' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
   |             |- note: convert 'optmizers' to a 'let' constant to make 'Sendable' shared state immutable
   |             |- note: annotate 'optmizers' with '@MainActor' if property should only be accessed from the main actor
   |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
47 |
48 | /// Adds methods to register optimizers
/host/spi-builder-workspace/Sources/STLR/STLROptimizers.swift:55:5: warning: 'public' modifier is redundant for static method declared in a public extension
53 |      - Parameter optimizer: The optimizer
54 |     */
55 |     public static func register(optimizer:STLROptimizer){
   |     `- warning: 'public' modifier is redundant for static method declared in a public extension
56 |         optmizers.append(optimizer)
57 |     }
/host/spi-builder-workspace/Sources/STLR/STLROptimizers.swift:60:5: warning: 'public' modifier is redundant for static method declared in a public extension
58 |
59 |     /// Removes all registered optimizers
60 |     public static func removeAllOptimizations(){
   |     `- warning: 'public' modifier is redundant for static method declared in a public extension
61 |         optmizers.removeAll()
62 |     }
[72/89] Compiling STLR TextFile.swift
/host/spi-builder-workspace/Sources/STLR/Generators/Generator.swift:34:14: warning: Make name optional and overriding
32 |     ///
33 |     ///  - Parameter scope: The scope
34 |     #warning("Make name optional and overriding")
   |              `- warning: Make name optional and overriding
35 |     static func generate(for scope:STLR, grammar name:String, accessLevel:String) throws ->[Operation]
36 | }
/host/spi-builder-workspace/Sources/STLR/Generators/GrammarStructure+STLR.swift:524:5: warning: 'fileprivate' modifier is redundant for subscript declared in a fileprivate extension
522 | fileprivate extension Array where Element == GrammarStructure.Node {
523 |
524 |     fileprivate subscript(_ name:String)->GrammarStructure.Node? {
    |     `- warning: 'fileprivate' modifier is redundant for subscript declared in a fileprivate extension
525 |         return self.filter({$0.name == name}).first
526 |     }
/host/spi-builder-workspace/Sources/STLR/Generators/GrammarStructure+STLR.swift:528:5: warning: 'fileprivate' modifier is redundant for instance method declared in a fileprivate extension
526 |     }
527 |
528 |     fileprivate func consolidate(accessLevel:String)->[Element]{
    |     `- warning: 'fileprivate' modifier is redundant for instance method declared in a fileprivate extension
529 |         var existingFields = [String : GrammarStructure.Node]()
530 |
/host/spi-builder-workspace/Sources/OysterKit/Rules/Cadinality.swift:60:23: warning: static property 'one' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
25 | /// Represents the cardinality of a rule. It can be specified as a closed range,
26 | /// including those with no upper bound (`PartialRangeFrom`)
27 | public struct Cardinality : Equatable {
   |               `- note: consider making struct 'Cardinality' conform to the 'Sendable' protocol
28 |     /// The minimum number of matches, must be >= 0
29 |     public let minimumMatches : Int
   :
58 |
59 |     /// A pre-specified constant for one and exactly one matches
60 |     public static let one = Cardinality(1...1)
   |                       |- warning: static property 'one' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'one' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
61 |
62 |     /// A pre-specified constant for optional matches (between 0 and 1 matches)
/host/spi-builder-workspace/Sources/OysterKit/Rules/Cadinality.swift:63:23: warning: static property 'zeroOrOne' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
25 | /// Represents the cardinality of a rule. It can be specified as a closed range,
26 | /// including those with no upper bound (`PartialRangeFrom`)
27 | public struct Cardinality : Equatable {
   |               `- note: consider making struct 'Cardinality' conform to the 'Sendable' protocol
28 |     /// The minimum number of matches, must be >= 0
29 |     public let minimumMatches : Int
   :
61 |
62 |     /// A pre-specified constant for optional matches (between 0 and 1 matches)
63 |     public static let zeroOrOne = Cardinality(0...1)
   |                       |- warning: static property 'zeroOrOne' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'zeroOrOne' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
64 |
65 |     /// A pre-specified constant for optional but unbound matches (between 0 and infinity matches)
/host/spi-builder-workspace/Sources/OysterKit/Rules/Cadinality.swift:66:23: warning: static property 'zeroOrMore' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
25 | /// Represents the cardinality of a rule. It can be specified as a closed range,
26 | /// including those with no upper bound (`PartialRangeFrom`)
27 | public struct Cardinality : Equatable {
   |               `- note: consider making struct 'Cardinality' conform to the 'Sendable' protocol
28 |     /// The minimum number of matches, must be >= 0
29 |     public let minimumMatches : Int
   :
64 |
65 |     /// A pre-specified constant for optional but unbound matches (between 0 and infinity matches)
66 |     public static let zeroOrMore = Cardinality(0...)
   |                       |- warning: static property 'zeroOrMore' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'zeroOrMore' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
67 |
68 |     /// A pre-specified constant for required but unbound matches (between 1 and infinity matches)
/host/spi-builder-workspace/Sources/STLR/Generators/GrammarStructure+STLR.swift:464:21: warning: initialization of immutable value 'rule' was never used; consider replacing with assignment to '_' or removing it
462 |
463 |             if case let Behaviour.Kind.structural(token) = element.kind {
464 |                 let rule = scope.grammar["\(token)"]
    |                     `- warning: initialization of immutable value 'rule' was never used; consider replacing with assignment to '_' or removing it
465 |
466 |                 return [
/host/spi-builder-workspace/Sources/STLR/Generators/GrammarStructure+STLR.swift:539:120: warning: string interpolation produces a debug description for a function value; did you mean to make this explicit?
537 |                     //Do nothing, it will work fine
538 |                 } else {
539 |                     fatalError("There are multiple fields with the same name (\(child.name)) but different types:\n\t\(child.dataType)\n\t\(existingType)\nCannot generate structure")
    |                                                                                                                        |     `- note: use 'String(describing:)' to silence this warning
    |                                                                                                                        `- warning: string interpolation produces a debug description for a function value; did you mean to make this explicit?
540 |                 }
541 |             } else {
[73/89] Compiling STLR Generator.swift
/host/spi-builder-workspace/Sources/STLR/Generators/Generator.swift:34:14: warning: Make name optional and overriding
32 |     ///
33 |     ///  - Parameter scope: The scope
34 |     #warning("Make name optional and overriding")
   |              `- warning: Make name optional and overriding
35 |     static func generate(for scope:STLR, grammar name:String, accessLevel:String) throws ->[Operation]
36 | }
/host/spi-builder-workspace/Sources/STLR/Generators/GrammarStructure+STLR.swift:524:5: warning: 'fileprivate' modifier is redundant for subscript declared in a fileprivate extension
522 | fileprivate extension Array where Element == GrammarStructure.Node {
523 |
524 |     fileprivate subscript(_ name:String)->GrammarStructure.Node? {
    |     `- warning: 'fileprivate' modifier is redundant for subscript declared in a fileprivate extension
525 |         return self.filter({$0.name == name}).first
526 |     }
/host/spi-builder-workspace/Sources/STLR/Generators/GrammarStructure+STLR.swift:528:5: warning: 'fileprivate' modifier is redundant for instance method declared in a fileprivate extension
526 |     }
527 |
528 |     fileprivate func consolidate(accessLevel:String)->[Element]{
    |     `- warning: 'fileprivate' modifier is redundant for instance method declared in a fileprivate extension
529 |         var existingFields = [String : GrammarStructure.Node]()
530 |
/host/spi-builder-workspace/Sources/OysterKit/Rules/Cadinality.swift:60:23: warning: static property 'one' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
25 | /// Represents the cardinality of a rule. It can be specified as a closed range,
26 | /// including those with no upper bound (`PartialRangeFrom`)
27 | public struct Cardinality : Equatable {
   |               `- note: consider making struct 'Cardinality' conform to the 'Sendable' protocol
28 |     /// The minimum number of matches, must be >= 0
29 |     public let minimumMatches : Int
   :
58 |
59 |     /// A pre-specified constant for one and exactly one matches
60 |     public static let one = Cardinality(1...1)
   |                       |- warning: static property 'one' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'one' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
61 |
62 |     /// A pre-specified constant for optional matches (between 0 and 1 matches)
/host/spi-builder-workspace/Sources/OysterKit/Rules/Cadinality.swift:63:23: warning: static property 'zeroOrOne' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
25 | /// Represents the cardinality of a rule. It can be specified as a closed range,
26 | /// including those with no upper bound (`PartialRangeFrom`)
27 | public struct Cardinality : Equatable {
   |               `- note: consider making struct 'Cardinality' conform to the 'Sendable' protocol
28 |     /// The minimum number of matches, must be >= 0
29 |     public let minimumMatches : Int
   :
61 |
62 |     /// A pre-specified constant for optional matches (between 0 and 1 matches)
63 |     public static let zeroOrOne = Cardinality(0...1)
   |                       |- warning: static property 'zeroOrOne' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'zeroOrOne' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
64 |
65 |     /// A pre-specified constant for optional but unbound matches (between 0 and infinity matches)
/host/spi-builder-workspace/Sources/OysterKit/Rules/Cadinality.swift:66:23: warning: static property 'zeroOrMore' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
25 | /// Represents the cardinality of a rule. It can be specified as a closed range,
26 | /// including those with no upper bound (`PartialRangeFrom`)
27 | public struct Cardinality : Equatable {
   |               `- note: consider making struct 'Cardinality' conform to the 'Sendable' protocol
28 |     /// The minimum number of matches, must be >= 0
29 |     public let minimumMatches : Int
   :
64 |
65 |     /// A pre-specified constant for optional but unbound matches (between 0 and infinity matches)
66 |     public static let zeroOrMore = Cardinality(0...)
   |                       |- warning: static property 'zeroOrMore' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'zeroOrMore' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
67 |
68 |     /// A pre-specified constant for required but unbound matches (between 1 and infinity matches)
/host/spi-builder-workspace/Sources/STLR/Generators/GrammarStructure+STLR.swift:464:21: warning: initialization of immutable value 'rule' was never used; consider replacing with assignment to '_' or removing it
462 |
463 |             if case let Behaviour.Kind.structural(token) = element.kind {
464 |                 let rule = scope.grammar["\(token)"]
    |                     `- warning: initialization of immutable value 'rule' was never used; consider replacing with assignment to '_' or removing it
465 |
466 |                 return [
/host/spi-builder-workspace/Sources/STLR/Generators/GrammarStructure+STLR.swift:539:120: warning: string interpolation produces a debug description for a function value; did you mean to make this explicit?
537 |                     //Do nothing, it will work fine
538 |                 } else {
539 |                     fatalError("There are multiple fields with the same name (\(child.name)) but different types:\n\t\(child.dataType)\n\t\(existingType)\nCannot generate structure")
    |                                                                                                                        |     `- note: use 'String(describing:)' to silence this warning
    |                                                                                                                        `- warning: string interpolation produces a debug description for a function value; did you mean to make this explicit?
540 |                 }
541 |             } else {
[74/89] Compiling STLR GrammarStructure+STLR.swift
/host/spi-builder-workspace/Sources/STLR/Generators/Generator.swift:34:14: warning: Make name optional and overriding
32 |     ///
33 |     ///  - Parameter scope: The scope
34 |     #warning("Make name optional and overriding")
   |              `- warning: Make name optional and overriding
35 |     static func generate(for scope:STLR, grammar name:String, accessLevel:String) throws ->[Operation]
36 | }
/host/spi-builder-workspace/Sources/STLR/Generators/GrammarStructure+STLR.swift:524:5: warning: 'fileprivate' modifier is redundant for subscript declared in a fileprivate extension
522 | fileprivate extension Array where Element == GrammarStructure.Node {
523 |
524 |     fileprivate subscript(_ name:String)->GrammarStructure.Node? {
    |     `- warning: 'fileprivate' modifier is redundant for subscript declared in a fileprivate extension
525 |         return self.filter({$0.name == name}).first
526 |     }
/host/spi-builder-workspace/Sources/STLR/Generators/GrammarStructure+STLR.swift:528:5: warning: 'fileprivate' modifier is redundant for instance method declared in a fileprivate extension
526 |     }
527 |
528 |     fileprivate func consolidate(accessLevel:String)->[Element]{
    |     `- warning: 'fileprivate' modifier is redundant for instance method declared in a fileprivate extension
529 |         var existingFields = [String : GrammarStructure.Node]()
530 |
/host/spi-builder-workspace/Sources/OysterKit/Rules/Cadinality.swift:60:23: warning: static property 'one' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
25 | /// Represents the cardinality of a rule. It can be specified as a closed range,
26 | /// including those with no upper bound (`PartialRangeFrom`)
27 | public struct Cardinality : Equatable {
   |               `- note: consider making struct 'Cardinality' conform to the 'Sendable' protocol
28 |     /// The minimum number of matches, must be >= 0
29 |     public let minimumMatches : Int
   :
58 |
59 |     /// A pre-specified constant for one and exactly one matches
60 |     public static let one = Cardinality(1...1)
   |                       |- warning: static property 'one' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'one' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
61 |
62 |     /// A pre-specified constant for optional matches (between 0 and 1 matches)
/host/spi-builder-workspace/Sources/OysterKit/Rules/Cadinality.swift:63:23: warning: static property 'zeroOrOne' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
25 | /// Represents the cardinality of a rule. It can be specified as a closed range,
26 | /// including those with no upper bound (`PartialRangeFrom`)
27 | public struct Cardinality : Equatable {
   |               `- note: consider making struct 'Cardinality' conform to the 'Sendable' protocol
28 |     /// The minimum number of matches, must be >= 0
29 |     public let minimumMatches : Int
   :
61 |
62 |     /// A pre-specified constant for optional matches (between 0 and 1 matches)
63 |     public static let zeroOrOne = Cardinality(0...1)
   |                       |- warning: static property 'zeroOrOne' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'zeroOrOne' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
64 |
65 |     /// A pre-specified constant for optional but unbound matches (between 0 and infinity matches)
/host/spi-builder-workspace/Sources/OysterKit/Rules/Cadinality.swift:66:23: warning: static property 'zeroOrMore' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
25 | /// Represents the cardinality of a rule. It can be specified as a closed range,
26 | /// including those with no upper bound (`PartialRangeFrom`)
27 | public struct Cardinality : Equatable {
   |               `- note: consider making struct 'Cardinality' conform to the 'Sendable' protocol
28 |     /// The minimum number of matches, must be >= 0
29 |     public let minimumMatches : Int
   :
64 |
65 |     /// A pre-specified constant for optional but unbound matches (between 0 and infinity matches)
66 |     public static let zeroOrMore = Cardinality(0...)
   |                       |- warning: static property 'zeroOrMore' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'zeroOrMore' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
67 |
68 |     /// A pre-specified constant for required but unbound matches (between 1 and infinity matches)
/host/spi-builder-workspace/Sources/STLR/Generators/GrammarStructure+STLR.swift:464:21: warning: initialization of immutable value 'rule' was never used; consider replacing with assignment to '_' or removing it
462 |
463 |             if case let Behaviour.Kind.structural(token) = element.kind {
464 |                 let rule = scope.grammar["\(token)"]
    |                     `- warning: initialization of immutable value 'rule' was never used; consider replacing with assignment to '_' or removing it
465 |
466 |                 return [
/host/spi-builder-workspace/Sources/STLR/Generators/GrammarStructure+STLR.swift:539:120: warning: string interpolation produces a debug description for a function value; did you mean to make this explicit?
537 |                     //Do nothing, it will work fine
538 |                 } else {
539 |                     fatalError("There are multiple fields with the same name (\(child.name)) but different types:\n\t\(child.dataType)\n\t\(existingType)\nCannot generate structure")
    |                                                                                                                        |     `- note: use 'String(describing:)' to silence this warning
    |                                                                                                                        `- warning: string interpolation produces a debug description for a function value; did you mean to make this explicit?
540 |                 }
541 |             } else {
[75/89] Compiling STLR SwiftRules.swift
/host/spi-builder-workspace/Sources/OysterKit/Rules/Cadinality.swift:60:23: warning: static property 'one' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
25 | /// Represents the cardinality of a rule. It can be specified as a closed range,
26 | /// including those with no upper bound (`PartialRangeFrom`)
27 | public struct Cardinality : Equatable {
   |               `- note: consider making struct 'Cardinality' conform to the 'Sendable' protocol
28 |     /// The minimum number of matches, must be >= 0
29 |     public let minimumMatches : Int
   :
58 |
59 |     /// A pre-specified constant for one and exactly one matches
60 |     public static let one = Cardinality(1...1)
   |                       |- warning: static property 'one' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'one' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
61 |
62 |     /// A pre-specified constant for optional matches (between 0 and 1 matches)
[76/89] Compiling STLR SwiftStructure.swift
/host/spi-builder-workspace/Sources/OysterKit/Rules/Cadinality.swift:60:23: warning: static property 'one' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
25 | /// Represents the cardinality of a rule. It can be specified as a closed range,
26 | /// including those with no upper bound (`PartialRangeFrom`)
27 | public struct Cardinality : Equatable {
   |               `- note: consider making struct 'Cardinality' conform to the 'Sendable' protocol
28 |     /// The minimum number of matches, must be >= 0
29 |     public let minimumMatches : Int
   :
58 |
59 |     /// A pre-specified constant for one and exactly one matches
60 |     public static let one = Cardinality(1...1)
   |                       |- warning: static property 'one' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'one' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
61 |
62 |     /// A pre-specified constant for optional matches (between 0 and 1 matches)
[77/89] Compiling STLR CharacterSetOnlyChoiceOptimizer.swift
/host/spi-builder-workspace/Sources/OysterKit/Rules/Cadinality.swift:60:23: warning: static property 'one' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
25 | /// Represents the cardinality of a rule. It can be specified as a closed range,
26 | /// including those with no upper bound (`PartialRangeFrom`)
27 | public struct Cardinality : Equatable {
   |               `- note: consider making struct 'Cardinality' conform to the 'Sendable' protocol
28 |     /// The minimum number of matches, must be >= 0
29 |     public let minimumMatches : Int
   :
58 |
59 |     /// A pre-specified constant for one and exactly one matches
60 |     public static let one = Cardinality(1...1)
   |                       |- warning: static property 'one' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'one' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
61 |
62 |     /// A pre-specified constant for optional matches (between 0 and 1 matches)
[78/89] Compiling STLR STLR+Extensions.swift
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:149:5: warning: 'public' modifier is redundant for instance method declared in a public extension
147 |     }
148 |
149 |     public func defined(identifier:String)->Bool{
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
150 |         for rule in rules {
151 |             if rule.identifier == identifier {
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:209:5: warning: 'public' modifier is redundant for property declared in a public extension
207 |
208 |     /// All rules, including those defined inline
209 |     public var allRules : STLR.Rules {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
210 |         var all = STLR.Rules()
211 |         all.append(contentsOf: rules)
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:216:5: warning: 'public' modifier is redundant for subscript declared in a public extension
214 |     }
215 |
216 |     public subscript(_ identifier:String)->STLR.Rule{
    |     `- warning: 'public' modifier is redundant for subscript declared in a public extension
217 |         for rule in rules {
218 |             if rule.identifier == identifier {
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:242:5: warning: 'public' modifier is redundant for instance method declared in a public extension
240 |     }
241 |
242 |     public func isLeftHandRecursive(identifier:String)->Bool{
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
243 |         var closedList = [String]()
244 |         return self[identifier].expression.references(identifier, grammar: self, closedList: &closedList)
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:247:5: warning: 'public' modifier is redundant for instance method declared in a public extension
245 |     }
246 |
247 |     public func isDirectLeftHandRecursive(identifier:String)->Bool{
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
248 |         var closedList = [String]()
249 |         return self[identifier].expression.directlyReferences(identifier, grammar: self, closedList: &closedList)
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:252:5: warning: 'public' modifier is redundant for instance method declared in a public extension
250 |     }
251 |
252 |     public func isRoot(identifier:String)->Bool{
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
253 |         var closedList = [String]()
254 |         for rule in rules {
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:262:5: warning: 'public' modifier is redundant for instance method declared in a public extension
260 |     }
261 |
262 |     public func validate(rule:STLR.Rule) throws {
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
263 |         if isDirectLeftHandRecursive(identifier: rule.identifier){
264 |             throw ProcessingError.interpretation(message: "\(rule.identifier) is directly left hand recursive (references itself without moving scan head forward)", causes: [])
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:272:5: warning: 'public' modifier is redundant for property declared in a public extension
270 | public extension STLR.Rule {
271 |     /// True if the rule is skipping
272 |     public var isVoid : Bool {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
273 |         return void != nil || (annotations?.void ?? false)
274 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:277:5: warning: 'public' modifier is redundant for property declared in a public extension
275 |
276 |     /// True if it is a scanning rule
277 |     public var isTransient : Bool {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
278 |         return transient != nil || (annotations?.transient ?? false)
279 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:281:5: warning: 'public' modifier is redundant for property declared in a public extension
279 |     }
280 |
281 |     public var type : String? {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
282 |         return annotations?.type
283 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:288:5: warning: 'public' modifier is redundant for property declared in a public extension
286 | public extension STLR.Quantifier {
287 |     /// The minimum number of matches required to satisfy the quantifier
288 |     public var minimumMatches : Int {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
289 |         switch self {
290 |         case .star, .questionMark:
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:300:5: warning: 'public' modifier is redundant for property declared in a public extension
298 |
299 |     /// The maximum number of matches required to satisfy the quantifier
300 |     public var maximumMatches : Int? {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
301 |         switch self {
302 |         case .questionMark:
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:338:5: warning: 'public' modifier is redundant for instance method declared in a public extension
336 |     }
337 |
338 |     public func directlyReferences(_ identifier:String, grammar:STLR.Grammar, closedList:inout [String])->Bool {
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
339 |         for element in elements {
340 |             if element.directlyReferences(identifier, grammar: grammar, closedList: &closedList){
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:353:5: warning: 'public' modifier is redundant for instance method declared in a public extension
351 |
352 |
353 |     public func references(_ identifier:String, grammar:STLR.Grammar, closedList: inout [String])->Bool {
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
354 |         for element in elements {
355 |             if element.references(identifier, grammar: grammar, closedList: &closedList){
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:366:5: warning: 'public' modifier is redundant for property declared in a public extension
364 |
365 |     /// The annotations defined as `RuleAnnotations`
366 |     public var ruleAnnotations : RuleAnnotations {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
367 |         return annotations?.ruleAnnotations ?? [:]
368 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:371:5: warning: 'public' modifier is redundant for property declared in a public extension
369 |
370 |     /// True if the element is skipping
371 |     public var isVoid : Bool {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
372 |         return void != nil || (annotations?.void ?? false)
373 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:376:5: warning: 'public' modifier is redundant for property declared in a public extension
374 |
375 |     /// True if it is a scanning element
376 |     public var isTransient : Bool {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
377 |         return transient != nil || (annotations?.transient ?? false)
378 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:381:5: warning: 'public' modifier is redundant for property declared in a public extension
379 |
380 |     /// True if the element is lookahead
381 |     public var isLookahead : Bool {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
382 |         return lookahead != nil
383 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:386:5: warning: 'public' modifier is redundant for property declared in a public extension
384 |
385 |     /// True if the element is negated
386 |     public var isNegated : Bool {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
387 |         return negated != nil
388 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:391:5: warning: 'public' modifier is redundant for property declared in a public extension
389 |
390 |     /// Returns the token name (if any) of the element
391 |     public var token : TokenType? {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
392 |         if case let Behaviour.Kind.structural(token) = kind {
393 |             return token
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:400:5: warning: 'public' modifier is redundant for property declared in a public extension
398 |
399 |     /// The `Kind` of the rule
400 |     public var kind : Behaviour.Kind {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
401 |         if isVoid {
402 |             return .skipping
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:418:5: warning: 'public' modifier is redundant for property declared in a public extension
416 |
417 |     /// The `Cardinality` of the match
418 |     public var cardinality : Cardinality {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
419 |         guard let quantifier = quantifier else {
420 |             return .one
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:436:5: warning: 'public' modifier is redundant for property declared in a public extension
434 |
435 |     /// The `Behaviour` of the rule
436 |     public var behaviour : Behaviour {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
437 |         return Behaviour(kind, cardinality: cardinality, negated: isNegated, lookahead: isLookahead)
438 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:463:5: warning: 'public' modifier is redundant for instance method declared in a public extension
461 |      - Returns: `true` if the identifier could be referenced before the scan head has moved
462 |     */
463 |     public func directlyReferences(_ identifier:String, grammar:STLR.Grammar)->Bool{
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
464 |         var closedList = [String]()
465 |         return directlyReferences(identifier, grammar: grammar, closedList: &closedList)
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:620:5: warning: 'internal' modifier is redundant for property declared in an internal extension
618 | internal extension Array where Element == STLR.Annotation {
619 |     /// The annotations on the element with any that would be captured in `Behaviour` removed (@token, @transient, @void)
620 |     internal var unfilteredRuleAnnotationsForTesting : RuleAnnotations {
    |     `- warning: 'internal' modifier is redundant for property declared in an internal extension
621 |         var ruleAnnotations = [RuleAnnotation : RuleAnnotationValue]()
622 |         for annotation in self {
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:641:5: warning: 'public' modifier is redundant for property declared in a public extension
639 |
640 |     /// The annotations on the element with any that would be captured in `Behaviour` removed (@token, @transient, @void)
641 |     public var ruleAnnotations : RuleAnnotations {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
642 |         var ruleAnnotations = [RuleAnnotation : RuleAnnotationValue]()
643 |         for annotation in filter({!$0.label.isBehavioural}){
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:650:5: warning: 'public' modifier is redundant for property declared in a public extension
648 |
649 |     /// The token if any specified in the annotations
650 |     public var token : String? {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
651 |         guard let tokenAnnotationValue = self[RuleAnnotation.token] else {
652 |             return nil
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:665:5: warning: 'public' modifier is redundant for property declared in a public extension
663 |
664 |     /// `true` if the annotations include @void
665 |     public var void : Bool {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
666 |         return self[RuleAnnotation.void] != nil
667 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:670:5: warning: 'public' modifier is redundant for property declared in a public extension
668 |
669 |     /// `true` if the annotations include @transient
670 |     public var transient : Bool {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
671 |         return self[RuleAnnotation.transient] != nil
672 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:673:5: warning: 'public' modifier is redundant for property declared in a public extension
671 |         return self[RuleAnnotation.transient] != nil
672 |     }
673 |     public var type : String? {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
674 |         if let typeAnnotationValue = self[RuleAnnotation.type] {
675 |             if case let RuleAnnotationValue.string(value) =  typeAnnotationValue {
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:46:22: warning: Should be defined as standard type in STLR.stlr
 44 |             self = .definedLabel(definedLabel: STLR.DefinedLabel.transient)
 45 |         case .pinned:
 46 |             #warning("Should be defined as standard type in STLR.stlr")
    |                      `- warning: Should be defined as standard type in STLR.stlr
 47 |             self = .customLabel(customLabel: "pin")
 48 |         case .type:
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:49:22: warning: Should be defined as standard type in STLR.stlr
 47 |             self = .customLabel(customLabel: "pin")
 48 |         case .type:
 49 |             #warning("Should be defined as standard type in STLR.stlr")
    |                      `- warning: Should be defined as standard type in STLR.stlr
 50 |             self = .customLabel(customLabel: "type")
 51 |         case .custom(let label):
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:410:26: warning: Possible bug? should it be returning the kid of the identifier?
408 |         } else {
409 |             if let identifier = identifier {
410 |                 #warning("Possible bug? should it be returning the kid of the identifier?")
    |                          `- warning: Possible bug? should it be returning the kid of the identifier?
411 |                 return .structural(token:StringToken(identifier))
412 |             }
/host/spi-builder-workspace/Sources/OysterKit/Rules/Cadinality.swift:60:23: warning: static property 'one' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
25 | /// Represents the cardinality of a rule. It can be specified as a closed range,
26 | /// including those with no upper bound (`PartialRangeFrom`)
27 | public struct Cardinality : Equatable {
   |               `- note: consider making struct 'Cardinality' conform to the 'Sendable' protocol
28 |     /// The minimum number of matches, must be >= 0
29 |     public let minimumMatches : Int
   :
58 |
59 |     /// A pre-specified constant for one and exactly one matches
60 |     public static let one = Cardinality(1...1)
   |                       |- warning: static property 'one' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'one' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
61 |
62 |     /// A pre-specified constant for optional matches (between 0 and 1 matches)
/host/spi-builder-workspace/Sources/OysterKit/Rules/Cadinality.swift:63:23: warning: static property 'zeroOrOne' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
25 | /// Represents the cardinality of a rule. It can be specified as a closed range,
26 | /// including those with no upper bound (`PartialRangeFrom`)
27 | public struct Cardinality : Equatable {
   |               `- note: consider making struct 'Cardinality' conform to the 'Sendable' protocol
28 |     /// The minimum number of matches, must be >= 0
29 |     public let minimumMatches : Int
   :
61 |
62 |     /// A pre-specified constant for optional matches (between 0 and 1 matches)
63 |     public static let zeroOrOne = Cardinality(0...1)
   |                       |- warning: static property 'zeroOrOne' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'zeroOrOne' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
64 |
65 |     /// A pre-specified constant for optional but unbound matches (between 0 and infinity matches)
/host/spi-builder-workspace/Sources/OysterKit/Rules/Cadinality.swift:66:23: warning: static property 'zeroOrMore' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
25 | /// Represents the cardinality of a rule. It can be specified as a closed range,
26 | /// including those with no upper bound (`PartialRangeFrom`)
27 | public struct Cardinality : Equatable {
   |               `- note: consider making struct 'Cardinality' conform to the 'Sendable' protocol
28 |     /// The minimum number of matches, must be >= 0
29 |     public let minimumMatches : Int
   :
64 |
65 |     /// A pre-specified constant for optional but unbound matches (between 0 and infinity matches)
66 |     public static let zeroOrMore = Cardinality(0...)
   |                       |- warning: static property 'zeroOrMore' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'zeroOrMore' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
67 |
68 |     /// A pre-specified constant for required but unbound matches (between 1 and infinity matches)
/host/spi-builder-workspace/Sources/OysterKit/Rules/Cadinality.swift:69:23: warning: static property 'oneOrMore' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
25 | /// Represents the cardinality of a rule. It can be specified as a closed range,
26 | /// including those with no upper bound (`PartialRangeFrom`)
27 | public struct Cardinality : Equatable {
   |               `- note: consider making struct 'Cardinality' conform to the 'Sendable' protocol
28 |     /// The minimum number of matches, must be >= 0
29 |     public let minimumMatches : Int
   :
67 |
68 |     /// A pre-specified constant for required but unbound matches (between 1 and infinity matches)
69 |     public static let oneOrMore = Cardinality(1...)
   |                       |- warning: static property 'oneOrMore' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'oneOrMore' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
70 |
71 |     /// The equality function
/host/spi-builder-workspace/Sources/STLR/Generated/STLR.swift:8:24: warning: static property 'regularExpressionCache' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
  6 |     typealias T = STLRTokens
  7 |     // Cache for compiled regular expressions
  8 |     private static var regularExpressionCache = [String : NSRegularExpression]()
    |                        |- warning: static property 'regularExpressionCache' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
    |                        |- note: convert 'regularExpressionCache' to a 'let' constant to make 'Sendable' shared state immutable
    |                        |- note: annotate 'regularExpressionCache' with '@MainActor' if property should only be accessed from the main actor
    |                        `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
  9 |
 10 |     /// Returns a pre-compiled pattern from the cache, or if not in the cache builds
/host/spi-builder-workspace/Sources/STLR/Generated/STLR.swift:301:24: warning: static property 'leftHandRecursiveRules' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
299 |
300 |     /// Cache for left-hand recursive rules
301 |     private static var leftHandRecursiveRules = [ Int : Rule ]()
    |                        |- warning: static property 'leftHandRecursiveRules' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
    |                        |- note: convert 'leftHandRecursiveRules' to a 'let' constant to make 'Sendable' shared state immutable
    |                        |- note: annotate 'leftHandRecursiveRules' with '@MainActor' if property should only be accessed from the main actor
    |                        `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
302 |
303 |     /// Create a language that can be used for parsing etc
[79/89] Compiling STLR STLR.swift
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:149:5: warning: 'public' modifier is redundant for instance method declared in a public extension
147 |     }
148 |
149 |     public func defined(identifier:String)->Bool{
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
150 |         for rule in rules {
151 |             if rule.identifier == identifier {
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:209:5: warning: 'public' modifier is redundant for property declared in a public extension
207 |
208 |     /// All rules, including those defined inline
209 |     public var allRules : STLR.Rules {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
210 |         var all = STLR.Rules()
211 |         all.append(contentsOf: rules)
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:216:5: warning: 'public' modifier is redundant for subscript declared in a public extension
214 |     }
215 |
216 |     public subscript(_ identifier:String)->STLR.Rule{
    |     `- warning: 'public' modifier is redundant for subscript declared in a public extension
217 |         for rule in rules {
218 |             if rule.identifier == identifier {
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:242:5: warning: 'public' modifier is redundant for instance method declared in a public extension
240 |     }
241 |
242 |     public func isLeftHandRecursive(identifier:String)->Bool{
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
243 |         var closedList = [String]()
244 |         return self[identifier].expression.references(identifier, grammar: self, closedList: &closedList)
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:247:5: warning: 'public' modifier is redundant for instance method declared in a public extension
245 |     }
246 |
247 |     public func isDirectLeftHandRecursive(identifier:String)->Bool{
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
248 |         var closedList = [String]()
249 |         return self[identifier].expression.directlyReferences(identifier, grammar: self, closedList: &closedList)
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:252:5: warning: 'public' modifier is redundant for instance method declared in a public extension
250 |     }
251 |
252 |     public func isRoot(identifier:String)->Bool{
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
253 |         var closedList = [String]()
254 |         for rule in rules {
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:262:5: warning: 'public' modifier is redundant for instance method declared in a public extension
260 |     }
261 |
262 |     public func validate(rule:STLR.Rule) throws {
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
263 |         if isDirectLeftHandRecursive(identifier: rule.identifier){
264 |             throw ProcessingError.interpretation(message: "\(rule.identifier) is directly left hand recursive (references itself without moving scan head forward)", causes: [])
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:272:5: warning: 'public' modifier is redundant for property declared in a public extension
270 | public extension STLR.Rule {
271 |     /// True if the rule is skipping
272 |     public var isVoid : Bool {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
273 |         return void != nil || (annotations?.void ?? false)
274 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:277:5: warning: 'public' modifier is redundant for property declared in a public extension
275 |
276 |     /// True if it is a scanning rule
277 |     public var isTransient : Bool {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
278 |         return transient != nil || (annotations?.transient ?? false)
279 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:281:5: warning: 'public' modifier is redundant for property declared in a public extension
279 |     }
280 |
281 |     public var type : String? {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
282 |         return annotations?.type
283 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:288:5: warning: 'public' modifier is redundant for property declared in a public extension
286 | public extension STLR.Quantifier {
287 |     /// The minimum number of matches required to satisfy the quantifier
288 |     public var minimumMatches : Int {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
289 |         switch self {
290 |         case .star, .questionMark:
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:300:5: warning: 'public' modifier is redundant for property declared in a public extension
298 |
299 |     /// The maximum number of matches required to satisfy the quantifier
300 |     public var maximumMatches : Int? {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
301 |         switch self {
302 |         case .questionMark:
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:338:5: warning: 'public' modifier is redundant for instance method declared in a public extension
336 |     }
337 |
338 |     public func directlyReferences(_ identifier:String, grammar:STLR.Grammar, closedList:inout [String])->Bool {
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
339 |         for element in elements {
340 |             if element.directlyReferences(identifier, grammar: grammar, closedList: &closedList){
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:353:5: warning: 'public' modifier is redundant for instance method declared in a public extension
351 |
352 |
353 |     public func references(_ identifier:String, grammar:STLR.Grammar, closedList: inout [String])->Bool {
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
354 |         for element in elements {
355 |             if element.references(identifier, grammar: grammar, closedList: &closedList){
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:366:5: warning: 'public' modifier is redundant for property declared in a public extension
364 |
365 |     /// The annotations defined as `RuleAnnotations`
366 |     public var ruleAnnotations : RuleAnnotations {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
367 |         return annotations?.ruleAnnotations ?? [:]
368 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:371:5: warning: 'public' modifier is redundant for property declared in a public extension
369 |
370 |     /// True if the element is skipping
371 |     public var isVoid : Bool {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
372 |         return void != nil || (annotations?.void ?? false)
373 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:376:5: warning: 'public' modifier is redundant for property declared in a public extension
374 |
375 |     /// True if it is a scanning element
376 |     public var isTransient : Bool {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
377 |         return transient != nil || (annotations?.transient ?? false)
378 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:381:5: warning: 'public' modifier is redundant for property declared in a public extension
379 |
380 |     /// True if the element is lookahead
381 |     public var isLookahead : Bool {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
382 |         return lookahead != nil
383 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:386:5: warning: 'public' modifier is redundant for property declared in a public extension
384 |
385 |     /// True if the element is negated
386 |     public var isNegated : Bool {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
387 |         return negated != nil
388 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:391:5: warning: 'public' modifier is redundant for property declared in a public extension
389 |
390 |     /// Returns the token name (if any) of the element
391 |     public var token : TokenType? {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
392 |         if case let Behaviour.Kind.structural(token) = kind {
393 |             return token
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:400:5: warning: 'public' modifier is redundant for property declared in a public extension
398 |
399 |     /// The `Kind` of the rule
400 |     public var kind : Behaviour.Kind {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
401 |         if isVoid {
402 |             return .skipping
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:418:5: warning: 'public' modifier is redundant for property declared in a public extension
416 |
417 |     /// The `Cardinality` of the match
418 |     public var cardinality : Cardinality {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
419 |         guard let quantifier = quantifier else {
420 |             return .one
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:436:5: warning: 'public' modifier is redundant for property declared in a public extension
434 |
435 |     /// The `Behaviour` of the rule
436 |     public var behaviour : Behaviour {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
437 |         return Behaviour(kind, cardinality: cardinality, negated: isNegated, lookahead: isLookahead)
438 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:463:5: warning: 'public' modifier is redundant for instance method declared in a public extension
461 |      - Returns: `true` if the identifier could be referenced before the scan head has moved
462 |     */
463 |     public func directlyReferences(_ identifier:String, grammar:STLR.Grammar)->Bool{
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
464 |         var closedList = [String]()
465 |         return directlyReferences(identifier, grammar: grammar, closedList: &closedList)
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:620:5: warning: 'internal' modifier is redundant for property declared in an internal extension
618 | internal extension Array where Element == STLR.Annotation {
619 |     /// The annotations on the element with any that would be captured in `Behaviour` removed (@token, @transient, @void)
620 |     internal var unfilteredRuleAnnotationsForTesting : RuleAnnotations {
    |     `- warning: 'internal' modifier is redundant for property declared in an internal extension
621 |         var ruleAnnotations = [RuleAnnotation : RuleAnnotationValue]()
622 |         for annotation in self {
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:641:5: warning: 'public' modifier is redundant for property declared in a public extension
639 |
640 |     /// The annotations on the element with any that would be captured in `Behaviour` removed (@token, @transient, @void)
641 |     public var ruleAnnotations : RuleAnnotations {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
642 |         var ruleAnnotations = [RuleAnnotation : RuleAnnotationValue]()
643 |         for annotation in filter({!$0.label.isBehavioural}){
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:650:5: warning: 'public' modifier is redundant for property declared in a public extension
648 |
649 |     /// The token if any specified in the annotations
650 |     public var token : String? {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
651 |         guard let tokenAnnotationValue = self[RuleAnnotation.token] else {
652 |             return nil
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:665:5: warning: 'public' modifier is redundant for property declared in a public extension
663 |
664 |     /// `true` if the annotations include @void
665 |     public var void : Bool {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
666 |         return self[RuleAnnotation.void] != nil
667 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:670:5: warning: 'public' modifier is redundant for property declared in a public extension
668 |
669 |     /// `true` if the annotations include @transient
670 |     public var transient : Bool {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
671 |         return self[RuleAnnotation.transient] != nil
672 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:673:5: warning: 'public' modifier is redundant for property declared in a public extension
671 |         return self[RuleAnnotation.transient] != nil
672 |     }
673 |     public var type : String? {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
674 |         if let typeAnnotationValue = self[RuleAnnotation.type] {
675 |             if case let RuleAnnotationValue.string(value) =  typeAnnotationValue {
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:46:22: warning: Should be defined as standard type in STLR.stlr
 44 |             self = .definedLabel(definedLabel: STLR.DefinedLabel.transient)
 45 |         case .pinned:
 46 |             #warning("Should be defined as standard type in STLR.stlr")
    |                      `- warning: Should be defined as standard type in STLR.stlr
 47 |             self = .customLabel(customLabel: "pin")
 48 |         case .type:
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:49:22: warning: Should be defined as standard type in STLR.stlr
 47 |             self = .customLabel(customLabel: "pin")
 48 |         case .type:
 49 |             #warning("Should be defined as standard type in STLR.stlr")
    |                      `- warning: Should be defined as standard type in STLR.stlr
 50 |             self = .customLabel(customLabel: "type")
 51 |         case .custom(let label):
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:410:26: warning: Possible bug? should it be returning the kid of the identifier?
408 |         } else {
409 |             if let identifier = identifier {
410 |                 #warning("Possible bug? should it be returning the kid of the identifier?")
    |                          `- warning: Possible bug? should it be returning the kid of the identifier?
411 |                 return .structural(token:StringToken(identifier))
412 |             }
/host/spi-builder-workspace/Sources/OysterKit/Rules/Cadinality.swift:60:23: warning: static property 'one' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
25 | /// Represents the cardinality of a rule. It can be specified as a closed range,
26 | /// including those with no upper bound (`PartialRangeFrom`)
27 | public struct Cardinality : Equatable {
   |               `- note: consider making struct 'Cardinality' conform to the 'Sendable' protocol
28 |     /// The minimum number of matches, must be >= 0
29 |     public let minimumMatches : Int
   :
58 |
59 |     /// A pre-specified constant for one and exactly one matches
60 |     public static let one = Cardinality(1...1)
   |                       |- warning: static property 'one' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'one' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
61 |
62 |     /// A pre-specified constant for optional matches (between 0 and 1 matches)
/host/spi-builder-workspace/Sources/OysterKit/Rules/Cadinality.swift:63:23: warning: static property 'zeroOrOne' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
25 | /// Represents the cardinality of a rule. It can be specified as a closed range,
26 | /// including those with no upper bound (`PartialRangeFrom`)
27 | public struct Cardinality : Equatable {
   |               `- note: consider making struct 'Cardinality' conform to the 'Sendable' protocol
28 |     /// The minimum number of matches, must be >= 0
29 |     public let minimumMatches : Int
   :
61 |
62 |     /// A pre-specified constant for optional matches (between 0 and 1 matches)
63 |     public static let zeroOrOne = Cardinality(0...1)
   |                       |- warning: static property 'zeroOrOne' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'zeroOrOne' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
64 |
65 |     /// A pre-specified constant for optional but unbound matches (between 0 and infinity matches)
/host/spi-builder-workspace/Sources/OysterKit/Rules/Cadinality.swift:66:23: warning: static property 'zeroOrMore' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
25 | /// Represents the cardinality of a rule. It can be specified as a closed range,
26 | /// including those with no upper bound (`PartialRangeFrom`)
27 | public struct Cardinality : Equatable {
   |               `- note: consider making struct 'Cardinality' conform to the 'Sendable' protocol
28 |     /// The minimum number of matches, must be >= 0
29 |     public let minimumMatches : Int
   :
64 |
65 |     /// A pre-specified constant for optional but unbound matches (between 0 and infinity matches)
66 |     public static let zeroOrMore = Cardinality(0...)
   |                       |- warning: static property 'zeroOrMore' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'zeroOrMore' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
67 |
68 |     /// A pre-specified constant for required but unbound matches (between 1 and infinity matches)
/host/spi-builder-workspace/Sources/OysterKit/Rules/Cadinality.swift:69:23: warning: static property 'oneOrMore' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
25 | /// Represents the cardinality of a rule. It can be specified as a closed range,
26 | /// including those with no upper bound (`PartialRangeFrom`)
27 | public struct Cardinality : Equatable {
   |               `- note: consider making struct 'Cardinality' conform to the 'Sendable' protocol
28 |     /// The minimum number of matches, must be >= 0
29 |     public let minimumMatches : Int
   :
67 |
68 |     /// A pre-specified constant for required but unbound matches (between 1 and infinity matches)
69 |     public static let oneOrMore = Cardinality(1...)
   |                       |- warning: static property 'oneOrMore' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'oneOrMore' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
70 |
71 |     /// The equality function
/host/spi-builder-workspace/Sources/STLR/Generated/STLR.swift:8:24: warning: static property 'regularExpressionCache' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
  6 |     typealias T = STLRTokens
  7 |     // Cache for compiled regular expressions
  8 |     private static var regularExpressionCache = [String : NSRegularExpression]()
    |                        |- warning: static property 'regularExpressionCache' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
    |                        |- note: convert 'regularExpressionCache' to a 'let' constant to make 'Sendable' shared state immutable
    |                        |- note: annotate 'regularExpressionCache' with '@MainActor' if property should only be accessed from the main actor
    |                        `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
  9 |
 10 |     /// Returns a pre-compiled pattern from the cache, or if not in the cache builds
/host/spi-builder-workspace/Sources/STLR/Generated/STLR.swift:301:24: warning: static property 'leftHandRecursiveRules' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
299 |
300 |     /// Cache for left-hand recursive rules
301 |     private static var leftHandRecursiveRules = [ Int : Rule ]()
    |                        |- warning: static property 'leftHandRecursiveRules' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
    |                        |- note: convert 'leftHandRecursiveRules' to a 'let' constant to make 'Sendable' shared state immutable
    |                        |- note: annotate 'leftHandRecursiveRules' with '@MainActor' if property should only be accessed from the main actor
    |                        `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
302 |
303 |     /// Create a language that can be used for parsing etc
[80/89] Compiling STLR SymbolTable.swift
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:149:5: warning: 'public' modifier is redundant for instance method declared in a public extension
147 |     }
148 |
149 |     public func defined(identifier:String)->Bool{
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
150 |         for rule in rules {
151 |             if rule.identifier == identifier {
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:209:5: warning: 'public' modifier is redundant for property declared in a public extension
207 |
208 |     /// All rules, including those defined inline
209 |     public var allRules : STLR.Rules {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
210 |         var all = STLR.Rules()
211 |         all.append(contentsOf: rules)
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:216:5: warning: 'public' modifier is redundant for subscript declared in a public extension
214 |     }
215 |
216 |     public subscript(_ identifier:String)->STLR.Rule{
    |     `- warning: 'public' modifier is redundant for subscript declared in a public extension
217 |         for rule in rules {
218 |             if rule.identifier == identifier {
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:242:5: warning: 'public' modifier is redundant for instance method declared in a public extension
240 |     }
241 |
242 |     public func isLeftHandRecursive(identifier:String)->Bool{
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
243 |         var closedList = [String]()
244 |         return self[identifier].expression.references(identifier, grammar: self, closedList: &closedList)
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:247:5: warning: 'public' modifier is redundant for instance method declared in a public extension
245 |     }
246 |
247 |     public func isDirectLeftHandRecursive(identifier:String)->Bool{
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
248 |         var closedList = [String]()
249 |         return self[identifier].expression.directlyReferences(identifier, grammar: self, closedList: &closedList)
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:252:5: warning: 'public' modifier is redundant for instance method declared in a public extension
250 |     }
251 |
252 |     public func isRoot(identifier:String)->Bool{
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
253 |         var closedList = [String]()
254 |         for rule in rules {
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:262:5: warning: 'public' modifier is redundant for instance method declared in a public extension
260 |     }
261 |
262 |     public func validate(rule:STLR.Rule) throws {
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
263 |         if isDirectLeftHandRecursive(identifier: rule.identifier){
264 |             throw ProcessingError.interpretation(message: "\(rule.identifier) is directly left hand recursive (references itself without moving scan head forward)", causes: [])
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:272:5: warning: 'public' modifier is redundant for property declared in a public extension
270 | public extension STLR.Rule {
271 |     /// True if the rule is skipping
272 |     public var isVoid : Bool {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
273 |         return void != nil || (annotations?.void ?? false)
274 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:277:5: warning: 'public' modifier is redundant for property declared in a public extension
275 |
276 |     /// True if it is a scanning rule
277 |     public var isTransient : Bool {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
278 |         return transient != nil || (annotations?.transient ?? false)
279 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:281:5: warning: 'public' modifier is redundant for property declared in a public extension
279 |     }
280 |
281 |     public var type : String? {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
282 |         return annotations?.type
283 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:288:5: warning: 'public' modifier is redundant for property declared in a public extension
286 | public extension STLR.Quantifier {
287 |     /// The minimum number of matches required to satisfy the quantifier
288 |     public var minimumMatches : Int {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
289 |         switch self {
290 |         case .star, .questionMark:
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:300:5: warning: 'public' modifier is redundant for property declared in a public extension
298 |
299 |     /// The maximum number of matches required to satisfy the quantifier
300 |     public var maximumMatches : Int? {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
301 |         switch self {
302 |         case .questionMark:
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:338:5: warning: 'public' modifier is redundant for instance method declared in a public extension
336 |     }
337 |
338 |     public func directlyReferences(_ identifier:String, grammar:STLR.Grammar, closedList:inout [String])->Bool {
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
339 |         for element in elements {
340 |             if element.directlyReferences(identifier, grammar: grammar, closedList: &closedList){
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:353:5: warning: 'public' modifier is redundant for instance method declared in a public extension
351 |
352 |
353 |     public func references(_ identifier:String, grammar:STLR.Grammar, closedList: inout [String])->Bool {
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
354 |         for element in elements {
355 |             if element.references(identifier, grammar: grammar, closedList: &closedList){
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:366:5: warning: 'public' modifier is redundant for property declared in a public extension
364 |
365 |     /// The annotations defined as `RuleAnnotations`
366 |     public var ruleAnnotations : RuleAnnotations {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
367 |         return annotations?.ruleAnnotations ?? [:]
368 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:371:5: warning: 'public' modifier is redundant for property declared in a public extension
369 |
370 |     /// True if the element is skipping
371 |     public var isVoid : Bool {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
372 |         return void != nil || (annotations?.void ?? false)
373 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:376:5: warning: 'public' modifier is redundant for property declared in a public extension
374 |
375 |     /// True if it is a scanning element
376 |     public var isTransient : Bool {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
377 |         return transient != nil || (annotations?.transient ?? false)
378 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:381:5: warning: 'public' modifier is redundant for property declared in a public extension
379 |
380 |     /// True if the element is lookahead
381 |     public var isLookahead : Bool {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
382 |         return lookahead != nil
383 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:386:5: warning: 'public' modifier is redundant for property declared in a public extension
384 |
385 |     /// True if the element is negated
386 |     public var isNegated : Bool {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
387 |         return negated != nil
388 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:391:5: warning: 'public' modifier is redundant for property declared in a public extension
389 |
390 |     /// Returns the token name (if any) of the element
391 |     public var token : TokenType? {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
392 |         if case let Behaviour.Kind.structural(token) = kind {
393 |             return token
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:400:5: warning: 'public' modifier is redundant for property declared in a public extension
398 |
399 |     /// The `Kind` of the rule
400 |     public var kind : Behaviour.Kind {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
401 |         if isVoid {
402 |             return .skipping
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:418:5: warning: 'public' modifier is redundant for property declared in a public extension
416 |
417 |     /// The `Cardinality` of the match
418 |     public var cardinality : Cardinality {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
419 |         guard let quantifier = quantifier else {
420 |             return .one
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:436:5: warning: 'public' modifier is redundant for property declared in a public extension
434 |
435 |     /// The `Behaviour` of the rule
436 |     public var behaviour : Behaviour {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
437 |         return Behaviour(kind, cardinality: cardinality, negated: isNegated, lookahead: isLookahead)
438 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:463:5: warning: 'public' modifier is redundant for instance method declared in a public extension
461 |      - Returns: `true` if the identifier could be referenced before the scan head has moved
462 |     */
463 |     public func directlyReferences(_ identifier:String, grammar:STLR.Grammar)->Bool{
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
464 |         var closedList = [String]()
465 |         return directlyReferences(identifier, grammar: grammar, closedList: &closedList)
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:620:5: warning: 'internal' modifier is redundant for property declared in an internal extension
618 | internal extension Array where Element == STLR.Annotation {
619 |     /// The annotations on the element with any that would be captured in `Behaviour` removed (@token, @transient, @void)
620 |     internal var unfilteredRuleAnnotationsForTesting : RuleAnnotations {
    |     `- warning: 'internal' modifier is redundant for property declared in an internal extension
621 |         var ruleAnnotations = [RuleAnnotation : RuleAnnotationValue]()
622 |         for annotation in self {
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:641:5: warning: 'public' modifier is redundant for property declared in a public extension
639 |
640 |     /// The annotations on the element with any that would be captured in `Behaviour` removed (@token, @transient, @void)
641 |     public var ruleAnnotations : RuleAnnotations {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
642 |         var ruleAnnotations = [RuleAnnotation : RuleAnnotationValue]()
643 |         for annotation in filter({!$0.label.isBehavioural}){
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:650:5: warning: 'public' modifier is redundant for property declared in a public extension
648 |
649 |     /// The token if any specified in the annotations
650 |     public var token : String? {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
651 |         guard let tokenAnnotationValue = self[RuleAnnotation.token] else {
652 |             return nil
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:665:5: warning: 'public' modifier is redundant for property declared in a public extension
663 |
664 |     /// `true` if the annotations include @void
665 |     public var void : Bool {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
666 |         return self[RuleAnnotation.void] != nil
667 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:670:5: warning: 'public' modifier is redundant for property declared in a public extension
668 |
669 |     /// `true` if the annotations include @transient
670 |     public var transient : Bool {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
671 |         return self[RuleAnnotation.transient] != nil
672 |     }
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:673:5: warning: 'public' modifier is redundant for property declared in a public extension
671 |         return self[RuleAnnotation.transient] != nil
672 |     }
673 |     public var type : String? {
    |     `- warning: 'public' modifier is redundant for property declared in a public extension
674 |         if let typeAnnotationValue = self[RuleAnnotation.type] {
675 |             if case let RuleAnnotationValue.string(value) =  typeAnnotationValue {
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:46:22: warning: Should be defined as standard type in STLR.stlr
 44 |             self = .definedLabel(definedLabel: STLR.DefinedLabel.transient)
 45 |         case .pinned:
 46 |             #warning("Should be defined as standard type in STLR.stlr")
    |                      `- warning: Should be defined as standard type in STLR.stlr
 47 |             self = .customLabel(customLabel: "pin")
 48 |         case .type:
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:49:22: warning: Should be defined as standard type in STLR.stlr
 47 |             self = .customLabel(customLabel: "pin")
 48 |         case .type:
 49 |             #warning("Should be defined as standard type in STLR.stlr")
    |                      `- warning: Should be defined as standard type in STLR.stlr
 50 |             self = .customLabel(customLabel: "type")
 51 |         case .custom(let label):
/host/spi-builder-workspace/Sources/STLR/Generated/Extensions/STLR+Extensions.swift:410:26: warning: Possible bug? should it be returning the kid of the identifier?
408 |         } else {
409 |             if let identifier = identifier {
410 |                 #warning("Possible bug? should it be returning the kid of the identifier?")
    |                          `- warning: Possible bug? should it be returning the kid of the identifier?
411 |                 return .structural(token:StringToken(identifier))
412 |             }
/host/spi-builder-workspace/Sources/OysterKit/Rules/Cadinality.swift:60:23: warning: static property 'one' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
25 | /// Represents the cardinality of a rule. It can be specified as a closed range,
26 | /// including those with no upper bound (`PartialRangeFrom`)
27 | public struct Cardinality : Equatable {
   |               `- note: consider making struct 'Cardinality' conform to the 'Sendable' protocol
28 |     /// The minimum number of matches, must be >= 0
29 |     public let minimumMatches : Int
   :
58 |
59 |     /// A pre-specified constant for one and exactly one matches
60 |     public static let one = Cardinality(1...1)
   |                       |- warning: static property 'one' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'one' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
61 |
62 |     /// A pre-specified constant for optional matches (between 0 and 1 matches)
/host/spi-builder-workspace/Sources/OysterKit/Rules/Cadinality.swift:63:23: warning: static property 'zeroOrOne' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
25 | /// Represents the cardinality of a rule. It can be specified as a closed range,
26 | /// including those with no upper bound (`PartialRangeFrom`)
27 | public struct Cardinality : Equatable {
   |               `- note: consider making struct 'Cardinality' conform to the 'Sendable' protocol
28 |     /// The minimum number of matches, must be >= 0
29 |     public let minimumMatches : Int
   :
61 |
62 |     /// A pre-specified constant for optional matches (between 0 and 1 matches)
63 |     public static let zeroOrOne = Cardinality(0...1)
   |                       |- warning: static property 'zeroOrOne' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'zeroOrOne' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
64 |
65 |     /// A pre-specified constant for optional but unbound matches (between 0 and infinity matches)
/host/spi-builder-workspace/Sources/OysterKit/Rules/Cadinality.swift:66:23: warning: static property 'zeroOrMore' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
25 | /// Represents the cardinality of a rule. It can be specified as a closed range,
26 | /// including those with no upper bound (`PartialRangeFrom`)
27 | public struct Cardinality : Equatable {
   |               `- note: consider making struct 'Cardinality' conform to the 'Sendable' protocol
28 |     /// The minimum number of matches, must be >= 0
29 |     public let minimumMatches : Int
   :
64 |
65 |     /// A pre-specified constant for optional but unbound matches (between 0 and infinity matches)
66 |     public static let zeroOrMore = Cardinality(0...)
   |                       |- warning: static property 'zeroOrMore' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'zeroOrMore' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
67 |
68 |     /// A pre-specified constant for required but unbound matches (between 1 and infinity matches)
/host/spi-builder-workspace/Sources/OysterKit/Rules/Cadinality.swift:69:23: warning: static property 'oneOrMore' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
25 | /// Represents the cardinality of a rule. It can be specified as a closed range,
26 | /// including those with no upper bound (`PartialRangeFrom`)
27 | public struct Cardinality : Equatable {
   |               `- note: consider making struct 'Cardinality' conform to the 'Sendable' protocol
28 |     /// The minimum number of matches, must be >= 0
29 |     public let minimumMatches : Int
   :
67 |
68 |     /// A pre-specified constant for required but unbound matches (between 1 and infinity matches)
69 |     public static let oneOrMore = Cardinality(1...)
   |                       |- warning: static property 'oneOrMore' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'oneOrMore' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
70 |
71 |     /// The equality function
/host/spi-builder-workspace/Sources/STLR/Generated/STLR.swift:8:24: warning: static property 'regularExpressionCache' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
  6 |     typealias T = STLRTokens
  7 |     // Cache for compiled regular expressions
  8 |     private static var regularExpressionCache = [String : NSRegularExpression]()
    |                        |- warning: static property 'regularExpressionCache' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
    |                        |- note: convert 'regularExpressionCache' to a 'let' constant to make 'Sendable' shared state immutable
    |                        |- note: annotate 'regularExpressionCache' with '@MainActor' if property should only be accessed from the main actor
    |                        `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
  9 |
 10 |     /// Returns a pre-compiled pattern from the cache, or if not in the cache builds
/host/spi-builder-workspace/Sources/STLR/Generated/STLR.swift:301:24: warning: static property 'leftHandRecursiveRules' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
299 |
300 |     /// Cache for left-hand recursive rules
301 |     private static var leftHandRecursiveRules = [ Int : Rule ]()
    |                        |- warning: static property 'leftHandRecursiveRules' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
    |                        |- note: convert 'leftHandRecursiveRules' to a 'let' constant to make 'Sendable' shared state immutable
    |                        |- note: annotate 'leftHandRecursiveRules' with '@MainActor' if property should only be accessed from the main actor
    |                        `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
302 |
303 |     /// Create a language that can be used for parsing etc
[81/90] Wrapping AST for STLR for debugging
[82/90] Write Objects.LinkFileList
[83/90] Archiving libSTLR.a
[85/118] Compiling ExampleLanguages SwiftLanguage.swift
/host/spi-builder-workspace/Sources/OysterKit/Rules/Cadinality.swift:69:23: warning: static property 'oneOrMore' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
25 | /// Represents the cardinality of a rule. It can be specified as a closed range,
26 | /// including those with no upper bound (`PartialRangeFrom`)
27 | public struct Cardinality : Equatable {
   |               `- note: consider making struct 'Cardinality' conform to the 'Sendable' protocol
28 |     /// The minimum number of matches, must be >= 0
29 |     public let minimumMatches : Int
   :
67 |
68 |     /// A pre-specified constant for required but unbound matches (between 1 and infinity matches)
69 |     public static let oneOrMore = Cardinality(1...)
   |                       |- warning: static property 'oneOrMore' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'oneOrMore' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
70 |
71 |     /// The equality function
/host/spi-builder-workspace/Sources/OysterKit/Rules/Cadinality.swift:63:23: warning: static property 'zeroOrOne' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
25 | /// Represents the cardinality of a rule. It can be specified as a closed range,
26 | /// including those with no upper bound (`PartialRangeFrom`)
27 | public struct Cardinality : Equatable {
   |               `- note: consider making struct 'Cardinality' conform to the 'Sendable' protocol
28 |     /// The minimum number of matches, must be >= 0
29 |     public let minimumMatches : Int
   :
61 |
62 |     /// A pre-specified constant for optional matches (between 0 and 1 matches)
63 |     public static let zeroOrOne = Cardinality(0...1)
   |                       |- warning: static property 'zeroOrOne' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'zeroOrOne' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
64 |
65 |     /// A pre-specified constant for optional but unbound matches (between 0 and infinity matches)
/host/spi-builder-workspace/Sources/OysterKit/Rules/Cadinality.swift:60:23: warning: static property 'one' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
25 | /// Represents the cardinality of a rule. It can be specified as a closed range,
26 | /// including those with no upper bound (`PartialRangeFrom`)
27 | public struct Cardinality : Equatable {
   |               `- note: consider making struct 'Cardinality' conform to the 'Sendable' protocol
28 |     /// The minimum number of matches, must be >= 0
29 |     public let minimumMatches : Int
   :
58 |
59 |     /// A pre-specified constant for one and exactly one matches
60 |     public static let one = Cardinality(1...1)
   |                       |- warning: static property 'one' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'one' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
61 |
62 |     /// A pre-specified constant for optional matches (between 0 and 1 matches)
/host/spi-builder-workspace/Sources/OysterKit/Rules/Cadinality.swift:66:23: warning: static property 'zeroOrMore' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
25 | /// Represents the cardinality of a rule. It can be specified as a closed range,
26 | /// including those with no upper bound (`PartialRangeFrom`)
27 | public struct Cardinality : Equatable {
   |               `- note: consider making struct 'Cardinality' conform to the 'Sendable' protocol
28 |     /// The minimum number of matches, must be >= 0
29 |     public let minimumMatches : Int
   :
64 |
65 |     /// A pre-specified constant for optional but unbound matches (between 0 and infinity matches)
66 |     public static let zeroOrMore = Cardinality(0...)
   |                       |- warning: static property 'zeroOrMore' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'zeroOrMore' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
67 |
68 |     /// A pre-specified constant for required but unbound matches (between 1 and infinity matches)
[86/118] Compiling ExampleLanguages UtilityClasses.swift
[87/118] Emitting module stlrc
/host/spi-builder-workspace/Sources/stlrc/Commands/Parse.swift:28:20: warning: static property 'all' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
 26 |         }
 27 |
 28 |         static var all: [Parameter] = [ inputFile.parameter ]
    |                    |- warning: static property 'all' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
    |                    |- note: convert 'all' to a 'let' constant to make 'Sendable' shared state immutable
    |                    |- note: annotate 'all' with '@MainActor' if property should only be accessed from the main actor
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 29 |     }
 30 |
/host/spi-builder-workspace/Sources/stlrc/Framework/Argument.swift:37:14: warning: associated value 'insufficientParameters(requiredOccurence:)' of 'Sendable'-conforming enum 'Errors' has non-sendable type 'Cardinality'; this is an error in the Swift 6 language mode
35 |         case noCommandProvided
36 |         case parametersNotFound
37 |         case insufficientParameters(requiredOccurence: Cardinality)
   |              `- warning: associated value 'insufficientParameters(requiredOccurence:)' of 'Sendable'-conforming enum 'Errors' has non-sendable type 'Cardinality'; this is an error in the Swift 6 language mode
38 |         case invalidParameterType
39 |         case tooManyParameters
/host/spi-builder-workspace/Sources/stlrc/Framework/Protocols/Parameters.swift:14:13: note: consider making enum 'Cardinality' conform to the 'Sendable' protocol
 12 |  Defines the number of times a parameter of a particular type can appear.
 13 |  */
 14 | public enum Cardinality {
    |             `- note: consider making enum 'Cardinality' conform to the 'Sendable' protocol
 15 |     case one(optional:Bool)
 16 |     case range(Range<Int>)
/host/spi-builder-workspace/Sources/stlrc/Framework/Extensions/ArrayExtensions.swift:19:5: warning: 'public' modifier is redundant for subscript declared in a public extension
 17 |
 18 | public extension Array where Element == Option {
 19 |     public subscript(optionNamed name:String)->Option?{
    |     `- warning: 'public' modifier is redundant for subscript declared in a public extension
 20 |         for option in self {
 21 |             if option.longForm == name {
/host/spi-builder-workspace/Sources/stlrc/Framework/Extensions/FileManager+stlr.swift:11:5: warning: 'public' modifier is redundant for instance method declared in a public extension
 9 |
10 | public extension FileManager{
11 |     public func isDirectory(_ url:URL)->Bool{
   |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
12 |         var isDirectory : ObjCBool = false
13 |
/host/spi-builder-workspace/Sources/stlrc/Framework/Option.swift:15:5: warning: 'public' modifier is redundant for subscript declared in a public extension
 13 |
 14 | public extension Optioned {
 15 |     public subscript<O:Option>(optionCalled longForm:String)->O?{
    |     `- warning: 'public' modifier is redundant for subscript declared in a public extension
 16 |         for option in options {
 17 |             if option.longForm == longForm {
/host/spi-builder-workspace/Sources/stlrc/Framework/Option.swift:113:5: warning: 'internal' modifier is redundant for instance method declared in an internal extension
111 |
112 | internal extension String {
113 |     internal func substring(_ range:CountableRange<Int>)->Substring{
    |     `- warning: 'internal' modifier is redundant for instance method declared in an internal extension
114 |         let first = index(startIndex, offsetBy: range.startIndex)
115 |         let last = index(first, offsetBy: range.upperBound-range.lowerBound)
/host/spi-builder-workspace/Sources/stlrc/Framework/Protocols/Parameters.swift:66:5: warning: 'public' modifier is redundant for instance method declared in a public extension
 64 |     }
 65 |
 66 |     public func between(_ min:Int, and max:Int)->Parameter{
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
 67 |         return parameter(withCardinality: Cardinality.range(min..<max))
 68 |     }
/host/spi-builder-workspace/Sources/stlrc/Framework/Protocols/Parameters.swift:70:5: warning: 'public' modifier is redundant for instance method declared in a public extension
 68 |     }
 69 |
 70 |     public func multiple(optional:Bool)->Parameter{
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
 71 |         return parameter(withCardinality: Cardinality.multiple(optional: optional))
 72 |     }
/host/spi-builder-workspace/Sources/stlrc/Framework/Protocols/Parameters.swift:73:5: warning: 'public' modifier is redundant for instance method declared in a public extension
 71 |         return parameter(withCardinality: Cardinality.multiple(optional: optional))
 72 |     }
 73 |     public func one(optional:Bool)->Parameter{
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
 74 |         return parameter(withCardinality: Cardinality.one(optional: optional))
 75 |     }
/host/spi-builder-workspace/Sources/stlrc/Options/GrammarOption.swift:49:20: warning: static property 'all' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
47 |         }
48 |
49 |         static var all: [Parameter] = [Parameters.inputGrammarFile.parameter]
   |                    |- warning: static property 'all' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
   |                    |- note: convert 'all' to a 'let' constant to make 'Sendable' shared state immutable
   |                    |- note: annotate 'all' with '@MainActor' if property should only be accessed from the main actor
   |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
50 |
51 |     }
/host/spi-builder-workspace/Sources/OysterKit/Errors/ProcessingErrorType.swift:81:23: warning: static property 'parsing' is not concurrency-safe because non-'Sendable' type 'ProcessingErrorType' may have shared mutable state; this is an error in the Swift 6 language mode
26 |
27 | /// Represents the type of processing error.
28 | public struct ProcessingErrorType : OptionSet {
   |               `- note: consider making struct 'ProcessingErrorType' conform to the 'Sendable' protocol
29 |     public let rawValue: Int
30 |
   :
79 |
80 |     /// A parsing `ProcessingError`
81 |     public static let parsing           = ProcessingErrorType(rawValue:1 << 4)
   |                       |- warning: static property 'parsing' is not concurrency-safe because non-'Sendable' type 'ProcessingErrorType' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'parsing' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
82 |
83 |     /// An interpretation `ProcessingError`
/host/spi-builder-workspace/Sources/stlrc/String+STLR.swift:11:5: warning: 'public' modifier is redundant for property declared in a public extension
 9 |
10 | public extension String {
11 |     public var canonicalPath : String {
   |     `- warning: 'public' modifier is redundant for property declared in a public extension
12 |
13 |         return NSString(string:"\(hasPrefix(".") || hasPrefix("/") || hasPrefix("~") ? "" : "./")\(self)").expandingTildeInPath + (hasSuffix("/") ? "/" : "")
[88/121] Compiling stlrc Tool.swift
[89/121] Compiling stlrc Version.swift
[90/121] Compiling stlrc Operations.swift
[91/121] Compiling stlrc Parameters.swift
/host/spi-builder-workspace/Sources/stlrc/Framework/Protocols/Parameters.swift:66:5: warning: 'public' modifier is redundant for instance method declared in a public extension
 64 |     }
 65 |
 66 |     public func between(_ min:Int, and max:Int)->Parameter{
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
 67 |         return parameter(withCardinality: Cardinality.range(min..<max))
 68 |     }
/host/spi-builder-workspace/Sources/stlrc/Framework/Protocols/Parameters.swift:70:5: warning: 'public' modifier is redundant for instance method declared in a public extension
 68 |     }
 69 |
 70 |     public func multiple(optional:Bool)->Parameter{
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
 71 |         return parameter(withCardinality: Cardinality.multiple(optional: optional))
 72 |     }
/host/spi-builder-workspace/Sources/stlrc/Framework/Protocols/Parameters.swift:73:5: warning: 'public' modifier is redundant for instance method declared in a public extension
 71 |         return parameter(withCardinality: Cardinality.multiple(optional: optional))
 72 |     }
 73 |     public func one(optional:Bool)->Parameter{
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
 74 |         return parameter(withCardinality: Cardinality.one(optional: optional))
 75 |     }
[92/121] Compiling stlrc Runnable.swift
/host/spi-builder-workspace/Sources/stlrc/Framework/Protocols/Parameters.swift:66:5: warning: 'public' modifier is redundant for instance method declared in a public extension
 64 |     }
 65 |
 66 |     public func between(_ min:Int, and max:Int)->Parameter{
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
 67 |         return parameter(withCardinality: Cardinality.range(min..<max))
 68 |     }
/host/spi-builder-workspace/Sources/stlrc/Framework/Protocols/Parameters.swift:70:5: warning: 'public' modifier is redundant for instance method declared in a public extension
 68 |     }
 69 |
 70 |     public func multiple(optional:Bool)->Parameter{
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
 71 |         return parameter(withCardinality: Cardinality.multiple(optional: optional))
 72 |     }
/host/spi-builder-workspace/Sources/stlrc/Framework/Protocols/Parameters.swift:73:5: warning: 'public' modifier is redundant for instance method declared in a public extension
 71 |         return parameter(withCardinality: Cardinality.multiple(optional: optional))
 72 |     }
 73 |     public func one(optional:Bool)->Parameter{
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
 74 |         return parameter(withCardinality: Cardinality.one(optional: optional))
 75 |     }
[93/121] Compiling stlrc Reporting.swift
/host/spi-builder-workspace/Sources/stlrc/Framework/Protocols/Parameters.swift:66:5: warning: 'public' modifier is redundant for instance method declared in a public extension
 64 |     }
 65 |
 66 |     public func between(_ min:Int, and max:Int)->Parameter{
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
 67 |         return parameter(withCardinality: Cardinality.range(min..<max))
 68 |     }
/host/spi-builder-workspace/Sources/stlrc/Framework/Protocols/Parameters.swift:70:5: warning: 'public' modifier is redundant for instance method declared in a public extension
 68 |     }
 69 |
 70 |     public func multiple(optional:Bool)->Parameter{
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
 71 |         return parameter(withCardinality: Cardinality.multiple(optional: optional))
 72 |     }
/host/spi-builder-workspace/Sources/stlrc/Framework/Protocols/Parameters.swift:73:5: warning: 'public' modifier is redundant for instance method declared in a public extension
 71 |         return parameter(withCardinality: Cardinality.multiple(optional: optional))
 72 |     }
 73 |     public func one(optional:Bool)->Parameter{
    |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
 74 |         return parameter(withCardinality: Cardinality.one(optional: optional))
 75 |     }
[94/121] Compiling stlrc OutputLocationOption.swift
/host/spi-builder-workspace/Sources/stlrc/String+STLR.swift:11:5: warning: 'public' modifier is redundant for property declared in a public extension
 9 |
10 | public extension String {
11 |     public var canonicalPath : String {
   |     `- warning: 'public' modifier is redundant for property declared in a public extension
12 |
13 |         return NSString(string:"\(hasPrefix(".") || hasPrefix("/") || hasPrefix("~") ? "" : "./")\(self)").expandingTildeInPath + (hasSuffix("/") ? "/" : "")
[95/121] Compiling stlrc String+STLR.swift
/host/spi-builder-workspace/Sources/stlrc/String+STLR.swift:11:5: warning: 'public' modifier is redundant for property declared in a public extension
 9 |
10 | public extension String {
11 |     public var canonicalPath : String {
   |     `- warning: 'public' modifier is redundant for property declared in a public extension
12 |
13 |         return NSString(string:"\(hasPrefix(".") || hasPrefix("/") || hasPrefix("~") ? "" : "./")\(self)").expandingTildeInPath + (hasSuffix("/") ? "/" : "")
[96/121] Compiling stlrc main.swift
/host/spi-builder-workspace/Sources/stlrc/String+STLR.swift:11:5: warning: 'public' modifier is redundant for property declared in a public extension
 9 |
10 | public extension String {
11 |     public var canonicalPath : String {
   |     `- warning: 'public' modifier is redundant for property declared in a public extension
12 |
13 |         return NSString(string:"\(hasPrefix(".") || hasPrefix("/") || hasPrefix("~") ? "" : "./")\(self)").expandingTildeInPath + (hasSuffix("/") ? "/" : "")
[97/121] Compiling stlrc GrammarOption.swift
/host/spi-builder-workspace/Sources/stlrc/Options/GrammarOption.swift:49:20: warning: static property 'all' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
47 |         }
48 |
49 |         static var all: [Parameter] = [Parameters.inputGrammarFile.parameter]
   |                    |- warning: static property 'all' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
   |                    |- note: convert 'all' to a 'let' constant to make 'Sendable' shared state immutable
   |                    |- note: annotate 'all' with '@MainActor' if property should only be accessed from the main actor
   |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
50 |
51 |     }
/host/spi-builder-workspace/Sources/OysterKit/Errors/ProcessingErrorType.swift:81:23: warning: static property 'parsing' is not concurrency-safe because non-'Sendable' type 'ProcessingErrorType' may have shared mutable state; this is an error in the Swift 6 language mode
26 |
27 | /// Represents the type of processing error.
28 | public struct ProcessingErrorType : OptionSet {
   |               `- note: consider making struct 'ProcessingErrorType' conform to the 'Sendable' protocol
29 |     public let rawValue: Int
30 |
   :
79 |
80 |     /// A parsing `ProcessingError`
81 |     public static let parsing           = ProcessingErrorType(rawValue:1 << 4)
   |                       |- warning: static property 'parsing' is not concurrency-safe because non-'Sendable' type 'ProcessingErrorType' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'parsing' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
82 |
83 |     /// An interpretation `ProcessingError`
[98/121] Compiling stlrc LanguageOption.swift
/host/spi-builder-workspace/Sources/stlrc/Options/GrammarOption.swift:49:20: warning: static property 'all' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
47 |         }
48 |
49 |         static var all: [Parameter] = [Parameters.inputGrammarFile.parameter]
   |                    |- warning: static property 'all' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
   |                    |- note: convert 'all' to a 'let' constant to make 'Sendable' shared state immutable
   |                    |- note: annotate 'all' with '@MainActor' if property should only be accessed from the main actor
   |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
50 |
51 |     }
/host/spi-builder-workspace/Sources/OysterKit/Errors/ProcessingErrorType.swift:81:23: warning: static property 'parsing' is not concurrency-safe because non-'Sendable' type 'ProcessingErrorType' may have shared mutable state; this is an error in the Swift 6 language mode
26 |
27 | /// Represents the type of processing error.
28 | public struct ProcessingErrorType : OptionSet {
   |               `- note: consider making struct 'ProcessingErrorType' conform to the 'Sendable' protocol
29 |     public let rawValue: Int
30 |
   :
79 |
80 |     /// A parsing `ProcessingError`
81 |     public static let parsing           = ProcessingErrorType(rawValue:1 << 4)
   |                       |- warning: static property 'parsing' is not concurrency-safe because non-'Sendable' type 'ProcessingErrorType' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'parsing' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
82 |
83 |     /// An interpretation `ProcessingError`
[99/121] Compiling stlrc OptimizeOption.swift
/host/spi-builder-workspace/Sources/stlrc/Options/GrammarOption.swift:49:20: warning: static property 'all' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
47 |         }
48 |
49 |         static var all: [Parameter] = [Parameters.inputGrammarFile.parameter]
   |                    |- warning: static property 'all' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
   |                    |- note: convert 'all' to a 'let' constant to make 'Sendable' shared state immutable
   |                    |- note: annotate 'all' with '@MainActor' if property should only be accessed from the main actor
   |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
50 |
51 |     }
/host/spi-builder-workspace/Sources/OysterKit/Errors/ProcessingErrorType.swift:81:23: warning: static property 'parsing' is not concurrency-safe because non-'Sendable' type 'ProcessingErrorType' may have shared mutable state; this is an error in the Swift 6 language mode
26 |
27 | /// Represents the type of processing error.
28 | public struct ProcessingErrorType : OptionSet {
   |               `- note: consider making struct 'ProcessingErrorType' conform to the 'Sendable' protocol
29 |     public let rawValue: Int
30 |
   :
79 |
80 |     /// A parsing `ProcessingError`
81 |     public static let parsing           = ProcessingErrorType(rawValue:1 << 4)
   |                       |- warning: static property 'parsing' is not concurrency-safe because non-'Sendable' type 'ProcessingErrorType' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'parsing' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
82 |
83 |     /// An interpretation `ProcessingError`
[100/121] Compiling stlrc DictionaryExtensions.swift
/host/spi-builder-workspace/Sources/stlrc/Framework/Extensions/FileManager+stlr.swift:11:5: warning: 'public' modifier is redundant for instance method declared in a public extension
 9 |
10 | public extension FileManager{
11 |     public func isDirectory(_ url:URL)->Bool{
   |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
12 |         var isDirectory : ObjCBool = false
13 |
[101/121] Compiling stlrc FileManager+stlr.swift
/host/spi-builder-workspace/Sources/stlrc/Framework/Extensions/FileManager+stlr.swift:11:5: warning: 'public' modifier is redundant for instance method declared in a public extension
 9 |
10 | public extension FileManager{
11 |     public func isDirectory(_ url:URL)->Bool{
   |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
12 |         var isDirectory : ObjCBool = false
13 |
[102/121] Compiling stlrc STLRScope.swift
/host/spi-builder-workspace/Sources/stlrc/Framework/Extensions/FileManager+stlr.swift:11:5: warning: 'public' modifier is redundant for instance method declared in a public extension
 9 |
10 | public extension FileManager{
11 |     public func isDirectory(_ url:URL)->Bool{
   |     `- warning: 'public' modifier is redundant for instance method declared in a public extension
12 |         var isDirectory : ObjCBool = false
13 |
[103/121] Compiling stlrc ANSIEncoding.swift
/host/spi-builder-workspace/Sources/stlrc/Framework/Argument.swift:37:14: warning: associated value 'insufficientParameters(requiredOccurence:)' of 'Sendable'-conforming enum 'Errors' has non-sendable type 'Cardinality'; this is an error in the Swift 6 language mode
35 |         case noCommandProvided
36 |         case parametersNotFound
37 |         case insufficientParameters(requiredOccurence: Cardinality)
   |              `- warning: associated value 'insufficientParameters(requiredOccurence:)' of 'Sendable'-conforming enum 'Errors' has non-sendable type 'Cardinality'; this is an error in the Swift 6 language mode
38 |         case invalidParameterType
39 |         case tooManyParameters
/host/spi-builder-workspace/Sources/stlrc/Framework/Protocols/Parameters.swift:14:13: note: consider making enum 'Cardinality' conform to the 'Sendable' protocol
 12 |  Defines the number of times a parameter of a particular type can appear.
 13 |  */
 14 | public enum Cardinality {
    |             `- note: consider making enum 'Cardinality' conform to the 'Sendable' protocol
 15 |     case one(optional:Bool)
 16 |     case range(Range<Int>)
/host/spi-builder-workspace/Sources/stlrc/Framework/Extensions/ArrayExtensions.swift:19:5: warning: 'public' modifier is redundant for subscript declared in a public extension
 17 |
 18 | public extension Array where Element == Option {
 19 |     public subscript(optionNamed name:String)->Option?{
    |     `- warning: 'public' modifier is redundant for subscript declared in a public extension
 20 |         for option in self {
 21 |             if option.longForm == name {
[104/121] Compiling stlrc Argument.swift
/host/spi-builder-workspace/Sources/stlrc/Framework/Argument.swift:37:14: warning: associated value 'insufficientParameters(requiredOccurence:)' of 'Sendable'-conforming enum 'Errors' has non-sendable type 'Cardinality'; this is an error in the Swift 6 language mode
35 |         case noCommandProvided
36 |         case parametersNotFound
37 |         case insufficientParameters(requiredOccurence: Cardinality)
   |              `- warning: associated value 'insufficientParameters(requiredOccurence:)' of 'Sendable'-conforming enum 'Errors' has non-sendable type 'Cardinality'; this is an error in the Swift 6 language mode
38 |         case invalidParameterType
39 |         case tooManyParameters
/host/spi-builder-workspace/Sources/stlrc/Framework/Protocols/Parameters.swift:14:13: note: consider making enum 'Cardinality' conform to the 'Sendable' protocol
 12 |  Defines the number of times a parameter of a particular type can appear.
 13 |  */
 14 | public enum Cardinality {
    |             `- note: consider making enum 'Cardinality' conform to the 'Sendable' protocol
 15 |     case one(optional:Bool)
 16 |     case range(Range<Int>)
/host/spi-builder-workspace/Sources/stlrc/Framework/Extensions/ArrayExtensions.swift:19:5: warning: 'public' modifier is redundant for subscript declared in a public extension
 17 |
 18 | public extension Array where Element == Option {
 19 |     public subscript(optionNamed name:String)->Option?{
    |     `- warning: 'public' modifier is redundant for subscript declared in a public extension
 20 |         for option in self {
 21 |             if option.longForm == name {
[105/121] Compiling stlrc ArrayExtensions.swift
/host/spi-builder-workspace/Sources/stlrc/Framework/Argument.swift:37:14: warning: associated value 'insufficientParameters(requiredOccurence:)' of 'Sendable'-conforming enum 'Errors' has non-sendable type 'Cardinality'; this is an error in the Swift 6 language mode
35 |         case noCommandProvided
36 |         case parametersNotFound
37 |         case insufficientParameters(requiredOccurence: Cardinality)
   |              `- warning: associated value 'insufficientParameters(requiredOccurence:)' of 'Sendable'-conforming enum 'Errors' has non-sendable type 'Cardinality'; this is an error in the Swift 6 language mode
38 |         case invalidParameterType
39 |         case tooManyParameters
/host/spi-builder-workspace/Sources/stlrc/Framework/Protocols/Parameters.swift:14:13: note: consider making enum 'Cardinality' conform to the 'Sendable' protocol
 12 |  Defines the number of times a parameter of a particular type can appear.
 13 |  */
 14 | public enum Cardinality {
    |             `- note: consider making enum 'Cardinality' conform to the 'Sendable' protocol
 15 |     case one(optional:Bool)
 16 |     case range(Range<Int>)
/host/spi-builder-workspace/Sources/stlrc/Framework/Extensions/ArrayExtensions.swift:19:5: warning: 'public' modifier is redundant for subscript declared in a public extension
 17 |
 18 | public extension Array where Element == Option {
 19 |     public subscript(optionNamed name:String)->Option?{
    |     `- warning: 'public' modifier is redundant for subscript declared in a public extension
 20 |         for option in self {
 21 |             if option.longForm == name {
[106/121] Compiling stlrc StringExtensions.swift
/host/spi-builder-workspace/Sources/stlrc/Framework/Option.swift:15:5: warning: 'public' modifier is redundant for subscript declared in a public extension
 13 |
 14 | public extension Optioned {
 15 |     public subscript<O:Option>(optionCalled longForm:String)->O?{
    |     `- warning: 'public' modifier is redundant for subscript declared in a public extension
 16 |         for option in options {
 17 |             if option.longForm == longForm {
/host/spi-builder-workspace/Sources/stlrc/Framework/Option.swift:113:5: warning: 'internal' modifier is redundant for instance method declared in an internal extension
111 |
112 | internal extension String {
113 |     internal func substring(_ range:CountableRange<Int>)->Substring{
    |     `- warning: 'internal' modifier is redundant for instance method declared in an internal extension
114 |         let first = index(startIndex, offsetBy: range.startIndex)
115 |         let last = index(first, offsetBy: range.upperBound-range.lowerBound)
[107/121] Compiling stlrc Option.swift
/host/spi-builder-workspace/Sources/stlrc/Framework/Option.swift:15:5: warning: 'public' modifier is redundant for subscript declared in a public extension
 13 |
 14 | public extension Optioned {
 15 |     public subscript<O:Option>(optionCalled longForm:String)->O?{
    |     `- warning: 'public' modifier is redundant for subscript declared in a public extension
 16 |         for option in options {
 17 |             if option.longForm == longForm {
/host/spi-builder-workspace/Sources/stlrc/Framework/Option.swift:113:5: warning: 'internal' modifier is redundant for instance method declared in an internal extension
111 |
112 | internal extension String {
113 |     internal func substring(_ range:CountableRange<Int>)->Substring{
    |     `- warning: 'internal' modifier is redundant for instance method declared in an internal extension
114 |         let first = index(startIndex, offsetBy: range.startIndex)
115 |         let last = index(first, offsetBy: range.upperBound-range.lowerBound)
[108/121] Compiling stlrc Command.swift
/host/spi-builder-workspace/Sources/stlrc/Framework/Option.swift:15:5: warning: 'public' modifier is redundant for subscript declared in a public extension
 13 |
 14 | public extension Optioned {
 15 |     public subscript<O:Option>(optionCalled longForm:String)->O?{
    |     `- warning: 'public' modifier is redundant for subscript declared in a public extension
 16 |         for option in options {
 17 |             if option.longForm == longForm {
/host/spi-builder-workspace/Sources/stlrc/Framework/Option.swift:113:5: warning: 'internal' modifier is redundant for instance method declared in an internal extension
111 |
112 | internal extension String {
113 |     internal func substring(_ range:CountableRange<Int>)->Substring{
    |     `- warning: 'internal' modifier is redundant for instance method declared in an internal extension
114 |         let first = index(startIndex, offsetBy: range.startIndex)
115 |         let last = index(first, offsetBy: range.upperBound-range.lowerBound)
[109/121] Compiling stlrc Generate.swift
/host/spi-builder-workspace/Sources/stlrc/Commands/Install.swift:79:14: warning: 'launchPath' is deprecated: renamed to 'executableURL'
 77 |     {
 78 |         let task = Process()
 79 |         task.launchPath = launchPath
    |              |- warning: 'launchPath' is deprecated: renamed to 'executableURL'
    |              `- note: use 'executableURL' instead
 80 |         task.arguments = arguments
 81 |
/host/spi-builder-workspace/Sources/stlrc/Commands/Install.swift:84:14: warning: 'launch()' is deprecated: renamed to 'run'
 82 |         let pipe = Pipe()
 83 |         task.standardOutput = pipe
 84 |         task.launch()
    |              |- warning: 'launch()' is deprecated: renamed to 'run'
    |              `- note: use 'run' instead
 85 |
 86 |         let data = pipe.fileHandleForReading.readDataToEndOfFile()
/host/spi-builder-workspace/Sources/stlrc/Commands/Parse.swift:28:20: warning: static property 'all' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
 26 |         }
 27 |
 28 |         static var all: [Parameter] = [ inputFile.parameter ]
    |                    |- warning: static property 'all' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
    |                    |- note: convert 'all' to a 'let' constant to make 'Sendable' shared state immutable
    |                    |- note: annotate 'all' with '@MainActor' if property should only be accessed from the main actor
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 29 |     }
 30 |
[110/121] Compiling stlrc Install.swift
/host/spi-builder-workspace/Sources/stlrc/Commands/Install.swift:79:14: warning: 'launchPath' is deprecated: renamed to 'executableURL'
 77 |     {
 78 |         let task = Process()
 79 |         task.launchPath = launchPath
    |              |- warning: 'launchPath' is deprecated: renamed to 'executableURL'
    |              `- note: use 'executableURL' instead
 80 |         task.arguments = arguments
 81 |
/host/spi-builder-workspace/Sources/stlrc/Commands/Install.swift:84:14: warning: 'launch()' is deprecated: renamed to 'run'
 82 |         let pipe = Pipe()
 83 |         task.standardOutput = pipe
 84 |         task.launch()
    |              |- warning: 'launch()' is deprecated: renamed to 'run'
    |              `- note: use 'run' instead
 85 |
 86 |         let data = pipe.fileHandleForReading.readDataToEndOfFile()
/host/spi-builder-workspace/Sources/stlrc/Commands/Parse.swift:28:20: warning: static property 'all' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
 26 |         }
 27 |
 28 |         static var all: [Parameter] = [ inputFile.parameter ]
    |                    |- warning: static property 'all' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
    |                    |- note: convert 'all' to a 'let' constant to make 'Sendable' shared state immutable
    |                    |- note: annotate 'all' with '@MainActor' if property should only be accessed from the main actor
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 29 |     }
 30 |
[111/121] Compiling stlrc Parse.swift
/host/spi-builder-workspace/Sources/stlrc/Commands/Install.swift:79:14: warning: 'launchPath' is deprecated: renamed to 'executableURL'
 77 |     {
 78 |         let task = Process()
 79 |         task.launchPath = launchPath
    |              |- warning: 'launchPath' is deprecated: renamed to 'executableURL'
    |              `- note: use 'executableURL' instead
 80 |         task.arguments = arguments
 81 |
/host/spi-builder-workspace/Sources/stlrc/Commands/Install.swift:84:14: warning: 'launch()' is deprecated: renamed to 'run'
 82 |         let pipe = Pipe()
 83 |         task.standardOutput = pipe
 84 |         task.launch()
    |              |- warning: 'launch()' is deprecated: renamed to 'run'
    |              `- note: use 'run' instead
 85 |
 86 |         let data = pipe.fileHandleForReading.readDataToEndOfFile()
/host/spi-builder-workspace/Sources/stlrc/Commands/Parse.swift:28:20: warning: static property 'all' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
 26 |         }
 27 |
 28 |         static var all: [Parameter] = [ inputFile.parameter ]
    |                    |- warning: static property 'all' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
    |                    |- note: convert 'all' to a 'let' constant to make 'Sendable' shared state immutable
    |                    |- note: annotate 'all' with '@MainActor' if property should only be accessed from the main actor
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 29 |     }
 30 |
[112/121] Compiling stlrc Profile.swift
/host/spi-builder-workspace/Sources/stlrc/Commands/Install.swift:79:14: warning: 'launchPath' is deprecated: renamed to 'executableURL'
 77 |     {
 78 |         let task = Process()
 79 |         task.launchPath = launchPath
    |              |- warning: 'launchPath' is deprecated: renamed to 'executableURL'
    |              `- note: use 'executableURL' instead
 80 |         task.arguments = arguments
 81 |
/host/spi-builder-workspace/Sources/stlrc/Commands/Install.swift:84:14: warning: 'launch()' is deprecated: renamed to 'run'
 82 |         let pipe = Pipe()
 83 |         task.standardOutput = pipe
 84 |         task.launch()
    |              |- warning: 'launch()' is deprecated: renamed to 'run'
    |              `- note: use 'run' instead
 85 |
 86 |         let data = pipe.fileHandleForReading.readDataToEndOfFile()
/host/spi-builder-workspace/Sources/stlrc/Commands/Parse.swift:28:20: warning: static property 'all' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
 26 |         }
 27 |
 28 |         static var all: [Parameter] = [ inputFile.parameter ]
    |                    |- warning: static property 'all' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
    |                    |- note: convert 'all' to a 'let' constant to make 'Sendable' shared state immutable
    |                    |- note: annotate 'all' with '@MainActor' if property should only be accessed from the main actor
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 29 |     }
 30 |
[113/122] Wrapping AST for stlrc for debugging
[114/122] Write Objects.LinkFileList
[115/122] Linking stlrc
[117/122] Emitting module ExampleLanguages
/host/spi-builder-workspace/Sources/ExampleLanguages/STLR.swift:8:24: warning: static property 'regularExpressionCache' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
  6 |     typealias T = STLRTokens
  7 |     // Cache for compiled regular expressions
  8 |     private static var regularExpressionCache = [String : NSRegularExpression]()
    |                        |- warning: static property 'regularExpressionCache' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
    |                        |- note: convert 'regularExpressionCache' to a 'let' constant to make 'Sendable' shared state immutable
    |                        |- note: annotate 'regularExpressionCache' with '@MainActor' if property should only be accessed from the main actor
    |                        `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
  9 |
 10 |     /// Returns a pre-compiled pattern from the cache, or if not in the cache builds
/host/spi-builder-workspace/Sources/ExampleLanguages/STLR.swift:301:24: warning: static property 'leftHandRecursiveRules' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
299 |
300 |     /// Cache for left-hand recursive rules
301 |     private static var leftHandRecursiveRules = [ Int : Rule ]()
    |                        |- warning: static property 'leftHandRecursiveRules' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
    |                        |- note: convert 'leftHandRecursiveRules' to a 'let' constant to make 'Sendable' shared state immutable
    |                        |- note: annotate 'leftHandRecursiveRules' with '@MainActor' if property should only be accessed from the main actor
    |                        `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
302 |
303 |     /// Create a language that can be used for parsing etc
[118/122] Compiling ExampleLanguages STLR Testing Extensions.swift
[119/122] Compiling ExampleLanguages STLR.swift
/host/spi-builder-workspace/Sources/ExampleLanguages/STLR.swift:8:24: warning: static property 'regularExpressionCache' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
  6 |     typealias T = STLRTokens
  7 |     // Cache for compiled regular expressions
  8 |     private static var regularExpressionCache = [String : NSRegularExpression]()
    |                        |- warning: static property 'regularExpressionCache' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
    |                        |- note: convert 'regularExpressionCache' to a 'let' constant to make 'Sendable' shared state immutable
    |                        |- note: annotate 'regularExpressionCache' with '@MainActor' if property should only be accessed from the main actor
    |                        `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
  9 |
 10 |     /// Returns a pre-compiled pattern from the cache, or if not in the cache builds
/host/spi-builder-workspace/Sources/ExampleLanguages/STLR.swift:301:24: warning: static property 'leftHandRecursiveRules' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
299 |
300 |     /// Cache for left-hand recursive rules
301 |     private static var leftHandRecursiveRules = [ Int : Rule ]()
    |                        |- warning: static property 'leftHandRecursiveRules' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in the Swift 6 language mode
    |                        |- note: convert 'leftHandRecursiveRules' to a 'let' constant to make 'Sendable' shared state immutable
    |                        |- note: annotate 'leftHandRecursiveRules' with '@MainActor' if property should only be accessed from the main actor
    |                        `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
302 |
303 |     /// Create a language that can be used for parsing etc
/host/spi-builder-workspace/Sources/OysterKit/Rules/Cadinality.swift:66:23: warning: static property 'zeroOrMore' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
25 | /// Represents the cardinality of a rule. It can be specified as a closed range,
26 | /// including those with no upper bound (`PartialRangeFrom`)
27 | public struct Cardinality : Equatable {
   |               `- note: consider making struct 'Cardinality' conform to the 'Sendable' protocol
28 |     /// The minimum number of matches, must be >= 0
29 |     public let minimumMatches : Int
   :
64 |
65 |     /// A pre-specified constant for optional but unbound matches (between 0 and infinity matches)
66 |     public static let zeroOrMore = Cardinality(0...)
   |                       |- warning: static property 'zeroOrMore' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'zeroOrMore' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
67 |
68 |     /// A pre-specified constant for required but unbound matches (between 1 and infinity matches)
/host/spi-builder-workspace/Sources/OysterKit/Rules/Cadinality.swift:63:23: warning: static property 'zeroOrOne' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
25 | /// Represents the cardinality of a rule. It can be specified as a closed range,
26 | /// including those with no upper bound (`PartialRangeFrom`)
27 | public struct Cardinality : Equatable {
   |               `- note: consider making struct 'Cardinality' conform to the 'Sendable' protocol
28 |     /// The minimum number of matches, must be >= 0
29 |     public let minimumMatches : Int
   :
61 |
62 |     /// A pre-specified constant for optional matches (between 0 and 1 matches)
63 |     public static let zeroOrOne = Cardinality(0...1)
   |                       |- warning: static property 'zeroOrOne' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'zeroOrOne' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
64 |
65 |     /// A pre-specified constant for optional but unbound matches (between 0 and infinity matches)
/host/spi-builder-workspace/Sources/OysterKit/Rules/Cadinality.swift:69:23: warning: static property 'oneOrMore' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
25 | /// Represents the cardinality of a rule. It can be specified as a closed range,
26 | /// including those with no upper bound (`PartialRangeFrom`)
27 | public struct Cardinality : Equatable {
   |               `- note: consider making struct 'Cardinality' conform to the 'Sendable' protocol
28 |     /// The minimum number of matches, must be >= 0
29 |     public let minimumMatches : Int
   :
67 |
68 |     /// A pre-specified constant for required but unbound matches (between 1 and infinity matches)
69 |     public static let oneOrMore = Cardinality(1...)
   |                       |- warning: static property 'oneOrMore' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'oneOrMore' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
70 |
71 |     /// The equality function
/host/spi-builder-workspace/Sources/OysterKit/Rules/Cadinality.swift:60:23: warning: static property 'one' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
25 | /// Represents the cardinality of a rule. It can be specified as a closed range,
26 | /// including those with no upper bound (`PartialRangeFrom`)
27 | public struct Cardinality : Equatable {
   |               `- note: consider making struct 'Cardinality' conform to the 'Sendable' protocol
28 |     /// The minimum number of matches, must be >= 0
29 |     public let minimumMatches : Int
   :
58 |
59 |     /// A pre-specified constant for one and exactly one matches
60 |     public static let one = Cardinality(1...1)
   |                       |- warning: static property 'one' is not concurrency-safe because non-'Sendable' type 'Cardinality' may have shared mutable state; this is an error in the Swift 6 language mode
   |                       |- note: annotate 'one' with '@MainActor' if property should only be accessed from the main actor
   |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
61 |
62 |     /// A pre-specified constant for optional matches (between 0 and 1 matches)
[120/123] Wrapping AST for ExampleLanguages for debugging
[121/123] Write Objects.LinkFileList
[122/123] Archiving libExampleLanguages.a
Build complete! (19.10s)
Build complete.
{
  "dependencies" : [
  ],
  "manifest_display_name" : "OysterKit",
  "name" : "OysterKit",
  "path" : "/host/spi-builder-workspace",
  "platforms" : [
  ],
  "products" : [
    {
      "name" : "OysterKit",
      "targets" : [
        "OysterKit"
      ],
      "type" : {
        "library" : [
          "static"
        ]
      }
    },
    {
      "name" : "STLR",
      "targets" : [
        "STLR"
      ],
      "type" : {
        "library" : [
          "static"
        ]
      }
    },
    {
      "name" : "ExampleLanguages",
      "targets" : [
        "ExampleLanguages"
      ],
      "type" : {
        "library" : [
          "static"
        ]
      }
    },
    {
      "name" : "stlrc",
      "targets" : [
        "stlrc"
      ],
      "type" : {
        "executable" : null
      }
    }
  ],
  "targets" : [
    {
      "c99name" : "stlrc",
      "module_type" : "SwiftTarget",
      "name" : "stlrc",
      "path" : "Sources/stlrc",
      "product_memberships" : [
        "stlrc"
      ],
      "sources" : [
        "Commands/Generate.swift",
        "Commands/Install.swift",
        "Commands/Parse.swift",
        "Commands/Profile.swift",
        "Framework/ANSIEncoding.swift",
        "Framework/Argument.swift",
        "Framework/Extensions/ArrayExtensions.swift",
        "Framework/Extensions/DictionaryExtensions.swift",
        "Framework/Extensions/FileManager+stlr.swift",
        "Framework/Extensions/STLRScope.swift",
        "Framework/Extensions/StringExtensions.swift",
        "Framework/Option.swift",
        "Framework/Protocols/Command.swift",
        "Framework/Protocols/Parameters.swift",
        "Framework/Protocols/Runnable.swift",
        "Framework/Reporting.swift",
        "Framework/Tool.swift",
        "Framework/Version.swift",
        "Operations.swift",
        "Options/GrammarOption.swift",
        "Options/LanguageOption.swift",
        "Options/OptimizeOption.swift",
        "Options/OutputLocationOption.swift",
        "String+STLR.swift",
        "main.swift"
      ],
      "target_dependencies" : [
        "OysterKit",
        "STLR"
      ],
      "type" : "executable"
    },
    {
      "c99name" : "STLRTests",
      "module_type" : "SwiftTarget",
      "name" : "STLRTests",
      "path" : "Tests/STLRTests",
      "sources" : [
        "AbstractSyntaxTree+Test.swift",
        "CompilerTest.swift",
        "DynamicGeneratorTest.swift",
        "FixValidations.swift",
        "FullSwiftGenerationTest.swift",
        "GrammarStructureTest.swift",
        "GrammarTest.swift",
        "HierarchyTests.swift",
        "Infrastructure.swift",
        "OptimizersTest.swift",
        "ParserTest.swift",
        "STLRTests.swift",
        "SwiftGenerationTest.swift"
      ],
      "target_dependencies" : [
        "OysterKit",
        "ExampleLanguages",
        "STLR"
      ],
      "type" : "test"
    },
    {
      "c99name" : "STLR",
      "module_type" : "SwiftTarget",
      "name" : "STLR",
      "path" : "Sources/STLR",
      "product_memberships" : [
        "STLR",
        "ExampleLanguages",
        "stlrc"
      ],
      "sources" : [
        "Extensions/String.swift",
        "Generated/Extensions/STLR+CustomStringConvertable.swift",
        "Generated/Extensions/STLR+DynamicRules.swift",
        "Generated/Extensions/STLR+Extensions.swift",
        "Generated/STLR.swift",
        "Generated/SymbolTable.swift",
        "Generators/Framework/Operations/Branching.swift",
        "Generators/Framework/Operations/Operation.swift",
        "Generators/Framework/Operations/System.swift",
        "Generators/Framework/TextFile.swift",
        "Generators/Generator.swift",
        "Generators/GrammarStructure+STLR.swift",
        "Generators/Swift/STLR+SwiftGrammar.swift",
        "Generators/Swift/String+Swift.swift",
        "Generators/Swift/SwiftPackageManager.swift",
        "Generators/Swift/SwiftRules.swift",
        "Generators/Swift/SwiftStructure.swift",
        "Optimisers/CharacterSetOnlyChoiceOptimizer.swift",
        "Optimisers/InlineIdentifierOptimizer.swift",
        "STLR Validation.swift",
        "STLR+Optimization.swift",
        "STLROptimizers.swift"
      ],
      "target_dependencies" : [
        "OysterKit"
      ],
      "type" : "library"
    },
    {
      "c99name" : "PerformanceTests",
      "module_type" : "SwiftTarget",
      "name" : "PerformanceTests",
      "path" : "Tests/PerformanceTests",
      "sources" : [
        "OysterKitPerformanceTests.swift"
      ],
      "target_dependencies" : [
        "OysterKit",
        "ExampleLanguages",
        "STLR"
      ],
      "type" : "test"
    },
    {
      "c99name" : "OysterKitTests",
      "module_type" : "SwiftTarget",
      "name" : "OysterKitTests",
      "path" : "Tests/OysterKitTests",
      "sources" : [
        "BlockRuleTest.swift",
        "DecoderTests.swift",
        "FixValidations.swift",
        "HomegenousASTTests.swift",
        "Infrastructure.swift",
        "LexerTest.swift",
        "Light Weight AST.swift",
        "NodeStackTests.swift",
        "OneOfEverythingGrammar.swift",
        "RuleAnnotationDescriptionTests.swift",
        "RuleAnnotationDescriptionsTests.swift",
        "RuleMatchRangeTest.swift",
        "RuleOperatorTests.swift",
        "RuleTests.swift",
        "ScannerTest.swift",
        "TerminalTests.swift",
        "TestAbstractSyntaxTree.swift",
        "TestErrors.swift"
      ],
      "target_dependencies" : [
        "OysterKit",
        "ExampleLanguages",
        "STLR"
      ],
      "type" : "test"
    },
    {
      "c99name" : "OysterKit",
      "module_type" : "SwiftTarget",
      "name" : "OysterKit",
      "path" : "Sources/OysterKit",
      "product_memberships" : [
        "OysterKit",
        "STLR",
        "ExampleLanguages",
        "stlrc"
      ],
      "sources" : [
        "Decoding/Extensions.swift",
        "Decoding/Parsing Decoder.swift",
        "Errors/Array+Error.swift",
        "Errors/CausalErrorType.swift",
        "Errors/ProcessingError.swift",
        "Errors/ProcessingErrorType.swift",
        "Lexical Analysis/Lexer.swift",
        "Lexical Analysis/LexicalAnalyzer.swift",
        "Lexical Analysis/Scanner.swift",
        "Logging/DecodingError+Logging.swift",
        "Logging/Log.swift",
        "Parser/Grammar.swift",
        "Parser/Intermediate Representations/Abstract Syntax Trees/AbstractSyntaxTree.swift",
        "Parser/Intermediate Representations/Abstract Syntax Trees/AbstractSyntaxTreeConstructor.swift",
        "Parser/Intermediate Representations/Abstract Syntax Trees/HomogenousTree.swift",
        "Parser/Intermediate Representations/IntermediateRepresentation.swift",
        "Parser/Intermediate Representations/LookAheadIR.swift",
        "Parser/Intermediate Representations/MatchResult.swift",
        "Parser/Intermediate Representations/NodeStack.swift",
        "Parser/Intermediate Representations/Nodes.swift",
        "Parser/Intermediate Representations/StateCache.swift",
        "Parser/Intermediate Representations/Streams/TokenStream.swift",
        "Parser/ParsingStrategy.swift",
        "Rules/Annotations/RuleAnnotation.swift",
        "Rules/Annotations/RuleAnnotationValue.swift",
        "Rules/Annotations/RuleAnnotations.swift",
        "Rules/Behaviour.swift",
        "Rules/Cadinality.swift",
        "Rules/Extensions/RuleAnnotations+Description.swift",
        "Rules/Implementations/ChoiceRule.swift",
        "Rules/Implementations/ClosureRule.swift",
        "Rules/Implementations/RecursiveRule.swift",
        "Rules/Implementations/RecursiveRuleInstance.swift",
        "Rules/Implementations/ReferenceRule.swift",
        "Rules/Implementations/SequenceRule.swift",
        "Rules/Implementations/TerminalRule.swift",
        "Rules/Rule Production/Terminal+Rule.swift",
        "Rules/Rule Production/Token+Rule.swift",
        "Rules/Rule+Extensions.swift",
        "Rules/Rule.swift",
        "Rules/Terminals/CharacterSet+Terminal.swift",
        "Rules/Terminals/EndOfFile.swift",
        "Rules/Terminals/NSRegularExpression+Terminal.swift",
        "Rules/Terminals/String+Terminal.swift",
        "Rules/Terminals/Terminal.swift",
        "Tokens/StringToken.swift",
        "Tokens/TokenType.swift"
      ],
      "type" : "library"
    },
    {
      "c99name" : "ExampleLanguages",
      "module_type" : "SwiftTarget",
      "name" : "ExampleLanguages",
      "path" : "Sources/ExampleLanguages",
      "product_memberships" : [
        "ExampleLanguages"
      ],
      "sources" : [
        "STLR Testing Extensions.swift",
        "STLR.swift",
        "SwiftLanguage.swift",
        "UtilityClasses.swift"
      ],
      "target_dependencies" : [
        "OysterKit",
        "STLR"
      ],
      "type" : "library"
    }
  ],
  "tools_version" : "4.0"
}
Done.
This is a staging environment. For live and up-to-date package information, visit swiftpackageindex.com.