Swift Package IndexBuild Information
Successful build of Parsel with Swift 6.0 for Linux.
Swift 6 data race errors: 33
Build Command
bash -c docker run --rm -v "checkouts-4609320-0":/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>&1Build Log
========================================
RunAll
========================================
Builder version: 4.40.0
Interrupt handler set up.
========================================
Checkout
========================================
Clone URL: https://github.com/BenchR267/Parsel.git
Reference: master
Initialized empty Git repository in /host/spi-builder-workspace/.git/
hint: Using 'master' as the name for the initial branch. This default branch name
hint: is subject to change. To configure the initial branch name to use in all
hint: of your new repositories, which will suppress this warning, call:
hint:
hint: git config --global init.defaultBranch <name>
hint:
hint: Names commonly chosen instead of 'master' are 'main', 'trunk' and
hint: 'development'. The just-created branch can be renamed via this command:
hint:
hint: git branch -m <name>
From https://github.com/BenchR267/Parsel
* branch master -> FETCH_HEAD
* [new branch] master -> origin/master
HEAD is now at 501db28 Release version 3.0.2
Cloned https://github.com/BenchR267/Parsel.git
Revision (git rev-parse @):
501db286265e62867b42851cce4a2fa914eac43f
SUCCESS checkout https://github.com/BenchR267/Parsel.git at master
========================================
Build
========================================
Selected platform: linux
Swift version: 6.0
Building package at path: $workDir
https://github.com/BenchR267/Parsel.git
Running build ...
bash -c docker run --rm -v "checkouts-4609320-0":/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
Building for debugging...
[0/2] Write sources
[1/2] Write swift-version-24593BA9C3E375BF.txt
[3/10] Compiling Parsel Lexical.swift
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:35:23: warning: static property 'char' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
33 |
34 | /// Parses one Character from a given String
35 | public static let char = Parser<String, Character> { input in
| |- warning: static property 'char' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'char' 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
36 | guard let first = input.first else {
37 | return .fail(Error.unexpectedToken(expected: "char", got: String(input.prefix(1))))
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:69:23: warning: static property 'asciiChar' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
67 |
68 | /// Parses one char that is part of the ascii table
69 | public static let asciiChar = char.filter { parsed in
| |- warning: static property 'asciiChar' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'asciiChar' 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 | guard parsed.unicodeScalars.first(where: { !$0.isASCII }) == nil else {
71 | return Error.unexpectedToken(expected: "ascii", got: String(parsed))
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:77:23: warning: static property 'asciiString' is not concurrency-safe because non-'Sendable' type 'Parser<String, String>' may have shared mutable state; this is an error in the Swift 6 language mode
75 |
76 | /// Parses a string that consists only of characters from the ascii range
77 | public static let asciiString = asciiChar.atLeastOne ^^ { String($0) }
| |- warning: static property 'asciiString' is not concurrency-safe because non-'Sendable' type 'Parser<String, String>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'asciiString' 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
78 |
79 | /// Parses a lowercase letter ('a'-'z')
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:80:23: warning: static property 'lowercaseLetter' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
78 |
79 | /// Parses a lowercase letter ('a'-'z')
80 | public static let lowercaseLetter = char.filter { parsed in
| |- warning: static property 'lowercaseLetter' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'lowercaseLetter' 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
81 | guard ("a"..."z").contains(parsed) else {
82 | return Error.unexpectedToken(expected: "lowercase", got: String(parsed))
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:88:23: warning: static property 'uppercaseLetter' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
86 |
87 | /// Parses an uppercase letter ('A'-'Z')
88 | public static let uppercaseLetter = char.filter { parsed in
| |- warning: static property 'uppercaseLetter' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'uppercaseLetter' 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
89 | guard ("A"..."Z").contains(parsed) else {
90 | return Error.unexpectedToken(expected: "uppercase", got: String(parsed))
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:96:23: warning: static property 'letter' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
94 |
95 | /// Parses a letter ('a'-'z' | 'A'-'Z')
96 | public static let letter = (lowercaseLetter | uppercaseLetter).mapError { err in
| |- warning: static property 'letter' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'letter' 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
97 | guard let lexicalErr = err as? Error else { return err }
98 | guard case let .unexpectedToken(_, got) = lexicalErr else {
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:128:23: warning: static property 'digit' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
126 |
127 | /// Parses a digit [0-9] from a given String
128 | public static let digit = Parser<String, Int> { input in
| |- warning: static property 'digit' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'digit' 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
129 | guard let first = input.first, let number = Int(String(first)) else {
130 | return .fail(Error.unexpectedToken(expected: "digit", got: String(input.prefix(1))))
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:136:23: warning: static property 'binaryDigit' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
134 |
135 | /// Parses a binary digit (0 or 1)
136 | public static let binaryDigit = digit.filter { parsed in
| |- warning: static property 'binaryDigit' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'binaryDigit' 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
137 | guard (0...1).contains(parsed) else {
138 | return Error.unexpectedToken(expected: "0 or 1", got: "\(parsed)")
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:144:23: warning: static property 'binaryNumber' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
142 |
143 | /// A parser for numbers of the format `0b10110110`
144 | public static let binaryNumber = (string("0b") ~> binaryDigit.atLeastOne) ^^ { digits in
| |- warning: static property 'binaryNumber' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'binaryNumber' 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
145 | return buildNumber(digits: digits, base: 2)
146 | }
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:149:23: warning: static property 'octalDigit' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
147 |
148 | /// Parses an octal digit (0 to 7)
149 | public static let octalDigit = digit.filter { parsed in
| |- warning: static property 'octalDigit' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'octalDigit' 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
150 | guard (0...7).contains(parsed) else {
151 | return Error.unexpectedToken(expected: "0 to 7", got: "\(parsed)")
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:157:23: warning: static property 'octalNumber' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
155 |
156 | /// A parser for numbers of the format `0o12372106`
157 | public static let octalNumber = (string("0o") ~> octalDigit.atLeastOne) ^^ { digits in
| |- warning: static property 'octalNumber' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'octalNumber' 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
158 | return buildNumber(digits: digits, base: 8)
159 | }
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:162:23: warning: static property 'hexadecimalDigit' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
160 |
161 | /// Parses a hexadecimal digit (0 to 15)
162 | public static let hexadecimalDigit = char.map { parsed -> Int in
| |- warning: static property 'hexadecimalDigit' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'hexadecimalDigit' 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
163 | let ascii = asciiValue(from: parsed)
164 | if ("a"..."f").contains(parsed) {
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:181:23: warning: static property 'hexadecimalNumber' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
179 |
180 | /// A parser for numbers of the format `0xdeadbeaf` or `0xDEADBEAF`
181 | public static let hexadecimalNumber = ((string("0x") | string("0X")) ~> hexadecimalDigit.atLeastOne) ^^ { digits in
| |- warning: static property 'hexadecimalNumber' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'hexadecimalNumber' 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
182 | return buildNumber(digits: digits, base: 16)
183 | }
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:186:23: warning: static property 'decimalNumber' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
184 |
185 | /// Parses a decimal number
186 | public static let decimalNumber = digit.atLeastOne ^^ { digits in
| |- warning: static property 'decimalNumber' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'decimalNumber' 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
187 | return buildNumber(digits: digits, base: 10)
188 | }
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:191:23: warning: static property 'unsignedNumber' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
189 |
190 | /// Parses an unsigned (positive) number in hexadecimal, octal, binary or decimal format
191 | public static let unsignedNumber = hexadecimalNumber | octalNumber | binaryNumber | decimalNumber
| |- warning: static property 'unsignedNumber' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'unsignedNumber' 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
192 |
193 | /// Parses a number in hexadecimal, octal, binary or decimal format
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:194:23: warning: static property 'number' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
192 |
193 | /// Parses a number in hexadecimal, octal, binary or decimal format
194 | public static let number = L.minus.optional ~ unsignedNumber ^^ { minus, number in minus == nil ? number : number * -1 }
| |- warning: static property 'number' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'number' 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
195 |
196 | /// Parses a floating number from String to Double (0.123; 0,123; …)
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:208:23: warning: static property 'minus' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
206 |
207 | /// Parses the `-` sign
208 | public static let minus = char("-")
| |- warning: static property 'minus' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'minus' 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
209 |
210 | /// Parses the `*` sign
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:197:23: warning: static property 'floatingNumber' is not concurrency-safe because non-'Sendable' type 'Parser<String, Double>' may have shared mutable state; this is an error in the Swift 6 language mode
195 |
196 | /// Parses a floating number from String to Double (0.123; 0,123; …)
197 | public static let floatingNumber = "[0-9]+([\\.,][0-9]+)?".r ^^ { input -> Double in
| |- warning: static property 'floatingNumber' is not concurrency-safe because non-'Sendable' type 'Parser<String, Double>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'floatingNumber' 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
198 | let cleaned = input.replacingOccurrences(of: ",", with: ".")
199 | return Double(cleaned) ?? 0.0
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:205:23: warning: static property 'plus' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
203 |
204 | /// Parses the `+` sign
205 | public static let plus = char("+")
| |- warning: static property 'plus' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'plus' 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
206 |
207 | /// Parses the `-` sign
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:211:23: warning: static property 'multiply' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
209 |
210 | /// Parses the `*` sign
211 | public static let multiply = char("*")
| |- warning: static property 'multiply' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'multiply' 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
212 |
213 | /// Parses the `/` sign
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:214:23: warning: static property 'divide' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
212 |
213 | /// Parses the `/` sign
214 | public static let divide = char("/")
| |- warning: static property 'divide' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'divide' 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
215 |
216 | /// Parses the `=` sign
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:217:23: warning: static property 'assign' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
215 |
216 | /// Parses the `=` sign
217 | public static let assign = char("=")
| |- warning: static property 'assign' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'assign' 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
218 |
219 | /// Parses the `==` sign
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:220:23: warning: static property 'equal' is not concurrency-safe because non-'Sendable' type 'Parser<String, String>' may have shared mutable state; this is an error in the Swift 6 language mode
218 |
219 | /// Parses the `==` sign
220 | public static let equal = (assign ~ assign) ^^ { String([$0, $1]) }
| |- warning: static property 'equal' is not concurrency-safe because non-'Sendable' type 'Parser<String, String>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'equal' 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
221 |
222 | // MARK: - Whitespaces
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:225:23: warning: static property 'space' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
223 |
224 | /// Parses one space character
225 | public static let space = char(" ")
| |- warning: static property 'space' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'space' 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
226 |
227 | /// Parses a new line `\n` character
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:228:23: warning: static property 'newLine' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
226 |
227 | /// Parses a new line `\n` character
228 | public static let newLine = char("\n")
| |- warning: static property 'newLine' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'newLine' 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
229 |
230 | /// Parses a new line `\n` character
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:231:23: warning: static property 'carriageReturn' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
229 |
230 | /// Parses a new line `\n` character
231 | public static let carriageReturn = char("\r\n")
| |- warning: static property 'carriageReturn' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'carriageReturn' 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
232 |
233 | /// Parses a tab `\t` character
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:234:23: warning: static property 'tab' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
232 |
233 | /// Parses a tab `\t` character
234 | public static let tab = char("\t")
| |- warning: static property 'tab' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'tab' 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
235 |
236 | /// Parses exactly one whitespace
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:237:23: warning: static property 'oneWhitespace' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
235 |
236 | /// Parses exactly one whitespace
237 | public static let oneWhitespace = space | newLine | carriageReturn | tab
| |- warning: static property 'oneWhitespace' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'oneWhitespace' 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
238 |
239 | /// Parses at least one whitespace
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:240:23: warning: static property 'whitespaces' is not concurrency-safe because non-'Sendable' type 'Parser<String, [Character]>' may have shared mutable state; this is an error in the Swift 6 language mode
238 |
239 | /// Parses at least one whitespace
240 | public static let whitespaces = oneWhitespace.atLeastOne
| |- warning: static property 'whitespaces' is not concurrency-safe because non-'Sendable' type 'Parser<String, [Character]>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'whitespaces' 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
241 |
242 | // MARK: - Helpers
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
[4/11] Compiling Parsel Parser.swift
[5/11] Compiling Parsel Parser+Conjunction.swift
[6/11] Compiling Parsel ParseResult.swift
[7/11] Compiling Parsel Errors.swift
[8/11] Compiling Parsel Operators+Sequential.swift
[9/11] Compiling Parsel Operators.swift
[10/11] Emitting module Parsel
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:35:23: warning: static property 'char' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
33 |
34 | /// Parses one Character from a given String
35 | public static let char = Parser<String, Character> { input in
| |- warning: static property 'char' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'char' 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
36 | guard let first = input.first else {
37 | return .fail(Error.unexpectedToken(expected: "char", got: String(input.prefix(1))))
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:69:23: warning: static property 'asciiChar' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
67 |
68 | /// Parses one char that is part of the ascii table
69 | public static let asciiChar = char.filter { parsed in
| |- warning: static property 'asciiChar' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'asciiChar' 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 | guard parsed.unicodeScalars.first(where: { !$0.isASCII }) == nil else {
71 | return Error.unexpectedToken(expected: "ascii", got: String(parsed))
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:77:23: warning: static property 'asciiString' is not concurrency-safe because non-'Sendable' type 'Parser<String, String>' may have shared mutable state; this is an error in the Swift 6 language mode
75 |
76 | /// Parses a string that consists only of characters from the ascii range
77 | public static let asciiString = asciiChar.atLeastOne ^^ { String($0) }
| |- warning: static property 'asciiString' is not concurrency-safe because non-'Sendable' type 'Parser<String, String>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'asciiString' 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
78 |
79 | /// Parses a lowercase letter ('a'-'z')
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:80:23: warning: static property 'lowercaseLetter' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
78 |
79 | /// Parses a lowercase letter ('a'-'z')
80 | public static let lowercaseLetter = char.filter { parsed in
| |- warning: static property 'lowercaseLetter' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'lowercaseLetter' 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
81 | guard ("a"..."z").contains(parsed) else {
82 | return Error.unexpectedToken(expected: "lowercase", got: String(parsed))
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:88:23: warning: static property 'uppercaseLetter' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
86 |
87 | /// Parses an uppercase letter ('A'-'Z')
88 | public static let uppercaseLetter = char.filter { parsed in
| |- warning: static property 'uppercaseLetter' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'uppercaseLetter' 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
89 | guard ("A"..."Z").contains(parsed) else {
90 | return Error.unexpectedToken(expected: "uppercase", got: String(parsed))
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:96:23: warning: static property 'letter' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
94 |
95 | /// Parses a letter ('a'-'z' | 'A'-'Z')
96 | public static let letter = (lowercaseLetter | uppercaseLetter).mapError { err in
| |- warning: static property 'letter' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'letter' 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
97 | guard let lexicalErr = err as? Error else { return err }
98 | guard case let .unexpectedToken(_, got) = lexicalErr else {
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:128:23: warning: static property 'digit' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
126 |
127 | /// Parses a digit [0-9] from a given String
128 | public static let digit = Parser<String, Int> { input in
| |- warning: static property 'digit' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'digit' 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
129 | guard let first = input.first, let number = Int(String(first)) else {
130 | return .fail(Error.unexpectedToken(expected: "digit", got: String(input.prefix(1))))
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:136:23: warning: static property 'binaryDigit' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
134 |
135 | /// Parses a binary digit (0 or 1)
136 | public static let binaryDigit = digit.filter { parsed in
| |- warning: static property 'binaryDigit' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'binaryDigit' 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
137 | guard (0...1).contains(parsed) else {
138 | return Error.unexpectedToken(expected: "0 or 1", got: "\(parsed)")
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:144:23: warning: static property 'binaryNumber' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
142 |
143 | /// A parser for numbers of the format `0b10110110`
144 | public static let binaryNumber = (string("0b") ~> binaryDigit.atLeastOne) ^^ { digits in
| |- warning: static property 'binaryNumber' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'binaryNumber' 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
145 | return buildNumber(digits: digits, base: 2)
146 | }
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:149:23: warning: static property 'octalDigit' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
147 |
148 | /// Parses an octal digit (0 to 7)
149 | public static let octalDigit = digit.filter { parsed in
| |- warning: static property 'octalDigit' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'octalDigit' 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
150 | guard (0...7).contains(parsed) else {
151 | return Error.unexpectedToken(expected: "0 to 7", got: "\(parsed)")
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:157:23: warning: static property 'octalNumber' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
155 |
156 | /// A parser for numbers of the format `0o12372106`
157 | public static let octalNumber = (string("0o") ~> octalDigit.atLeastOne) ^^ { digits in
| |- warning: static property 'octalNumber' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'octalNumber' 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
158 | return buildNumber(digits: digits, base: 8)
159 | }
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:162:23: warning: static property 'hexadecimalDigit' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
160 |
161 | /// Parses a hexadecimal digit (0 to 15)
162 | public static let hexadecimalDigit = char.map { parsed -> Int in
| |- warning: static property 'hexadecimalDigit' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'hexadecimalDigit' 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
163 | let ascii = asciiValue(from: parsed)
164 | if ("a"..."f").contains(parsed) {
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:181:23: warning: static property 'hexadecimalNumber' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
179 |
180 | /// A parser for numbers of the format `0xdeadbeaf` or `0xDEADBEAF`
181 | public static let hexadecimalNumber = ((string("0x") | string("0X")) ~> hexadecimalDigit.atLeastOne) ^^ { digits in
| |- warning: static property 'hexadecimalNumber' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'hexadecimalNumber' 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
182 | return buildNumber(digits: digits, base: 16)
183 | }
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:186:23: warning: static property 'decimalNumber' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
184 |
185 | /// Parses a decimal number
186 | public static let decimalNumber = digit.atLeastOne ^^ { digits in
| |- warning: static property 'decimalNumber' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'decimalNumber' 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
187 | return buildNumber(digits: digits, base: 10)
188 | }
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:191:23: warning: static property 'unsignedNumber' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
189 |
190 | /// Parses an unsigned (positive) number in hexadecimal, octal, binary or decimal format
191 | public static let unsignedNumber = hexadecimalNumber | octalNumber | binaryNumber | decimalNumber
| |- warning: static property 'unsignedNumber' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'unsignedNumber' 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
192 |
193 | /// Parses a number in hexadecimal, octal, binary or decimal format
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:194:23: warning: static property 'number' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
192 |
193 | /// Parses a number in hexadecimal, octal, binary or decimal format
194 | public static let number = L.minus.optional ~ unsignedNumber ^^ { minus, number in minus == nil ? number : number * -1 }
| |- warning: static property 'number' is not concurrency-safe because non-'Sendable' type 'Parser<String, Int>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'number' 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
195 |
196 | /// Parses a floating number from String to Double (0.123; 0,123; …)
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:208:23: warning: static property 'minus' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
206 |
207 | /// Parses the `-` sign
208 | public static let minus = char("-")
| |- warning: static property 'minus' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'minus' 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
209 |
210 | /// Parses the `*` sign
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:197:23: warning: static property 'floatingNumber' is not concurrency-safe because non-'Sendable' type 'Parser<String, Double>' may have shared mutable state; this is an error in the Swift 6 language mode
195 |
196 | /// Parses a floating number from String to Double (0.123; 0,123; …)
197 | public static let floatingNumber = "[0-9]+([\\.,][0-9]+)?".r ^^ { input -> Double in
| |- warning: static property 'floatingNumber' is not concurrency-safe because non-'Sendable' type 'Parser<String, Double>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'floatingNumber' 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
198 | let cleaned = input.replacingOccurrences(of: ",", with: ".")
199 | return Double(cleaned) ?? 0.0
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:205:23: warning: static property 'plus' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
203 |
204 | /// Parses the `+` sign
205 | public static let plus = char("+")
| |- warning: static property 'plus' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'plus' 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
206 |
207 | /// Parses the `-` sign
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:211:23: warning: static property 'multiply' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
209 |
210 | /// Parses the `*` sign
211 | public static let multiply = char("*")
| |- warning: static property 'multiply' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'multiply' 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
212 |
213 | /// Parses the `/` sign
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:214:23: warning: static property 'divide' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
212 |
213 | /// Parses the `/` sign
214 | public static let divide = char("/")
| |- warning: static property 'divide' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'divide' 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
215 |
216 | /// Parses the `=` sign
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:217:23: warning: static property 'assign' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
215 |
216 | /// Parses the `=` sign
217 | public static let assign = char("=")
| |- warning: static property 'assign' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'assign' 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
218 |
219 | /// Parses the `==` sign
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:220:23: warning: static property 'equal' is not concurrency-safe because non-'Sendable' type 'Parser<String, String>' may have shared mutable state; this is an error in the Swift 6 language mode
218 |
219 | /// Parses the `==` sign
220 | public static let equal = (assign ~ assign) ^^ { String([$0, $1]) }
| |- warning: static property 'equal' is not concurrency-safe because non-'Sendable' type 'Parser<String, String>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'equal' 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
221 |
222 | // MARK: - Whitespaces
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:225:23: warning: static property 'space' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
223 |
224 | /// Parses one space character
225 | public static let space = char(" ")
| |- warning: static property 'space' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'space' 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
226 |
227 | /// Parses a new line `\n` character
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:228:23: warning: static property 'newLine' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
226 |
227 | /// Parses a new line `\n` character
228 | public static let newLine = char("\n")
| |- warning: static property 'newLine' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'newLine' 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
229 |
230 | /// Parses a new line `\n` character
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:231:23: warning: static property 'carriageReturn' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
229 |
230 | /// Parses a new line `\n` character
231 | public static let carriageReturn = char("\r\n")
| |- warning: static property 'carriageReturn' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'carriageReturn' 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
232 |
233 | /// Parses a tab `\t` character
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:234:23: warning: static property 'tab' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
232 |
233 | /// Parses a tab `\t` character
234 | public static let tab = char("\t")
| |- warning: static property 'tab' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'tab' 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
235 |
236 | /// Parses exactly one whitespace
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:237:23: warning: static property 'oneWhitespace' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
235 |
236 | /// Parses exactly one whitespace
237 | public static let oneWhitespace = space | newLine | carriageReturn | tab
| |- warning: static property 'oneWhitespace' is not concurrency-safe because non-'Sendable' type 'Parser<String, Character>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'oneWhitespace' 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
238 |
239 | /// Parses at least one whitespace
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/Lexical.swift:240:23: warning: static property 'whitespaces' is not concurrency-safe because non-'Sendable' type 'Parser<String, [Character]>' may have shared mutable state; this is an error in the Swift 6 language mode
238 |
239 | /// Parses at least one whitespace
240 | public static let whitespaces = oneWhitespace.atLeastOne
| |- warning: static property 'whitespaces' is not concurrency-safe because non-'Sendable' type 'Parser<String, [Character]>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'whitespaces' 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
241 |
242 | // MARK: - Helpers
/host/spi-builder-workspace/Sources/Parsel/Core/Parser.swift:9:12: note: generic class 'Parser' does not conform to the 'Sendable' protocol
7 |
8 | /// A Parser parses sequences of T (Token) to one or multiple R (Result)
9 | open class Parser<T, R> where T: Sequence {
| `- note: generic class 'Parser' does not conform to the 'Sendable' protocol
10 |
11 | /// ParseFunction is the type of the wrapped function type
/host/spi-builder-workspace/Sources/Parsel/RegexParser.swift:58:23: warning: static property 'mail' is not concurrency-safe because non-'Sendable' type 'RegexParser' may have shared mutable state; this is an error in the Swift 6 language mode
13 |
14 | /// A parser that parses Strings with a given regular expression
15 | public final class RegexParser: Parser<String, String> {
| `- note: class 'RegexParser' does not conform to the 'Sendable' protocol
16 |
17 | /// Possible errors while using RegexParser
:
56 |
57 | /// Parses an e-mail-address
58 | public static let mail = """
| |- warning: static property 'mail' is not concurrency-safe because non-'Sendable' type 'RegexParser' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'mail' 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
59 | ([a-z0-9_\\.-]+)@([\\da-z\\.-]+)\\.([a-z\\.]{2,6})
60 | """.r
/host/spi-builder-workspace/Sources/Parsel/RegexParser.swift:64:23: warning: static property 'httpAddress' is not concurrency-safe because non-'Sendable' type 'RegexParser' may have shared mutable state; this is an error in the Swift 6 language mode
13 |
14 | /// A parser that parses Strings with a given regular expression
15 | public final class RegexParser: Parser<String, String> {
| `- note: class 'RegexParser' does not conform to the 'Sendable' protocol
16 |
17 | /// Possible errors while using RegexParser
:
62 | // swiftlint:disable line_length
63 | /// Parses an http(s) address
64 | public static let httpAddress = """
| |- warning: static property 'httpAddress' is not concurrency-safe because non-'Sendable' type 'RegexParser' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'httpAddress' 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
65 | ^(?i)(?:(?:https?|ftp):\\/\\/)?(?:\\S+(?::\\S*)?@)?(?:(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}(?:\\.(?:[1-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))|(?:(?:[a-z\\u00a1-\\uffff0-9]+-?)*[a-z\\u00a1-\\uffff0-9]+)(?:\\.(?:[a-z\\u00a1-\\uffff0-9]+-?)*[a-z\\u00a1-\\uffff0-9]+)*(?:\\.(?:[a-z\\u00a1-\\uffff]{2,})))(?::\\d{2,5})?(?:\\/[^\\s]*)?$
66 | """.r
/host/spi-builder-workspace/Sources/Parsel/RegexParser.swift:69:23: warning: static property 'ipAddress' is not concurrency-safe because non-'Sendable' type 'RegexParser' may have shared mutable state; this is an error in the Swift 6 language mode
13 |
14 | /// A parser that parses Strings with a given regular expression
15 | public final class RegexParser: Parser<String, String> {
| `- note: class 'RegexParser' does not conform to the 'Sendable' protocol
16 |
17 | /// Possible errors while using RegexParser
:
67 |
68 | /// Parses an IP address
69 | public static let ipAddress = """
| |- warning: static property 'ipAddress' is not concurrency-safe because non-'Sendable' type 'RegexParser' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'ipAddress' 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 | (?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)
71 | """.r
/host/spi-builder-workspace/Sources/Parsel/RegexParser.swift:74:23: warning: static property 'semver' is not concurrency-safe because non-'Sendable' type 'RegexParser' may have shared mutable state; this is an error in the Swift 6 language mode
13 |
14 | /// A parser that parses Strings with a given regular expression
15 | public final class RegexParser: Parser<String, String> {
| `- note: class 'RegexParser' does not conform to the 'Sendable' protocol
16 |
17 | /// Possible errors while using RegexParser
:
72 |
73 | /// Parses a semantic version number (1.0.0, 1.0, …) thanks to https://git.daplie.com/coolaj86/semver-utils
74 | public static let semver = """
| |- warning: static property 'semver' is not concurrency-safe because non-'Sendable' type 'RegexParser' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'semver' 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
75 | v?((\\d+)\\.(\\d+)\\.(\\d+))(?:-([\\dA-Za-z\\-]+(?:\\.[\\dA-Za-z\\-]+)*))?(?:\\+([\\dA-Za-z\\-]+(?:\\.[\\dA-Za-z\\-]+)*))?
76 | """.r
[11/11] Compiling Parsel RegexParser.swift
/host/spi-builder-workspace/Sources/Parsel/RegexParser.swift:58:23: warning: static property 'mail' is not concurrency-safe because non-'Sendable' type 'RegexParser' may have shared mutable state; this is an error in the Swift 6 language mode
13 |
14 | /// A parser that parses Strings with a given regular expression
15 | public final class RegexParser: Parser<String, String> {
| `- note: class 'RegexParser' does not conform to the 'Sendable' protocol
16 |
17 | /// Possible errors while using RegexParser
:
56 |
57 | /// Parses an e-mail-address
58 | public static let mail = """
| |- warning: static property 'mail' is not concurrency-safe because non-'Sendable' type 'RegexParser' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'mail' 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
59 | ([a-z0-9_\\.-]+)@([\\da-z\\.-]+)\\.([a-z\\.]{2,6})
60 | """.r
/host/spi-builder-workspace/Sources/Parsel/RegexParser.swift:64:23: warning: static property 'httpAddress' is not concurrency-safe because non-'Sendable' type 'RegexParser' may have shared mutable state; this is an error in the Swift 6 language mode
13 |
14 | /// A parser that parses Strings with a given regular expression
15 | public final class RegexParser: Parser<String, String> {
| `- note: class 'RegexParser' does not conform to the 'Sendable' protocol
16 |
17 | /// Possible errors while using RegexParser
:
62 | // swiftlint:disable line_length
63 | /// Parses an http(s) address
64 | public static let httpAddress = """
| |- warning: static property 'httpAddress' is not concurrency-safe because non-'Sendable' type 'RegexParser' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'httpAddress' 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
65 | ^(?i)(?:(?:https?|ftp):\\/\\/)?(?:\\S+(?::\\S*)?@)?(?:(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}(?:\\.(?:[1-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))|(?:(?:[a-z\\u00a1-\\uffff0-9]+-?)*[a-z\\u00a1-\\uffff0-9]+)(?:\\.(?:[a-z\\u00a1-\\uffff0-9]+-?)*[a-z\\u00a1-\\uffff0-9]+)*(?:\\.(?:[a-z\\u00a1-\\uffff]{2,})))(?::\\d{2,5})?(?:\\/[^\\s]*)?$
66 | """.r
/host/spi-builder-workspace/Sources/Parsel/RegexParser.swift:69:23: warning: static property 'ipAddress' is not concurrency-safe because non-'Sendable' type 'RegexParser' may have shared mutable state; this is an error in the Swift 6 language mode
13 |
14 | /// A parser that parses Strings with a given regular expression
15 | public final class RegexParser: Parser<String, String> {
| `- note: class 'RegexParser' does not conform to the 'Sendable' protocol
16 |
17 | /// Possible errors while using RegexParser
:
67 |
68 | /// Parses an IP address
69 | public static let ipAddress = """
| |- warning: static property 'ipAddress' is not concurrency-safe because non-'Sendable' type 'RegexParser' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'ipAddress' 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 | (?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)
71 | """.r
/host/spi-builder-workspace/Sources/Parsel/RegexParser.swift:74:23: warning: static property 'semver' is not concurrency-safe because non-'Sendable' type 'RegexParser' may have shared mutable state; this is an error in the Swift 6 language mode
13 |
14 | /// A parser that parses Strings with a given regular expression
15 | public final class RegexParser: Parser<String, String> {
| `- note: class 'RegexParser' does not conform to the 'Sendable' protocol
16 |
17 | /// Possible errors while using RegexParser
:
72 |
73 | /// Parses a semantic version number (1.0.0, 1.0, …) thanks to https://git.daplie.com/coolaj86/semver-utils
74 | public static let semver = """
| |- warning: static property 'semver' is not concurrency-safe because non-'Sendable' type 'RegexParser' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'semver' 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
75 | v?((\\d+)\\.(\\d+)\\.(\\d+))(?:-([\\dA-Za-z\\-]+(?:\\.[\\dA-Za-z\\-]+)*))?(?:\\+([\\dA-Za-z\\-]+(?:\\.[\\dA-Za-z\\-]+)*))?
76 | """.r
Build complete! (12.86s)
Build complete.
{
"dependencies" : [
],
"manifest_display_name" : "Parsel",
"name" : "Parsel",
"path" : "/host/spi-builder-workspace",
"platforms" : [
],
"products" : [
{
"name" : "Parsel",
"targets" : [
"Parsel"
],
"type" : {
"library" : [
"automatic"
]
}
}
],
"targets" : [
{
"c99name" : "ParselTests",
"module_type" : "SwiftTarget",
"name" : "ParselTests",
"path" : "Tests/ParselTests",
"sources" : [
"Errors_TestCase.swift",
"Helpers.swift",
"Lexical_TestCase.swift",
"Operators+Sequential_TestCase.swift",
"Operators_TestCase.swift",
"ParseResult_TestCase.swift",
"Parsel_TestCase.swift",
"Parser+Conjunction_TestCase.swift",
"Parser_TestCase.swift",
"RegexParser_TestCase.swift"
],
"target_dependencies" : [
"Parsel"
],
"type" : "test"
},
{
"c99name" : "Parsel",
"module_type" : "SwiftTarget",
"name" : "Parsel",
"path" : "Sources/Parsel",
"product_memberships" : [
"Parsel"
],
"sources" : [
"Core/Errors.swift",
"Core/Operators+Sequential.swift",
"Core/Operators.swift",
"Core/ParseResult.swift",
"Core/Parser+Conjunction.swift",
"Core/Parser.swift",
"Lexical.swift",
"RegexParser.swift"
],
"type" : "library"
}
],
"tools_version" : "4.0"
}
Done.