Enable Swift 6 mode, fix concurrency build errors (#202)

MaxDesiatov · web-flow · commit d9b56a7b3f97 · 2025-10-08T18:29:32.000+01:00
This mostly amounted to adding `Sendable` on existing value types, or avoiding use of reference types where not needed.
diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
@@ -142,7 +142,7 @@ jobs:
         run: |
           toolchain_path="/opt/swiftwasm"
           ./build-exec mkdir -p "$toolchain_path"
-          curl -v -L ${{ matrix.development-toolchain-download }} | ./build-exec tar xz --strip-component 1 -C "$toolchain_path"
+          curl -L ${{ matrix.development-toolchain-download }} | ./build-exec tar xz --strip-component 1 -C "$toolchain_path"
           echo "toolchain-path=$toolchain_path" >> $GITHUB_OUTPUT
           ./build-exec "$toolchain_path/usr/bin/swift" sdk install "${{ matrix.wasi-swift-sdk-download }}" --checksum "${{ matrix.wasi-swift-sdk-checksum }}"
           wasi_sdk_path=$(./build-exec "$toolchain_path/usr/bin/swift" sdk configure --show-configuration "${{ matrix.wasi-swift-sdk-id }}" wasm32-unknown-wasi | grep sdkRootPath: | cut -d: -f2)
diff --git a/Package.swift b/Package.swift
@@ -4,12 +4,7 @@ import PackageDescription
 
 import class Foundation.ProcessInfo
 
-let DarwinPlatforms: [Platform]
-#if swift(<5.9)
-    DarwinPlatforms = [.macOS, .iOS, .watchOS, .tvOS]
-#else
-    DarwinPlatforms = [.macOS, .iOS, .watchOS, .tvOS, .visionOS]
-#endif
+let DarwinPlatforms: [Platform] = [.macOS, .iOS, .watchOS, .tvOS, .visionOS]
 
 let package = Package(
     name: "WasmKit",
@@ -120,8 +115,7 @@ let package = Package(
 
         .target(name: "WITExtractor"),
         .testTarget(name: "WITExtractorTests", dependencies: ["WITExtractor", "WIT"]),
-    ],
-    swiftLanguageVersions: [.v5]
+    ]
 )
 
 if ProcessInfo.processInfo.environment["SWIFTCI_USE_LOCAL_DEPS"] == nil {
diff --git a/Sources/WAT/Location.swift b/Sources/WAT/Location.swift
@@ -1,5 +1,5 @@
 /// A location in a WAT source file.
-public struct Location: Equatable, CustomDebugStringConvertible {
+public struct Location: Equatable, CustomDebugStringConvertible, Sendable {
     let index: Lexer.Index
     let source: String.UnicodeScalarView
 
diff --git a/Sources/WAT/WAT.swift b/Sources/WAT/WAT.swift
@@ -1,7 +1,7 @@
 import WasmParser
 
 /// Options for encoding a WebAssembly module into a binary format.
-public struct EncodeOptions {
+public struct EncodeOptions: Sendable {
     /// Whether to include the name section.
     public var nameSection: Bool
 
diff --git a/Sources/WIT/AST.swift b/Sources/WIT/AST.swift
@@ -33,13 +33,13 @@ struct Version: Equatable, Hashable, CustomStringConvertible {
     }
 }
 
-public enum ASTItemSyntax: Equatable, Hashable {
+public enum ASTItemSyntax: Equatable, Hashable, Sendable {
     case interface(SyntaxNode<InterfaceSyntax>)
     case world(SyntaxNode<WorldSyntax>)
     case use(SyntaxNode<TopLevelUseSyntax>)
 }
 
-public struct PackageNameSyntax: Equatable, Hashable, CustomStringConvertible {
+public struct PackageNameSyntax: Equatable, Hashable, CustomStringConvertible, Sendable {
     public var namespace: Identifier
     public var name: Identifier
     var version: Version?
@@ -81,27 +81,27 @@ public struct WorldSyntax: Equatable, Hashable, SyntaxNodeProtocol {
     public var items: [WorldItemSyntax]
 }
 
-public enum WorldItemSyntax: Equatable, Hashable {
+public enum WorldItemSyntax: Equatable, Hashable, Sendable {
     case `import`(ImportSyntax)
     case export(ExportSyntax)
     case use(SyntaxNode<UseSyntax>)
     case type(SyntaxNode<TypeDefSyntax>)
     case include(IncludeSyntax)
 }
 
-public struct ImportSyntax: Equatable, Hashable {
+public struct ImportSyntax: Equatable, Hashable, Sendable {
     public var documents: DocumentsSyntax
     public var attributes: [AttributeSyntax]
     public var kind: ExternKindSyntax
 }
 
-public struct ExportSyntax: Equatable, Hashable {
+public struct ExportSyntax: Equatable, Hashable, Sendable {
     public var documents: DocumentsSyntax
     public var attributes: [AttributeSyntax]
     public var kind: ExternKindSyntax
 }
 
-public enum ExternKindSyntax: Equatable, Hashable {
+public enum ExternKindSyntax: Equatable, Hashable, Sendable {
     case interface(Identifier, [InterfaceItemSyntax])
     case path(UsePathSyntax)
     case function(Identifier, FunctionSyntax)
@@ -131,7 +131,7 @@ public struct TypeDefSyntax: Equatable, Hashable, SyntaxNodeProtocol {
     public var body: TypeDefBodySyntax
 }
 
-public enum TypeDefBodySyntax: Equatable, Hashable {
+public enum TypeDefBodySyntax: Equatable, Hashable, Sendable {
     case flags(FlagsSyntax)
     case resource(ResourceSyntax)
     case record(RecordSyntax)
@@ -141,11 +141,11 @@ public enum TypeDefBodySyntax: Equatable, Hashable {
     case alias(TypeAliasSyntax)
 }
 
-public struct TypeAliasSyntax: Equatable, Hashable {
+public struct TypeAliasSyntax: Equatable, Hashable, Sendable {
     public let typeRepr: TypeReprSyntax
 }
 
-public indirect enum TypeReprSyntax: Equatable, Hashable {
+public indirect enum TypeReprSyntax: Equatable, Hashable, Sendable {
     case bool
     case u8
     case u16
@@ -169,7 +169,7 @@ public indirect enum TypeReprSyntax: Equatable, Hashable {
     case stream(StreamSyntax)
 }
 
-public enum HandleSyntax: Equatable, Hashable {
+public enum HandleSyntax: Equatable, Hashable, Sendable {
     case own(resource: Identifier)
     case borrow(resource: Identifier)
 
@@ -181,65 +181,65 @@ public enum HandleSyntax: Equatable, Hashable {
     }
 }
 
-public struct ResourceSyntax: Equatable, Hashable {
+public struct ResourceSyntax: Equatable, Hashable, Sendable {
     var functions: [ResourceFunctionSyntax]
 }
 
-public enum ResourceFunctionSyntax: Equatable, Hashable {
+public enum ResourceFunctionSyntax: Equatable, Hashable, Sendable {
     case method(SyntaxNode<NamedFunctionSyntax>)
     case `static`(SyntaxNode<NamedFunctionSyntax>)
     case constructor(SyntaxNode<NamedFunctionSyntax>)
 }
 
-public struct RecordSyntax: Equatable, Hashable {
+public struct RecordSyntax: Equatable, Hashable, Sendable {
     public var fields: [FieldSyntax]
 }
 
-public struct FieldSyntax: Equatable, Hashable {
+public struct FieldSyntax: Equatable, Hashable, Sendable {
     public var documents: DocumentsSyntax
     public var name: Identifier
     public var type: TypeReprSyntax
     var textRange: TextRange
 }
 
-public struct FlagsSyntax: Equatable, Hashable {
+public struct FlagsSyntax: Equatable, Hashable, Sendable {
     public var flags: [FlagSyntax]
 }
 
-public struct FlagSyntax: Equatable, Hashable {
+public struct FlagSyntax: Equatable, Hashable, Sendable {
     public var documents: DocumentsSyntax
     public var name: Identifier
 }
 
-public struct VariantSyntax: Equatable, Hashable {
+public struct VariantSyntax: Equatable, Hashable, Sendable {
     public var cases: [CaseSyntax]
     var textRange: TextRange
 }
 
-public struct CaseSyntax: Equatable, Hashable {
+public struct CaseSyntax: Equatable, Hashable, Sendable {
     public var documents: DocumentsSyntax
     public var name: Identifier
     public var type: TypeReprSyntax?
     var textRange: TextRange
 }
 
-public struct EnumSyntax: Equatable, Hashable {
+public struct EnumSyntax: Equatable, Hashable, Sendable {
     public var cases: [EnumCaseSyntax]
     var textRange: TextRange
 }
 
-public struct EnumCaseSyntax: Equatable, Hashable {
+public struct EnumCaseSyntax: Equatable, Hashable, Sendable {
     public var documents: DocumentsSyntax
     public var name: Identifier
     var textRange: TextRange
 }
 
-public struct ResultSyntax: Equatable, Hashable {
+public struct ResultSyntax: Equatable, Hashable, Sendable {
     public let ok: TypeReprSyntax?
     public let error: TypeReprSyntax?
 }
 
-public struct StreamSyntax: Equatable, Hashable {
+public struct StreamSyntax: Equatable, Hashable, Sendable {
     var element: TypeReprSyntax?
     var end: TypeReprSyntax?
 }
@@ -256,20 +256,20 @@ public struct UnionSyntax: Equatable, Hashable, SyntaxNodeProtocol {
     var textRange: TextRange
 }
 
-public struct UnionCaseSyntax: Equatable, Hashable {
+public struct UnionCaseSyntax: Equatable, Hashable, Sendable {
     public var documents: DocumentsSyntax
     public var type: TypeReprSyntax
     var textRange: TextRange
 }
 
-public struct ParameterSyntax: Equatable, Hashable {
+public struct ParameterSyntax: Equatable, Hashable, Sendable {
     public var name: Identifier
     public var type: TypeReprSyntax
     var textRange: TextRange
 }
 public typealias ParameterList = [ParameterSyntax]
 
-public enum ResultListSyntax: Equatable, Hashable {
+public enum ResultListSyntax: Equatable, Hashable, Sendable {
     case named(ParameterList)
     case anon(TypeReprSyntax)
 
@@ -281,7 +281,7 @@ public enum ResultListSyntax: Equatable, Hashable {
     }
 }
 
-public struct FunctionSyntax: Equatable, Hashable {
+public struct FunctionSyntax: Equatable, Hashable, Sendable {
     public var parameters: ParameterList
     public var results: ResultListSyntax
     var textRange: TextRange
@@ -293,7 +293,7 @@ public struct UseSyntax: Equatable, Hashable, SyntaxNodeProtocol {
     public var names: [UseNameSyntax]
 }
 
-public enum UsePathSyntax: Equatable, Hashable {
+public enum UsePathSyntax: Equatable, Hashable, Sendable {
     case id(Identifier)
     case package(id: PackageNameSyntax, name: Identifier)
 
@@ -305,23 +305,23 @@ public enum UsePathSyntax: Equatable, Hashable {
     }
 }
 
-public struct UseNameSyntax: Equatable, Hashable {
+public struct UseNameSyntax: Equatable, Hashable, Sendable {
     public var name: Identifier
     public var asName: Identifier?
 }
 
-public struct IncludeSyntax: Equatable, Hashable {
+public struct IncludeSyntax: Equatable, Hashable, Sendable {
     var attributes: [AttributeSyntax]
     var from: UsePathSyntax
     var names: [IncludeNameSyntax]
 }
 
-public struct IncludeNameSyntax: Equatable, Hashable {
+public struct IncludeNameSyntax: Equatable, Hashable, Sendable {
     var name: Identifier
     var asName: Identifier
 }
 
-public struct Identifier: Equatable, Hashable, CustomStringConvertible {
+public struct Identifier: Equatable, Hashable, CustomStringConvertible, Sendable {
     public var text: String
     var textRange: TextRange
 
@@ -330,28 +330,28 @@ public struct Identifier: Equatable, Hashable, CustomStringConvertible {
     }
 }
 
-public struct DocumentsSyntax: Equatable, Hashable {
+public struct DocumentsSyntax: Equatable, Hashable, Sendable {
     var comments: [String]
 }
 
-public enum AttributeSyntax: Equatable, Hashable {
+public enum AttributeSyntax: Equatable, Hashable, Sendable {
     case since(SinceAttributeSyntax)
     case unstable(UnstableAttributeSyntax)
     case deprecated(DeprecatedAttributeSyntax)
 }
 
-public struct SinceAttributeSyntax: Equatable, Hashable {
+public struct SinceAttributeSyntax: Equatable, Hashable, Sendable {
     let version: Version
     let feature: Identifier?
     let textRange: TextRange
 }
 
-public struct UnstableAttributeSyntax: Equatable, Hashable {
+public struct UnstableAttributeSyntax: Equatable, Hashable, Sendable {
     let textRange: TextRange
     let feature: Identifier
 }
 
-public struct DeprecatedAttributeSyntax: Equatable, Hashable {
+public struct DeprecatedAttributeSyntax: Equatable, Hashable, Sendable {
     let textRange: TextRange
     let version: Version
 }
diff --git a/Sources/WIT/Diagnostics.swift b/Sources/WIT/Diagnostics.swift
@@ -6,7 +6,7 @@ struct DiagnosticError: Error {
     let diagnostic: Diagnostic
 }
 
-public struct Diagnostic {
+public struct Diagnostic: Sendable {
 
     public let message: String
     var textRange: TextRange?
diff --git a/Sources/WIT/PackageResolver.swift b/Sources/WIT/PackageResolver.swift
@@ -1,7 +1,7 @@
 import Foundation
 
 /// A unit of WIT package managing a collection of WIT source files
-public final class PackageUnit: Hashable, CustomStringConvertible {
+public final class PackageUnit: Hashable, CustomStringConvertible, Sendable {
     public let packageName: PackageNameSyntax
     public let sourceFiles: [SyntaxNode<SourceFileSyntax>]
 
diff --git a/Sources/WIT/Semantics/RequestEvaluator.swift b/Sources/WIT/Semantics/RequestEvaluator.swift
@@ -35,7 +35,7 @@ internal class Evaluator {
 
         // Check cyclical request
         if activeRequestsSet.contains(requestAsHashable) {
-            throw CyclicalRequestError(activeRequests: activeRequests + [request])
+            throw CyclicalRequestError(activeRequestDescriptions: activeRequests.map { "\($0)" } + ["\(request)"])
         }
 
         // Push the given request as an active request
@@ -64,11 +64,11 @@ internal class Evaluator {
 
 extension Evaluator {
     struct CyclicalRequestError: Error, CustomStringConvertible {
-        let activeRequests: [any EvaluationRequest]
+        let activeRequestDescriptions: [String]
 
         var description: String {
             var description = "==== Cycle detected! ====\n"
-            for (index, request) in activeRequests.enumerated() {
+            for (index, request) in activeRequestDescriptions.enumerated() {
                 let indent = String(repeating: "  ", count: index)
                 description += "\(indent)\\- \(request)\n"
             }
diff --git a/Sources/WIT/SyntaxNode.swift b/Sources/WIT/SyntaxNode.swift
@@ -1,10 +1,10 @@
 /// An AST node that can be wrapped by ``SyntaxNode`` as a reference
-public protocol SyntaxNodeProtocol {}
+public protocol SyntaxNodeProtocol: Sendable {}
 
 /// An AST node with reference semantics to provide identity of a node.
 @dynamicMemberLookup
-public struct SyntaxNode<Syntax: SyntaxNodeProtocol>: Equatable, Hashable {
-    class Ref {
+public struct SyntaxNode<Syntax: SyntaxNodeProtocol>: Equatable, Hashable, Sendable {
+    final class Ref: Sendable {
         fileprivate let syntax: Syntax
         init(syntax: Syntax) {
             self.syntax = syntax
diff --git a/Sources/WasmKit/Component/ComponentTypes.swift b/Sources/WasmKit/Component/ComponentTypes.swift
@@ -1,5 +1,5 @@
 /// Error type raised from Component Model operations
-public struct ComponentError<Content>: Error {
+public struct ComponentError<Content: Sendable>: Error {
     /// The content of the error
     public let content: Content
 
diff --git a/Sources/WasmKit/Execution/Errors.swift b/Sources/WasmKit/Execution/Errors.swift
@@ -3,12 +3,9 @@ import WasmTypes
 import struct WasmParser.Import
 
 /// The backtrace of the trap.
-struct Backtrace: CustomStringConvertible {
+struct Backtrace: CustomStringConvertible, Sendable {
     /// A symbol in the backtrace.
     struct Symbol {
-        /// The function that the symbol represents.
-        let function: Function
-
         /// The name of the symbol.
         let name: String?
     }
diff --git a/Sources/WasmKit/Execution/Execution.swift b/Sources/WasmKit/Execution/Execution.swift
@@ -70,7 +70,6 @@ struct Execution {
             let symbolName = store.nameRegistry.symbolicate(.wasm(function))
             symbols.append(
                 Backtrace.Symbol(
-                    function: Function(handle: .wasm(function), store: store),
                     name: symbolName
                 )
             )
diff --git a/Sources/WasmParser/Stream/Stream.swift b/Sources/WasmParser/Stream/Stream.swift
diff --git a/Sources/WasmParser/WasmParser.swift b/Sources/WasmParser/WasmParser.swift
diff --git a/Sources/WasmParser/WasmTypes.swift b/Sources/WasmParser/WasmTypes.swift
diff --git a/Sources/WasmTypes/WasmTypes.swift b/Sources/WasmTypes/WasmTypes.swift
diff --git a/Tests/WITTests/Semantics/RequestEvaluatorTests.swift b/Tests/WITTests/Semantics/RequestEvaluatorTests.swift
diff --git a/Tests/WasmKitTests/Spectest/Spectest.swift b/Tests/WasmKitTests/Spectest/Spectest.swift

Original file line number	Diff line number	Diff line change
`@@ -33,13 +33,13 @@ struct Version: Equatable, Hashable, CustomStringConvertible {`
`33`	`33`	`}`
`34`	`34`	`}`
`35`	`35`
`36`		`-public enum ASTItemSyntax: Equatable, Hashable {`
	`36`	`+public enum ASTItemSyntax: Equatable, Hashable, Sendable {`
`37`	`37`	`case interface(SyntaxNode<InterfaceSyntax>)`
`38`	`38`	`case world(SyntaxNode<WorldSyntax>)`
`39`	`39`	`case use(SyntaxNode<TopLevelUseSyntax>)`
`40`	`40`	`}`
`41`	`41`
`42`		`-public struct PackageNameSyntax: Equatable, Hashable, CustomStringConvertible {`
	`42`	`+public struct PackageNameSyntax: Equatable, Hashable, CustomStringConvertible, Sendable {`
`43`	`43`	`public var namespace: Identifier`
`44`	`44`	`public var name: Identifier`
`45`	`45`	`var version: Version?`
`@@ -81,27 +81,27 @@ public struct WorldSyntax: Equatable, Hashable, SyntaxNodeProtocol {`
`81`	`81`	`public var items: [WorldItemSyntax]`
`82`	`82`	`}`
`83`	`83`
`84`		`-public enum WorldItemSyntax: Equatable, Hashable {`
	`84`	`+public enum WorldItemSyntax: Equatable, Hashable, Sendable {`
`85`	`85`	case `import`(ImportSyntax)
`86`	`86`	`case export(ExportSyntax)`
`87`	`87`	`case use(SyntaxNode<UseSyntax>)`
`88`	`88`	`case type(SyntaxNode<TypeDefSyntax>)`
`89`	`89`	`case include(IncludeSyntax)`
`90`	`90`	`}`
`91`	`91`
`92`		`-public struct ImportSyntax: Equatable, Hashable {`
	`92`	`+public struct ImportSyntax: Equatable, Hashable, Sendable {`
`93`	`93`	`public var documents: DocumentsSyntax`
`94`	`94`	`public var attributes: [AttributeSyntax]`
`95`	`95`	`public var kind: ExternKindSyntax`
`96`	`96`	`}`
`97`	`97`
`98`		`-public struct ExportSyntax: Equatable, Hashable {`
	`98`	`+public struct ExportSyntax: Equatable, Hashable, Sendable {`
`99`	`99`	`public var documents: DocumentsSyntax`
`100`	`100`	`public var attributes: [AttributeSyntax]`
`101`	`101`	`public var kind: ExternKindSyntax`
`102`	`102`	`}`
`103`	`103`
`104`		`-public enum ExternKindSyntax: Equatable, Hashable {`
	`104`	`+public enum ExternKindSyntax: Equatable, Hashable, Sendable {`
`105`	`105`	`case interface(Identifier, [InterfaceItemSyntax])`
`106`	`106`	`case path(UsePathSyntax)`
`107`	`107`	`case function(Identifier, FunctionSyntax)`
`@@ -131,7 +131,7 @@ public struct TypeDefSyntax: Equatable, Hashable, SyntaxNodeProtocol {`
`131`	`131`	`public var body: TypeDefBodySyntax`
`132`	`132`	`}`
`133`	`133`
`134`		`-public enum TypeDefBodySyntax: Equatable, Hashable {`
	`134`	`+public enum TypeDefBodySyntax: Equatable, Hashable, Sendable {`
`135`	`135`	`case flags(FlagsSyntax)`
`136`	`136`	`case resource(ResourceSyntax)`
`137`	`137`	`case record(RecordSyntax)`
`@@ -141,11 +141,11 @@ public enum TypeDefBodySyntax: Equatable, Hashable {`
`141`	`141`	`case alias(TypeAliasSyntax)`
`142`	`142`	`}`
`143`	`143`
`144`		`-public struct TypeAliasSyntax: Equatable, Hashable {`
	`144`	`+public struct TypeAliasSyntax: Equatable, Hashable, Sendable {`
`145`	`145`	`public let typeRepr: TypeReprSyntax`
`146`	`146`	`}`
`147`	`147`
`148`		`-public indirect enum TypeReprSyntax: Equatable, Hashable {`
	`148`	`+public indirect enum TypeReprSyntax: Equatable, Hashable, Sendable {`
`149`	`149`	`case bool`
`150`	`150`	`case u8`
`151`	`151`	`case u16`
`@@ -169,7 +169,7 @@ public indirect enum TypeReprSyntax: Equatable, Hashable {`
`169`	`169`	`case stream(StreamSyntax)`
`170`	`170`	`}`
`171`	`171`
`172`		`-public enum HandleSyntax: Equatable, Hashable {`
	`172`	`+public enum HandleSyntax: Equatable, Hashable, Sendable {`
`173`	`173`	`case own(resource: Identifier)`
`174`	`174`	`case borrow(resource: Identifier)`
`175`	`175`
`@@ -181,65 +181,65 @@ public enum HandleSyntax: Equatable, Hashable {`
`181`	`181`	`}`
`182`	`182`	`}`
`183`	`183`
`184`		`-public struct ResourceSyntax: Equatable, Hashable {`
	`184`	`+public struct ResourceSyntax: Equatable, Hashable, Sendable {`
`185`	`185`	`var functions: [ResourceFunctionSyntax]`
`186`	`186`	`}`
`187`	`187`
`188`		`-public enum ResourceFunctionSyntax: Equatable, Hashable {`
	`188`	`+public enum ResourceFunctionSyntax: Equatable, Hashable, Sendable {`
`189`	`189`	`case method(SyntaxNode<NamedFunctionSyntax>)`
`190`	`190`	case `static`(SyntaxNode<NamedFunctionSyntax>)
`191`	`191`	`case constructor(SyntaxNode<NamedFunctionSyntax>)`
`192`	`192`	`}`
`193`	`193`
`194`		`-public struct RecordSyntax: Equatable, Hashable {`
	`194`	`+public struct RecordSyntax: Equatable, Hashable, Sendable {`
`195`	`195`	`public var fields: [FieldSyntax]`
`196`	`196`	`}`
`197`	`197`
`198`		`-public struct FieldSyntax: Equatable, Hashable {`
	`198`	`+public struct FieldSyntax: Equatable, Hashable, Sendable {`
`199`	`199`	`public var documents: DocumentsSyntax`
`200`	`200`	`public var name: Identifier`
`201`	`201`	`public var type: TypeReprSyntax`
`202`	`202`	`var textRange: TextRange`
`203`	`203`	`}`
`204`	`204`
`205`		`-public struct FlagsSyntax: Equatable, Hashable {`
	`205`	`+public struct FlagsSyntax: Equatable, Hashable, Sendable {`
`206`	`206`	`public var flags: [FlagSyntax]`
`207`	`207`	`}`
`208`	`208`
`209`		`-public struct FlagSyntax: Equatable, Hashable {`
	`209`	`+public struct FlagSyntax: Equatable, Hashable, Sendable {`
`210`	`210`	`public var documents: DocumentsSyntax`
`211`	`211`	`public var name: Identifier`
`212`	`212`	`}`
`213`	`213`
`214`		`-public struct VariantSyntax: Equatable, Hashable {`
	`214`	`+public struct VariantSyntax: Equatable, Hashable, Sendable {`
`215`	`215`	`public var cases: [CaseSyntax]`
`216`	`216`	`var textRange: TextRange`
`217`	`217`	`}`
`218`	`218`
`219`		`-public struct CaseSyntax: Equatable, Hashable {`
	`219`	`+public struct CaseSyntax: Equatable, Hashable, Sendable {`
`220`	`220`	`public var documents: DocumentsSyntax`
`221`	`221`	`public var name: Identifier`
`222`	`222`	`public var type: TypeReprSyntax?`
`223`	`223`	`var textRange: TextRange`
`224`	`224`	`}`
`225`	`225`
`226`		`-public struct EnumSyntax: Equatable, Hashable {`
	`226`	`+public struct EnumSyntax: Equatable, Hashable, Sendable {`
`227`	`227`	`public var cases: [EnumCaseSyntax]`
`228`	`228`	`var textRange: TextRange`
`229`	`229`	`}`
`230`	`230`
`231`		`-public struct EnumCaseSyntax: Equatable, Hashable {`
	`231`	`+public struct EnumCaseSyntax: Equatable, Hashable, Sendable {`
`232`	`232`	`public var documents: DocumentsSyntax`
`233`	`233`	`public var name: Identifier`
`234`	`234`	`var textRange: TextRange`
`235`	`235`	`}`
`236`	`236`
`237`		`-public struct ResultSyntax: Equatable, Hashable {`
	`237`	`+public struct ResultSyntax: Equatable, Hashable, Sendable {`
`238`	`238`	`public let ok: TypeReprSyntax?`
`239`	`239`	`public let error: TypeReprSyntax?`
`240`	`240`	`}`
`241`	`241`
`242`		`-public struct StreamSyntax: Equatable, Hashable {`
	`242`	`+public struct StreamSyntax: Equatable, Hashable, Sendable {`
`243`	`243`	`var element: TypeReprSyntax?`
`244`	`244`	`var end: TypeReprSyntax?`
`245`	`245`	`}`
`@@ -256,20 +256,20 @@ public struct UnionSyntax: Equatable, Hashable, SyntaxNodeProtocol {`
`256`	`256`	`var textRange: TextRange`
`257`	`257`	`}`
`258`	`258`
`259`		`-public struct UnionCaseSyntax: Equatable, Hashable {`
	`259`	`+public struct UnionCaseSyntax: Equatable, Hashable, Sendable {`
`260`	`260`	`public var documents: DocumentsSyntax`
`261`	`261`	`public var type: TypeReprSyntax`
`262`	`262`	`var textRange: TextRange`
`263`	`263`	`}`
`264`	`264`
`265`		`-public struct ParameterSyntax: Equatable, Hashable {`
	`265`	`+public struct ParameterSyntax: Equatable, Hashable, Sendable {`
`266`	`266`	`public var name: Identifier`
`267`	`267`	`public var type: TypeReprSyntax`
`268`	`268`	`var textRange: TextRange`
`269`	`269`	`}`
`270`	`270`	`public typealias ParameterList = [ParameterSyntax]`
`271`	`271`
`272`		`-public enum ResultListSyntax: Equatable, Hashable {`
	`272`	`+public enum ResultListSyntax: Equatable, Hashable, Sendable {`
`273`	`273`	`case named(ParameterList)`
`274`	`274`	`case anon(TypeReprSyntax)`
`275`	`275`
`@@ -281,7 +281,7 @@ public enum ResultListSyntax: Equatable, Hashable {`
`281`	`281`	`}`
`282`	`282`	`}`
`283`	`283`
`284`		`-public struct FunctionSyntax: Equatable, Hashable {`
	`284`	`+public struct FunctionSyntax: Equatable, Hashable, Sendable {`
`285`	`285`	`public var parameters: ParameterList`
`286`	`286`	`public var results: ResultListSyntax`
`287`	`287`	`var textRange: TextRange`
`@@ -293,7 +293,7 @@ public struct UseSyntax: Equatable, Hashable, SyntaxNodeProtocol {`
`293`	`293`	`public var names: [UseNameSyntax]`
`294`	`294`	`}`
`295`	`295`
`296`		`-public enum UsePathSyntax: Equatable, Hashable {`
	`296`	`+public enum UsePathSyntax: Equatable, Hashable, Sendable {`
`297`	`297`	`case id(Identifier)`
`298`	`298`	`case package(id: PackageNameSyntax, name: Identifier)`
`299`	`299`
`@@ -305,23 +305,23 @@ public enum UsePathSyntax: Equatable, Hashable {`
`305`	`305`	`}`
`306`	`306`	`}`
`307`	`307`
`308`		`-public struct UseNameSyntax: Equatable, Hashable {`
	`308`	`+public struct UseNameSyntax: Equatable, Hashable, Sendable {`
`309`	`309`	`public var name: Identifier`
`310`	`310`	`public var asName: Identifier?`
`311`	`311`	`}`
`312`	`312`
`313`		`-public struct IncludeSyntax: Equatable, Hashable {`
	`313`	`+public struct IncludeSyntax: Equatable, Hashable, Sendable {`
`314`	`314`	`var attributes: [AttributeSyntax]`
`315`	`315`	`var from: UsePathSyntax`
`316`	`316`	`var names: [IncludeNameSyntax]`
`317`	`317`	`}`
`318`	`318`
`319`		`-public struct IncludeNameSyntax: Equatable, Hashable {`
	`319`	`+public struct IncludeNameSyntax: Equatable, Hashable, Sendable {`
`320`	`320`	`var name: Identifier`
`321`	`321`	`var asName: Identifier`
`322`	`322`	`}`
`323`	`323`
`324`		`-public struct Identifier: Equatable, Hashable, CustomStringConvertible {`
	`324`	`+public struct Identifier: Equatable, Hashable, CustomStringConvertible, Sendable {`
`325`	`325`	`public var text: String`
`326`	`326`	`var textRange: TextRange`
`327`	`327`
`@@ -330,28 +330,28 @@ public struct Identifier: Equatable, Hashable, CustomStringConvertible {`
`330`	`330`	`}`
`331`	`331`	`}`
`332`	`332`
`333`		`-public struct DocumentsSyntax: Equatable, Hashable {`
	`333`	`+public struct DocumentsSyntax: Equatable, Hashable, Sendable {`
`334`	`334`	`var comments: [String]`
`335`	`335`	`}`
`336`	`336`
`337`		`-public enum AttributeSyntax: Equatable, Hashable {`
	`337`	`+public enum AttributeSyntax: Equatable, Hashable, Sendable {`
`338`	`338`	`case since(SinceAttributeSyntax)`
`339`	`339`	`case unstable(UnstableAttributeSyntax)`
`340`	`340`	`case deprecated(DeprecatedAttributeSyntax)`
`341`	`341`	`}`
`342`	`342`
`343`		`-public struct SinceAttributeSyntax: Equatable, Hashable {`
	`343`	`+public struct SinceAttributeSyntax: Equatable, Hashable, Sendable {`
`344`	`344`	`let version: Version`
`345`	`345`	`let feature: Identifier?`
`346`	`346`	`let textRange: TextRange`
`347`	`347`	`}`
`348`	`348`
`349`		`-public struct UnstableAttributeSyntax: Equatable, Hashable {`
	`349`	`+public struct UnstableAttributeSyntax: Equatable, Hashable, Sendable {`
`350`	`350`	`let textRange: TextRange`
`351`	`351`	`let feature: Identifier`
`352`	`352`	`}`
`353`	`353`
`354`		`-public struct DeprecatedAttributeSyntax: Equatable, Hashable {`
	`354`	`+public struct DeprecatedAttributeSyntax: Equatable, Hashable, Sendable {`
`355`	`355`	`let textRange: TextRange`
`356`	`356`	`let version: Version`
`357`	`357`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@ struct DiagnosticError: Error {`
`6`	`6`	`let diagnostic: Diagnostic`
`7`	`7`	`}`
`8`	`8`
`9`		`-public struct Diagnostic {`
	`9`	`+public struct Diagnostic: Sendable {`
`10`	`10`
`11`	`11`	`public let message: String`
`12`	`12`	`var textRange: TextRange?`