Swift Package IndexBuild Information
Successful build of swift-idna, reference main (cc894d), with Swift 6.3 for Wasm on 10 Oct 2026 09:05:49 UTC.
Swift 6 data race errors: 0
Build Command
bash -c docker run --pull=always --rm -v "checkouts-54344843-0":/host -w "$PWD" -e JAVA_HOME="/root/.sdkman/candidates/java/current" -e SPI_BUILD="1" -e SPI_PROCESSING="1" registry.gitlab.com/saguaro1/spi-images:wasm-6.3-latest swift build --swift-sdk swift-6.3.2-RELEASE_wasm 2>&1Build Log
========================================
RunAll
========================================
Builder version: 5.1.1
Interrupt handler set up.
========================================
Checkout
========================================
Clone URL: https://github.com/swift-dns/swift-idna.git
Reference: main
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/swift-dns/swift-idna
* branch main -> FETCH_HEAD
* [new branch] main -> origin/main
HEAD is now at cc894d4 Harden UTF8 checks (#55)
Cloned https://github.com/swift-dns/swift-idna.git
Revision (git rev-parse @):
cc894d45b3f489825519fe4ab389370ace6937d7
SUCCESS checkout https://github.com/swift-dns/swift-idna.git at main
========================================
Build
========================================
Selected platform: wasm
Swift version: 6.3
Building package at path: $PWD
https://github.com/swift-dns/swift-idna.git
Running build ...
bash -c docker run --pull=always --rm -v "checkouts-54344843-0":/host -w "$PWD" -e JAVA_HOME="/root/.sdkman/candidates/java/current" -e SPI_BUILD="1" -e SPI_PROCESSING="1" registry.gitlab.com/saguaro1/spi-images:wasm-6.3-latest swift build --swift-sdk swift-6.3.2-RELEASE_wasm 2>&1
wasm-6.3-latest: Pulling from saguaro1/spi-images
Digest: sha256:df2e9038ff906af397ec7b7e13902ccb183f8867606bc33419e44453a9abdb4b
Status: Image is up to date for registry.gitlab.com/saguaro1/spi-images:wasm-6.3-latest
Fetching https://github.com/apple/swift-collections.git
Fetching https://github.com/swift-dns/swift-highway.git
[1/632] Fetching swift-highway
[58/29327] Fetching swift-highway, swift-collections
Fetched https://github.com/swift-dns/swift-highway.git from cache (1.63s)
Fetched https://github.com/apple/swift-collections.git from cache (1.64s)
Computing version for https://github.com/apple/swift-collections.git
Computed https://github.com/apple/swift-collections.git at 1.7.2 (1.89s)
Computing version for https://github.com/swift-dns/swift-highway.git
Computed https://github.com/swift-dns/swift-highway.git at 1.0.0-alpha.7 (0.16s)
Creating working copy for https://github.com/apple/swift-collections.git
Working copy of https://github.com/apple/swift-collections.git resolved at 1.7.2
Creating working copy for https://github.com/swift-dns/swift-highway.git
Working copy of https://github.com/swift-dns/swift-highway.git resolved at 1.0.0-alpha.7
Building for debugging...
[0/11] Write sources
[5/11] Compiling cswift_idna_mark_table.c
[6/11] Compiling cswift_idna_nfc_table.c
[7/11] Write swift-version-24593BA9C3E375BF.txt
[8/11] Compiling cswift_idna_mapping_table.c
[9/52] Compiling cswift_idna_test_v2_cases.c
[11/52] Emitting module InternalCollectionsUtilities
[11/55] Compiling cswift_idna_nfc_test_cases.c
[13/55] Compiling InternalCollectionsUtilities UnsafeRawBufferPointer+Extras.swift
[14/55] Compiling InternalCollectionsUtilities _SortedCollection.swift
[15/55] Compiling InternalCollectionsUtilities _UniqueCollection.swift
[16/55] Compiling InternalCollectionsUtilities Strideable+LimitHelpers.swift
[17/55] Compiling InternalCollectionsUtilities String+Padding.swift
[18/55] Compiling InternalCollectionsUtilities TemporaryAllocation.swift
[19/55] Compiling InternalCollectionsUtilities _UnsafeBitSet+Index.swift
[20/55] Compiling InternalCollectionsUtilities UnsafeMutablePointer+Extras.swift
[21/55] Compiling InternalCollectionsUtilities UnsafeMutableRawBufferPointer+Extras.swift
[22/55] Compiling InternalCollectionsUtilities UnsafePointer+Extras.swift
[23/55] Compiling InternalCollectionsUtilities MutableSpan+Extras.swift
[24/55] Compiling InternalCollectionsUtilities OutputSpan+Extras.swift
[25/55] Compiling InternalCollectionsUtilities RandomAccessCollection+Offsets.swift
[26/55] Compiling InternalCollectionsUtilities Span+Extras.swift
[27/55] Compiling InternalCollectionsUtilities BorrowingIteratorProtocol+Equality.swift
[28/55] Compiling InternalCollectionsUtilities BorrowingIteratorProtocol+Extras.swift
[29/55] Compiling InternalCollectionsUtilities Debugging.swift
[30/55] Compiling InternalCollectionsUtilities Descriptions.swift
[31/55] Compiling InternalCollectionsUtilities _UnsafeBitSet+_Word.swift
[32/55] Compiling InternalCollectionsUtilities _UnsafeBitSet.swift
[33/56] Compiling InternalCollectionsUtilities UInt+first and last set bit.swift
[34/56] Compiling InternalCollectionsUtilities UInt+reversed.swift
[35/56] Compiling InternalCollectionsUtilities FixedWidthInteger+roundUpToPowerOfTwo.swift
[36/56] Compiling InternalCollectionsUtilities Integer rank.swift
[37/56] Compiling InternalCollectionsUtilities UnsafeBufferPointer+Extras.swift
[38/56] Compiling InternalCollectionsUtilities UnsafeMutableBufferPointer+Extras.swift
[39/56] Emitting module Highway
[40/56] Compiling Highway Highway.swift
[49/56] Compiling InternalCollectionsUtilities Iterable+CopyContents.swift
[50/56] Compiling InternalCollectionsUtilities Iterable+Equality.swift
[51/56] Compiling InternalCollectionsUtilities LifetimeOverride.swift
[52/56] Compiling InternalCollectionsUtilities MutableRef.swift
[53/57] Compiling Highway HighwayUInt64.swift
[54/57] Compiling Highway HighwayUInt8.swift
[59/62] Compiling SpanPreview OutputSpan+InputSpanHelpers.swift
[60/62] Compiling SpanPreview InputSpan.swift
[61/62] Emitting module SpanPreview
[62/62] Compiling SpanPreview MutableSpan+InputSpanHelpers.swift
[64/146] Compiling BasicContainers RigidSet+Iterable.swift
[65/146] Compiling BasicContainers RigidSet+Lookup.swift
[66/146] Compiling BasicContainers RigidSet+Removals.swift
[67/146] Compiling BasicContainers RigidSet+Resizing.swift
[68/146] Compiling BasicContainers RigidSet.swift
[69/146] Compiling BasicContainers UniqueArray+Append.swift
[70/146] Compiling BasicContainers UniqueArray+Consumption.swift
[71/146] Compiling BasicContainers UniqueArray+ContainerOperations.swift
[72/146] Compiling BasicContainers UniqueArray+Deprecated.swift
[73/146] Compiling BasicContainers UniqueArray+Descriptions.swift
[74/146] Compiling BasicContainers UniqueArray+Equatable.swift
[75/146] Compiling BasicContainers UniqueArray+Experimental.swift
[76/157] Compiling BasicContainers UniqueSet+Deprecated.swift
[77/157] Compiling BasicContainers UniqueSet+Equatable.swift
[78/157] Compiling BasicContainers UniqueSet+Hashable.swift
[79/157] Compiling BasicContainers UniqueSet+Index.swift
[80/157] Compiling BasicContainers UniqueSet+Initializers.swift
[81/157] Compiling BasicContainers UniqueSet+Insertions.swift
[82/157] Compiling BasicContainers UniqueSet+Iterable.swift
[83/157] Compiling BasicContainers UniqueSet+Lookup.swift
[84/157] Compiling BasicContainers UniqueSet+Removals.swift
[85/157] Compiling BasicContainers UniqueSet+Resizing.swift
[86/157] Compiling BasicContainers UniqueSet.swift
[87/157] Compiling BasicContainers RigidArray+Append.swift
[88/157] Compiling BasicContainers RigidArray+Consumption.swift
[89/157] Compiling BasicContainers RigidArray+ContainerOperations.swift
[90/157] Compiling BasicContainers RigidArray+Deprecated.swift
[91/157] Compiling BasicContainers RigidArray+Descriptions.swift
[92/157] Compiling BasicContainers RigidArray+Equatable.swift
[93/157] Compiling BasicContainers RigidArray+Experimental.swift
[94/157] Compiling BasicContainers RigidArray+Formatter.swift
[95/157] Compiling BasicContainers RigidArray+Hashable.swift
[96/157] Compiling BasicContainers RigidArray+Initializers.swift
[97/157] Compiling BasicContainers RigidArray+Insertions.swift
[98/157] Compiling BasicContainers RigidArray+Iterable.swift
[99/157] Compiling BasicContainers UniqueArray+Hashable.swift
[100/157] Compiling BasicContainers UniqueArray+Initializers.swift
[101/157] Compiling BasicContainers UniqueArray+Insertions.swift
[102/157] Compiling BasicContainers UniqueArray+Iterable.swift
[103/157] Compiling BasicContainers UniqueArray+Removals.swift
[104/157] Compiling BasicContainers UniqueArray+Replacements.swift
[105/157] Compiling BasicContainers UniqueArray.swift
[106/157] Compiling BasicContainers UniqueDictionary+Consumption.swift
[107/157] Compiling BasicContainers UniqueDictionary+Debugging.swift
[108/157] Compiling BasicContainers UniqueDictionary+Equatable.swift
[109/157] Compiling BasicContainers UniqueDictionary+Hashable.swift
[110/157] Compiling BasicContainers RigidArray+Removals.swift
[111/157] Compiling BasicContainers RigidArray+Replacements.swift
[112/157] Compiling BasicContainers RigidArray.swift
[113/157] Compiling BasicContainers RigidDictionary+Consumption.swift
[114/157] Compiling BasicContainers RigidDictionary+Debugging.swift
[115/157] Compiling BasicContainers RigidDictionary+Equatable.swift
[116/157] Compiling BasicContainers RigidDictionary+Hashable.swift
[117/157] Compiling BasicContainers RigidDictionary+Index.swift
[118/157] Compiling BasicContainers RigidDictionary+Indices.swift
[119/157] Compiling BasicContainers RigidDictionary+Initializers.swift
[120/157] Compiling BasicContainers RigidDictionary+Insertions.swift
[121/157] Compiling BasicContainers RigidDictionary+Keys.swift
[122/157] Compiling BasicContainers RigidDictionary+Lookup.swift
[123/157] Compiling BasicContainers RigidDictionary+Removals.swift
[124/157] Compiling BasicContainers RigidDictionary+Resizing.swift
[125/157] Compiling BasicContainers RigidDictionary.swift
[126/157] Compiling BasicContainers RigidSet+Consumption.swift
[127/157] Compiling BasicContainers RigidSet+Debugging.swift
[128/157] Compiling BasicContainers RigidSet+Deprecated.swift
[129/157] Compiling BasicContainers RigidSet+Equatable.swift
[130/157] Compiling BasicContainers RigidSet+Hashable.swift
[131/157] Compiling BasicContainers RigidSet+Index.swift
[132/157] Compiling BasicContainers RigidSet+Initializers.swift
[133/157] Compiling BasicContainers RigidSet+Insertions.swift
[134/157] Compiling BasicContainers UniqueDictionary+Index.swift
[135/157] Compiling BasicContainers UniqueDictionary+Indices.swift
[136/157] Compiling BasicContainers UniqueDictionary+Initializers.swift
[137/157] Compiling BasicContainers UniqueDictionary+Insertions.swift
[138/157] Compiling BasicContainers UniqueDictionary+Keys.swift
[139/157] Compiling BasicContainers UniqueDictionary+Lookup.swift
[140/157] Compiling BasicContainers UniqueDictionary+Removals.swift
[141/157] Compiling BasicContainers UniqueDictionary+Resizing.swift
[142/157] Compiling BasicContainers UniqueDictionary.swift
[143/157] Compiling BasicContainers UniqueSet+Consumption.swift
[144/157] Compiling BasicContainers UniqueSet+Debugging.swift
[145/157] Emitting module BasicContainers
[146/157] Compiling BasicContainers _HTable+Bitmap.swift
[147/157] Compiling BasicContainers _HTable+Bucket.swift
[148/157] Compiling BasicContainers _HTable+Consumption.swift
[149/157] Compiling BasicContainers _HTable+Debug.swift
[150/157] Compiling BasicContainers _HTable+Deprecated.swift
[151/157] Compiling BasicContainers _HTable+Find.swift
[152/157] Compiling BasicContainers _HTable+Insert.swift
[153/157] Compiling BasicContainers _HTable+Iteration.swift
[154/157] Compiling BasicContainers _HTable+Removal.swift
[155/157] Compiling BasicContainers _HTable+Resizing.swift
[156/157] Compiling BasicContainers _HTable+Sizing.swift
[157/157] Compiling BasicContainers _HTable.swift
[159/182] Compiling SwiftIDNA TinyBufferSubSequence.swift
[160/182] Compiling SwiftIDNA UTF8BytesIterator.swift
[161/182] Compiling SwiftIDNA UnicodeScalarIterator.swift
[162/185] Compiling SwiftIDNA +Array.swift
/host/spi-builder-workspace/Sources/SwiftIDNA/+Array.swift:7:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
5 | package init(copying span: Span<Element>) {
6 | unsafe self.init(unsafeUninitializedCapacity: span.count) { buffer, initializedCount in
7 | span.withUnsafeBytes { spanPtr in
| | | `- note: argument #0 in call to instance method 'withUnsafeBytes' has unsafe type '(UnsafeRawBufferPointer) -> ()'
| | `- note: reference to instance method 'withUnsafeBytes' involves unsafe type 'UnsafeRawBufferPointer'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
8 | let rawBuffer = UnsafeMutableRawBufferPointer(buffer)
9 | unsafe rawBuffer.copyMemory(from: spanPtr)
/host/spi-builder-workspace/Sources/SwiftIDNA/+OutputSpan.swift:10:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
8 | let usedCapacity = self.count
9 | unsafe self.withUnsafeMutableBufferPointer { buffer, initializedCount in
10 | span.withUnsafeBytes { spanPtr in
| | | `- note: argument #0 in call to instance method 'withUnsafeBytes' has unsafe type '(UnsafeRawBufferPointer) -> ()'
| | `- note: reference to instance method 'withUnsafeBytes' involves unsafe type 'UnsafeRawBufferPointer'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
11 | let target = unsafe UnsafeMutableRawPointer(
12 | buffer.baseAddress.unsafelyUnwrapped
[#StrictMemorySafety]: <https://docs.swift.org/compiler/documentation/diagnostics/strict-memory-safety>
[163/185] Compiling SwiftIDNA +BinaryInteger.swift
/host/spi-builder-workspace/Sources/SwiftIDNA/+Array.swift:7:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
5 | package init(copying span: Span<Element>) {
6 | unsafe self.init(unsafeUninitializedCapacity: span.count) { buffer, initializedCount in
7 | span.withUnsafeBytes { spanPtr in
| | | `- note: argument #0 in call to instance method 'withUnsafeBytes' has unsafe type '(UnsafeRawBufferPointer) -> ()'
| | `- note: reference to instance method 'withUnsafeBytes' involves unsafe type 'UnsafeRawBufferPointer'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
8 | let rawBuffer = UnsafeMutableRawBufferPointer(buffer)
9 | unsafe rawBuffer.copyMemory(from: spanPtr)
/host/spi-builder-workspace/Sources/SwiftIDNA/+OutputSpan.swift:10:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
8 | let usedCapacity = self.count
9 | unsafe self.withUnsafeMutableBufferPointer { buffer, initializedCount in
10 | span.withUnsafeBytes { spanPtr in
| | | `- note: argument #0 in call to instance method 'withUnsafeBytes' has unsafe type '(UnsafeRawBufferPointer) -> ()'
| | `- note: reference to instance method 'withUnsafeBytes' involves unsafe type 'UnsafeRawBufferPointer'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
11 | let target = unsafe UnsafeMutableRawPointer(
12 | buffer.baseAddress.unsafelyUnwrapped
[#StrictMemorySafety]: <https://docs.swift.org/compiler/documentation/diagnostics/strict-memory-safety>
[164/185] Compiling SwiftIDNA +OutputSpan.swift
/host/spi-builder-workspace/Sources/SwiftIDNA/+Array.swift:7:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
5 | package init(copying span: Span<Element>) {
6 | unsafe self.init(unsafeUninitializedCapacity: span.count) { buffer, initializedCount in
7 | span.withUnsafeBytes { spanPtr in
| | | `- note: argument #0 in call to instance method 'withUnsafeBytes' has unsafe type '(UnsafeRawBufferPointer) -> ()'
| | `- note: reference to instance method 'withUnsafeBytes' involves unsafe type 'UnsafeRawBufferPointer'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
8 | let rawBuffer = UnsafeMutableRawBufferPointer(buffer)
9 | unsafe rawBuffer.copyMemory(from: spanPtr)
/host/spi-builder-workspace/Sources/SwiftIDNA/+OutputSpan.swift:10:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
8 | let usedCapacity = self.count
9 | unsafe self.withUnsafeMutableBufferPointer { buffer, initializedCount in
10 | span.withUnsafeBytes { spanPtr in
| | | `- note: argument #0 in call to instance method 'withUnsafeBytes' has unsafe type '(UnsafeRawBufferPointer) -> ()'
| | `- note: reference to instance method 'withUnsafeBytes' involves unsafe type 'UnsafeRawBufferPointer'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
11 | let target = unsafe UnsafeMutableRawPointer(
12 | buffer.baseAddress.unsafelyUnwrapped
[#StrictMemorySafety]: <https://docs.swift.org/compiler/documentation/diagnostics/strict-memory-safety>
[165/185] Compiling SwiftIDNA +Span.swift
/host/spi-builder-workspace/Sources/SwiftIDNA/+Array.swift:7:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
5 | package init(copying span: Span<Element>) {
6 | unsafe self.init(unsafeUninitializedCapacity: span.count) { buffer, initializedCount in
7 | span.withUnsafeBytes { spanPtr in
| | | `- note: argument #0 in call to instance method 'withUnsafeBytes' has unsafe type '(UnsafeRawBufferPointer) -> ()'
| | `- note: reference to instance method 'withUnsafeBytes' involves unsafe type 'UnsafeRawBufferPointer'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
8 | let rawBuffer = UnsafeMutableRawBufferPointer(buffer)
9 | unsafe rawBuffer.copyMemory(from: spanPtr)
/host/spi-builder-workspace/Sources/SwiftIDNA/+OutputSpan.swift:10:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
8 | let usedCapacity = self.count
9 | unsafe self.withUnsafeMutableBufferPointer { buffer, initializedCount in
10 | span.withUnsafeBytes { spanPtr in
| | | `- note: argument #0 in call to instance method 'withUnsafeBytes' has unsafe type '(UnsafeRawBufferPointer) -> ()'
| | `- note: reference to instance method 'withUnsafeBytes' involves unsafe type 'UnsafeRawBufferPointer'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
11 | let target = unsafe UnsafeMutableRawPointer(
12 | buffer.baseAddress.unsafelyUnwrapped
[#StrictMemorySafety]: <https://docs.swift.org/compiler/documentation/diagnostics/strict-memory-safety>
[166/185] Compiling SwiftIDNA IDNA.ConversionResult.swift
/host/spi-builder-workspace/Sources/SwiftIDNA/IDNA.MappingErrors.swift:47:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
45 | var errors = [MappingError]()
46 | errors.reserveCapacity(self.errors.count)
47 | self.errors.span.withUnsafeBufferPointer { spanPtr in
| | | `- note: argument #0 in call to instance method 'withUnsafeBufferPointer' has unsafe type '(UnsafeBufferPointer<IDNA.MappingError>) -> ()'
| | `- note: reference to instance method 'withUnsafeBufferPointer' involves unsafe type 'UnsafeBufferPointer<IDNA.MappingError>'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
48 | unsafe errors.append(contentsOf: spanPtr)
49 | }
[#StrictMemorySafety]: <https://docs.swift.org/compiler/documentation/diagnostics/strict-memory-safety>
[167/185] Compiling SwiftIDNA IDNA.MappingErrors.swift
/host/spi-builder-workspace/Sources/SwiftIDNA/IDNA.MappingErrors.swift:47:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
45 | var errors = [MappingError]()
46 | errors.reserveCapacity(self.errors.count)
47 | self.errors.span.withUnsafeBufferPointer { spanPtr in
| | | `- note: argument #0 in call to instance method 'withUnsafeBufferPointer' has unsafe type '(UnsafeBufferPointer<IDNA.MappingError>) -> ()'
| | `- note: reference to instance method 'withUnsafeBufferPointer' involves unsafe type 'UnsafeBufferPointer<IDNA.MappingError>'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
48 | unsafe errors.append(contentsOf: spanPtr)
49 | }
[#StrictMemorySafety]: <https://docs.swift.org/compiler/documentation/diagnostics/strict-memory-safety>
[168/185] Compiling SwiftIDNA IDNA.swift
/host/spi-builder-workspace/Sources/SwiftIDNA/IDNA.MappingErrors.swift:47:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
45 | var errors = [MappingError]()
46 | errors.reserveCapacity(self.errors.count)
47 | self.errors.span.withUnsafeBufferPointer { spanPtr in
| | | `- note: argument #0 in call to instance method 'withUnsafeBufferPointer' has unsafe type '(UnsafeBufferPointer<IDNA.MappingError>) -> ()'
| | `- note: reference to instance method 'withUnsafeBufferPointer' involves unsafe type 'UnsafeBufferPointer<IDNA.MappingError>'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
48 | unsafe errors.append(contentsOf: spanPtr)
49 | }
[#StrictMemorySafety]: <https://docs.swift.org/compiler/documentation/diagnostics/strict-memory-safety>
[169/185] Compiling SwiftIDNA IDNAMapping.swift
[170/185] Compiling SwiftIDNA IDNA_API.swift
[171/185] Compiling SwiftIDNA IDNA_Impl_assumingUnsanitized.swift
[172/185] Compiling SwiftIDNA +String.swift
/host/spi-builder-workspace/Sources/SwiftIDNA/+String.swift:10:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
8 | self.init(copying: utf8Span)
9 | } else if #available(SwiftStdlib 5.3, *) {
10 | self.init(unsafeUninitializedCapacity: span.count) { buffer in
| | | `- note: argument 'initializingUTF8With' in call to initializer 'init' has unsafe type '(UnsafeMutableBufferPointer<UInt8>) throws -> Int'
| | `- note: reference to initializer 'init(unsafeUninitializedCapacity:initializingUTF8With:)' involves unsafe type 'UnsafeMutableBufferPointer<UInt8>'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
11 | span.withUnsafeBytes { spanPtr in
12 | let rawBuffer = UnsafeMutableRawBufferPointer(buffer)
/host/spi-builder-workspace/Sources/SwiftIDNA/+String.swift:11:17: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
9 | } else if #available(SwiftStdlib 5.3, *) {
10 | self.init(unsafeUninitializedCapacity: span.count) { buffer in
11 | span.withUnsafeBytes { spanPtr in
| | | `- note: argument #0 in call to instance method 'withUnsafeBytes' has unsafe type '(UnsafeRawBufferPointer) -> ()'
| | `- note: reference to instance method 'withUnsafeBytes' involves unsafe type 'UnsafeRawBufferPointer'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
12 | let rawBuffer = UnsafeMutableRawBufferPointer(buffer)
13 | unsafe rawBuffer.copyMemory(from: spanPtr)
/host/spi-builder-workspace/Sources/SwiftIDNA/+String.swift:21:17: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
19 | unsafeUninitializedCapacity: span.count
20 | ) { buffer, initializedCount in
21 | span.withUnsafeBytes { spanPtr in
| | | `- note: argument #0 in call to instance method 'withUnsafeBytes' has unsafe type '(UnsafeRawBufferPointer) -> ()'
| | `- note: reference to instance method 'withUnsafeBytes' involves unsafe type 'UnsafeRawBufferPointer'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
22 | let rawBuffer = UnsafeMutableRawBufferPointer(buffer)
23 | unsafe rawBuffer.copyMemory(from: spanPtr)
/host/spi-builder-workspace/Sources/SwiftIDNA/+String.swift:39:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
37 | self.init(copying: utf8Span)
38 | } else if #available(SwiftStdlib 5.3, *) {
39 | self.init(unsafeUninitializedCapacity: span.count) { buffer in
| | | `- note: argument 'initializingUTF8With' in call to initializer 'init' has unsafe type '(UnsafeMutableBufferPointer<UInt8>) throws -> Int'
| | `- note: reference to initializer 'init(unsafeUninitializedCapacity:initializingUTF8With:)' involves unsafe type 'UnsafeMutableBufferPointer<UInt8>'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
40 | span.withUnsafeBytes { spanPtr in
41 | let rawBuffer = UnsafeMutableRawBufferPointer(buffer)
/host/spi-builder-workspace/Sources/SwiftIDNA/+String.swift:40:17: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
38 | } else if #available(SwiftStdlib 5.3, *) {
39 | self.init(unsafeUninitializedCapacity: span.count) { buffer in
40 | span.withUnsafeBytes { spanPtr in
| | | `- note: argument #0 in call to instance method 'withUnsafeBytes' has unsafe type '(UnsafeRawBufferPointer) -> ()'
| | `- note: reference to instance method 'withUnsafeBytes' involves unsafe type 'UnsafeRawBufferPointer'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
41 | let rawBuffer = UnsafeMutableRawBufferPointer(buffer)
42 | unsafe rawBuffer.copyMemory(from: spanPtr)
/host/spi-builder-workspace/Sources/SwiftIDNA/+String.swift:50:17: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
48 | unsafeUninitializedCapacity: span.count
49 | ) { buffer, initializedCount in
50 | span.withUnsafeBytes { spanPtr in
| | | `- note: argument #0 in call to instance method 'withUnsafeBytes' has unsafe type '(UnsafeRawBufferPointer) -> ()'
| | `- note: reference to instance method 'withUnsafeBytes' involves unsafe type 'UnsafeRawBufferPointer'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
51 | let rawBuffer = UnsafeMutableRawBufferPointer(buffer)
52 | unsafe rawBuffer.copyMemory(from: spanPtr)
/host/spi-builder-workspace/Sources/SwiftIDNA/+String.swift:68:29: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
66 | /// Fast path: Currently always the case for non-Darwin.
67 | /// On Darwin, always the case unless for some objc-bridged strings.
68 | if let fastResult = self.utf8.withContiguousStorageIfAvailable({ buffer in
| | | `- note: argument #0 in call to instance method 'withContiguousStorageIfAvailable' has unsafe type '(UnsafeBufferPointer<String.UTF8View.Element>) throws -> Result<T, E>' (aka '(UnsafeBufferPointer<UInt8>) throws -> Result<T, E>')
| | `- note: reference to instance method 'withContiguousStorageIfAvailable' involves unsafe type 'UnsafeBufferPointer<String.UTF8View.Element>' (aka 'UnsafeBufferPointer<UInt8>')
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
69 | Result(catching: { () throws(E) -> T in
70 | try body(unsafe buffer.span)
/host/spi-builder-workspace/Sources/SwiftIDNA/+String.swift:135:9: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
133 | ) throws -> Int
134 | ) rethrows {
135 | try self.init(unsafeUninitializedCapacity: capacity) { buffer in
| | | `- note: argument 'initializingUTF8With' in call to initializer 'init' has unsafe type '(UnsafeMutableBufferPointer<UInt8>) throws -> Int'
| | `- note: reference to initializer 'init(unsafeUninitializedCapacity:initializingUTF8With:)' involves unsafe type 'UnsafeMutableBufferPointer<UInt8>'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
136 | unsafe try initializer(buffer)
137 | }
/host/spi-builder-workspace/Sources/SwiftIDNA/Collections/DecodedUnicodeScalars.swift:117:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
115 | @inlinable
116 | func withUnsafeScalarValues(_ block: (Span<UInt32>) -> Void) {
117 | self.scalars.withUnsafeBufferPointer { buffer -> Void in
| | | `- note: argument #0 in call to instance method 'withUnsafeBufferPointer' has unsafe type '(UnsafeBufferPointer<UnicodeScalarValue>) -> Void'
| | `- note: reference to instance method 'withUnsafeBufferPointer' involves unsafe type 'UnsafeBufferPointer<UnicodeScalarValue>'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
118 | guard let base = buffer.baseAddress else {
119 | return
[#StrictMemorySafety]: <https://docs.swift.org/compiler/documentation/diagnostics/strict-memory-safety>
[173/185] Compiling SwiftIDNA ByteCheck+IDNA.swift
/host/spi-builder-workspace/Sources/SwiftIDNA/+String.swift:10:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
8 | self.init(copying: utf8Span)
9 | } else if #available(SwiftStdlib 5.3, *) {
10 | self.init(unsafeUninitializedCapacity: span.count) { buffer in
| | | `- note: argument 'initializingUTF8With' in call to initializer 'init' has unsafe type '(UnsafeMutableBufferPointer<UInt8>) throws -> Int'
| | `- note: reference to initializer 'init(unsafeUninitializedCapacity:initializingUTF8With:)' involves unsafe type 'UnsafeMutableBufferPointer<UInt8>'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
11 | span.withUnsafeBytes { spanPtr in
12 | let rawBuffer = UnsafeMutableRawBufferPointer(buffer)
/host/spi-builder-workspace/Sources/SwiftIDNA/+String.swift:11:17: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
9 | } else if #available(SwiftStdlib 5.3, *) {
10 | self.init(unsafeUninitializedCapacity: span.count) { buffer in
11 | span.withUnsafeBytes { spanPtr in
| | | `- note: argument #0 in call to instance method 'withUnsafeBytes' has unsafe type '(UnsafeRawBufferPointer) -> ()'
| | `- note: reference to instance method 'withUnsafeBytes' involves unsafe type 'UnsafeRawBufferPointer'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
12 | let rawBuffer = UnsafeMutableRawBufferPointer(buffer)
13 | unsafe rawBuffer.copyMemory(from: spanPtr)
/host/spi-builder-workspace/Sources/SwiftIDNA/+String.swift:21:17: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
19 | unsafeUninitializedCapacity: span.count
20 | ) { buffer, initializedCount in
21 | span.withUnsafeBytes { spanPtr in
| | | `- note: argument #0 in call to instance method 'withUnsafeBytes' has unsafe type '(UnsafeRawBufferPointer) -> ()'
| | `- note: reference to instance method 'withUnsafeBytes' involves unsafe type 'UnsafeRawBufferPointer'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
22 | let rawBuffer = UnsafeMutableRawBufferPointer(buffer)
23 | unsafe rawBuffer.copyMemory(from: spanPtr)
/host/spi-builder-workspace/Sources/SwiftIDNA/+String.swift:39:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
37 | self.init(copying: utf8Span)
38 | } else if #available(SwiftStdlib 5.3, *) {
39 | self.init(unsafeUninitializedCapacity: span.count) { buffer in
| | | `- note: argument 'initializingUTF8With' in call to initializer 'init' has unsafe type '(UnsafeMutableBufferPointer<UInt8>) throws -> Int'
| | `- note: reference to initializer 'init(unsafeUninitializedCapacity:initializingUTF8With:)' involves unsafe type 'UnsafeMutableBufferPointer<UInt8>'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
40 | span.withUnsafeBytes { spanPtr in
41 | let rawBuffer = UnsafeMutableRawBufferPointer(buffer)
/host/spi-builder-workspace/Sources/SwiftIDNA/+String.swift:40:17: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
38 | } else if #available(SwiftStdlib 5.3, *) {
39 | self.init(unsafeUninitializedCapacity: span.count) { buffer in
40 | span.withUnsafeBytes { spanPtr in
| | | `- note: argument #0 in call to instance method 'withUnsafeBytes' has unsafe type '(UnsafeRawBufferPointer) -> ()'
| | `- note: reference to instance method 'withUnsafeBytes' involves unsafe type 'UnsafeRawBufferPointer'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
41 | let rawBuffer = UnsafeMutableRawBufferPointer(buffer)
42 | unsafe rawBuffer.copyMemory(from: spanPtr)
/host/spi-builder-workspace/Sources/SwiftIDNA/+String.swift:50:17: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
48 | unsafeUninitializedCapacity: span.count
49 | ) { buffer, initializedCount in
50 | span.withUnsafeBytes { spanPtr in
| | | `- note: argument #0 in call to instance method 'withUnsafeBytes' has unsafe type '(UnsafeRawBufferPointer) -> ()'
| | `- note: reference to instance method 'withUnsafeBytes' involves unsafe type 'UnsafeRawBufferPointer'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
51 | let rawBuffer = UnsafeMutableRawBufferPointer(buffer)
52 | unsafe rawBuffer.copyMemory(from: spanPtr)
/host/spi-builder-workspace/Sources/SwiftIDNA/+String.swift:68:29: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
66 | /// Fast path: Currently always the case for non-Darwin.
67 | /// On Darwin, always the case unless for some objc-bridged strings.
68 | if let fastResult = self.utf8.withContiguousStorageIfAvailable({ buffer in
| | | `- note: argument #0 in call to instance method 'withContiguousStorageIfAvailable' has unsafe type '(UnsafeBufferPointer<String.UTF8View.Element>) throws -> Result<T, E>' (aka '(UnsafeBufferPointer<UInt8>) throws -> Result<T, E>')
| | `- note: reference to instance method 'withContiguousStorageIfAvailable' involves unsafe type 'UnsafeBufferPointer<String.UTF8View.Element>' (aka 'UnsafeBufferPointer<UInt8>')
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
69 | Result(catching: { () throws(E) -> T in
70 | try body(unsafe buffer.span)
/host/spi-builder-workspace/Sources/SwiftIDNA/+String.swift:135:9: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
133 | ) throws -> Int
134 | ) rethrows {
135 | try self.init(unsafeUninitializedCapacity: capacity) { buffer in
| | | `- note: argument 'initializingUTF8With' in call to initializer 'init' has unsafe type '(UnsafeMutableBufferPointer<UInt8>) throws -> Int'
| | `- note: reference to initializer 'init(unsafeUninitializedCapacity:initializingUTF8With:)' involves unsafe type 'UnsafeMutableBufferPointer<UInt8>'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
136 | unsafe try initializer(buffer)
137 | }
/host/spi-builder-workspace/Sources/SwiftIDNA/Collections/DecodedUnicodeScalars.swift:117:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
115 | @inlinable
116 | func withUnsafeScalarValues(_ block: (Span<UInt32>) -> Void) {
117 | self.scalars.withUnsafeBufferPointer { buffer -> Void in
| | | `- note: argument #0 in call to instance method 'withUnsafeBufferPointer' has unsafe type '(UnsafeBufferPointer<UnicodeScalarValue>) -> Void'
| | `- note: reference to instance method 'withUnsafeBufferPointer' involves unsafe type 'UnsafeBufferPointer<UnicodeScalarValue>'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
118 | guard let base = buffer.baseAddress else {
119 | return
[#StrictMemorySafety]: <https://docs.swift.org/compiler/documentation/diagnostics/strict-memory-safety>
[174/185] Compiling SwiftIDNA DecodedUnicodeScalars.swift
/host/spi-builder-workspace/Sources/SwiftIDNA/+String.swift:10:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
8 | self.init(copying: utf8Span)
9 | } else if #available(SwiftStdlib 5.3, *) {
10 | self.init(unsafeUninitializedCapacity: span.count) { buffer in
| | | `- note: argument 'initializingUTF8With' in call to initializer 'init' has unsafe type '(UnsafeMutableBufferPointer<UInt8>) throws -> Int'
| | `- note: reference to initializer 'init(unsafeUninitializedCapacity:initializingUTF8With:)' involves unsafe type 'UnsafeMutableBufferPointer<UInt8>'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
11 | span.withUnsafeBytes { spanPtr in
12 | let rawBuffer = UnsafeMutableRawBufferPointer(buffer)
/host/spi-builder-workspace/Sources/SwiftIDNA/+String.swift:11:17: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
9 | } else if #available(SwiftStdlib 5.3, *) {
10 | self.init(unsafeUninitializedCapacity: span.count) { buffer in
11 | span.withUnsafeBytes { spanPtr in
| | | `- note: argument #0 in call to instance method 'withUnsafeBytes' has unsafe type '(UnsafeRawBufferPointer) -> ()'
| | `- note: reference to instance method 'withUnsafeBytes' involves unsafe type 'UnsafeRawBufferPointer'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
12 | let rawBuffer = UnsafeMutableRawBufferPointer(buffer)
13 | unsafe rawBuffer.copyMemory(from: spanPtr)
/host/spi-builder-workspace/Sources/SwiftIDNA/+String.swift:21:17: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
19 | unsafeUninitializedCapacity: span.count
20 | ) { buffer, initializedCount in
21 | span.withUnsafeBytes { spanPtr in
| | | `- note: argument #0 in call to instance method 'withUnsafeBytes' has unsafe type '(UnsafeRawBufferPointer) -> ()'
| | `- note: reference to instance method 'withUnsafeBytes' involves unsafe type 'UnsafeRawBufferPointer'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
22 | let rawBuffer = UnsafeMutableRawBufferPointer(buffer)
23 | unsafe rawBuffer.copyMemory(from: spanPtr)
/host/spi-builder-workspace/Sources/SwiftIDNA/+String.swift:39:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
37 | self.init(copying: utf8Span)
38 | } else if #available(SwiftStdlib 5.3, *) {
39 | self.init(unsafeUninitializedCapacity: span.count) { buffer in
| | | `- note: argument 'initializingUTF8With' in call to initializer 'init' has unsafe type '(UnsafeMutableBufferPointer<UInt8>) throws -> Int'
| | `- note: reference to initializer 'init(unsafeUninitializedCapacity:initializingUTF8With:)' involves unsafe type 'UnsafeMutableBufferPointer<UInt8>'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
40 | span.withUnsafeBytes { spanPtr in
41 | let rawBuffer = UnsafeMutableRawBufferPointer(buffer)
/host/spi-builder-workspace/Sources/SwiftIDNA/+String.swift:40:17: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
38 | } else if #available(SwiftStdlib 5.3, *) {
39 | self.init(unsafeUninitializedCapacity: span.count) { buffer in
40 | span.withUnsafeBytes { spanPtr in
| | | `- note: argument #0 in call to instance method 'withUnsafeBytes' has unsafe type '(UnsafeRawBufferPointer) -> ()'
| | `- note: reference to instance method 'withUnsafeBytes' involves unsafe type 'UnsafeRawBufferPointer'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
41 | let rawBuffer = UnsafeMutableRawBufferPointer(buffer)
42 | unsafe rawBuffer.copyMemory(from: spanPtr)
/host/spi-builder-workspace/Sources/SwiftIDNA/+String.swift:50:17: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
48 | unsafeUninitializedCapacity: span.count
49 | ) { buffer, initializedCount in
50 | span.withUnsafeBytes { spanPtr in
| | | `- note: argument #0 in call to instance method 'withUnsafeBytes' has unsafe type '(UnsafeRawBufferPointer) -> ()'
| | `- note: reference to instance method 'withUnsafeBytes' involves unsafe type 'UnsafeRawBufferPointer'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
51 | let rawBuffer = UnsafeMutableRawBufferPointer(buffer)
52 | unsafe rawBuffer.copyMemory(from: spanPtr)
/host/spi-builder-workspace/Sources/SwiftIDNA/+String.swift:68:29: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
66 | /// Fast path: Currently always the case for non-Darwin.
67 | /// On Darwin, always the case unless for some objc-bridged strings.
68 | if let fastResult = self.utf8.withContiguousStorageIfAvailable({ buffer in
| | | `- note: argument #0 in call to instance method 'withContiguousStorageIfAvailable' has unsafe type '(UnsafeBufferPointer<String.UTF8View.Element>) throws -> Result<T, E>' (aka '(UnsafeBufferPointer<UInt8>) throws -> Result<T, E>')
| | `- note: reference to instance method 'withContiguousStorageIfAvailable' involves unsafe type 'UnsafeBufferPointer<String.UTF8View.Element>' (aka 'UnsafeBufferPointer<UInt8>')
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
69 | Result(catching: { () throws(E) -> T in
70 | try body(unsafe buffer.span)
/host/spi-builder-workspace/Sources/SwiftIDNA/+String.swift:135:9: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
133 | ) throws -> Int
134 | ) rethrows {
135 | try self.init(unsafeUninitializedCapacity: capacity) { buffer in
| | | `- note: argument 'initializingUTF8With' in call to initializer 'init' has unsafe type '(UnsafeMutableBufferPointer<UInt8>) throws -> Int'
| | `- note: reference to initializer 'init(unsafeUninitializedCapacity:initializingUTF8With:)' involves unsafe type 'UnsafeMutableBufferPointer<UInt8>'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
136 | unsafe try initializer(buffer)
137 | }
/host/spi-builder-workspace/Sources/SwiftIDNA/Collections/DecodedUnicodeScalars.swift:117:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
115 | @inlinable
116 | func withUnsafeScalarValues(_ block: (Span<UInt32>) -> Void) {
117 | self.scalars.withUnsafeBufferPointer { buffer -> Void in
| | | `- note: argument #0 in call to instance method 'withUnsafeBufferPointer' has unsafe type '(UnsafeBufferPointer<UnicodeScalarValue>) -> Void'
| | `- note: reference to instance method 'withUnsafeBufferPointer' involves unsafe type 'UnsafeBufferPointer<UnicodeScalarValue>'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
118 | guard let base = buffer.baseAddress else {
119 | return
[#StrictMemorySafety]: <https://docs.swift.org/compiler/documentation/diagnostics/strict-memory-safety>
[175/185] Compiling SwiftIDNA IDNAUnicodeScalarView.swift
/host/spi-builder-workspace/Sources/SwiftIDNA/+String.swift:10:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
8 | self.init(copying: utf8Span)
9 | } else if #available(SwiftStdlib 5.3, *) {
10 | self.init(unsafeUninitializedCapacity: span.count) { buffer in
| | | `- note: argument 'initializingUTF8With' in call to initializer 'init' has unsafe type '(UnsafeMutableBufferPointer<UInt8>) throws -> Int'
| | `- note: reference to initializer 'init(unsafeUninitializedCapacity:initializingUTF8With:)' involves unsafe type 'UnsafeMutableBufferPointer<UInt8>'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
11 | span.withUnsafeBytes { spanPtr in
12 | let rawBuffer = UnsafeMutableRawBufferPointer(buffer)
/host/spi-builder-workspace/Sources/SwiftIDNA/+String.swift:11:17: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
9 | } else if #available(SwiftStdlib 5.3, *) {
10 | self.init(unsafeUninitializedCapacity: span.count) { buffer in
11 | span.withUnsafeBytes { spanPtr in
| | | `- note: argument #0 in call to instance method 'withUnsafeBytes' has unsafe type '(UnsafeRawBufferPointer) -> ()'
| | `- note: reference to instance method 'withUnsafeBytes' involves unsafe type 'UnsafeRawBufferPointer'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
12 | let rawBuffer = UnsafeMutableRawBufferPointer(buffer)
13 | unsafe rawBuffer.copyMemory(from: spanPtr)
/host/spi-builder-workspace/Sources/SwiftIDNA/+String.swift:21:17: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
19 | unsafeUninitializedCapacity: span.count
20 | ) { buffer, initializedCount in
21 | span.withUnsafeBytes { spanPtr in
| | | `- note: argument #0 in call to instance method 'withUnsafeBytes' has unsafe type '(UnsafeRawBufferPointer) -> ()'
| | `- note: reference to instance method 'withUnsafeBytes' involves unsafe type 'UnsafeRawBufferPointer'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
22 | let rawBuffer = UnsafeMutableRawBufferPointer(buffer)
23 | unsafe rawBuffer.copyMemory(from: spanPtr)
/host/spi-builder-workspace/Sources/SwiftIDNA/+String.swift:39:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
37 | self.init(copying: utf8Span)
38 | } else if #available(SwiftStdlib 5.3, *) {
39 | self.init(unsafeUninitializedCapacity: span.count) { buffer in
| | | `- note: argument 'initializingUTF8With' in call to initializer 'init' has unsafe type '(UnsafeMutableBufferPointer<UInt8>) throws -> Int'
| | `- note: reference to initializer 'init(unsafeUninitializedCapacity:initializingUTF8With:)' involves unsafe type 'UnsafeMutableBufferPointer<UInt8>'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
40 | span.withUnsafeBytes { spanPtr in
41 | let rawBuffer = UnsafeMutableRawBufferPointer(buffer)
/host/spi-builder-workspace/Sources/SwiftIDNA/+String.swift:40:17: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
38 | } else if #available(SwiftStdlib 5.3, *) {
39 | self.init(unsafeUninitializedCapacity: span.count) { buffer in
40 | span.withUnsafeBytes { spanPtr in
| | | `- note: argument #0 in call to instance method 'withUnsafeBytes' has unsafe type '(UnsafeRawBufferPointer) -> ()'
| | `- note: reference to instance method 'withUnsafeBytes' involves unsafe type 'UnsafeRawBufferPointer'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
41 | let rawBuffer = UnsafeMutableRawBufferPointer(buffer)
42 | unsafe rawBuffer.copyMemory(from: spanPtr)
/host/spi-builder-workspace/Sources/SwiftIDNA/+String.swift:50:17: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
48 | unsafeUninitializedCapacity: span.count
49 | ) { buffer, initializedCount in
50 | span.withUnsafeBytes { spanPtr in
| | | `- note: argument #0 in call to instance method 'withUnsafeBytes' has unsafe type '(UnsafeRawBufferPointer) -> ()'
| | `- note: reference to instance method 'withUnsafeBytes' involves unsafe type 'UnsafeRawBufferPointer'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
51 | let rawBuffer = UnsafeMutableRawBufferPointer(buffer)
52 | unsafe rawBuffer.copyMemory(from: spanPtr)
/host/spi-builder-workspace/Sources/SwiftIDNA/+String.swift:68:29: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
66 | /// Fast path: Currently always the case for non-Darwin.
67 | /// On Darwin, always the case unless for some objc-bridged strings.
68 | if let fastResult = self.utf8.withContiguousStorageIfAvailable({ buffer in
| | | `- note: argument #0 in call to instance method 'withContiguousStorageIfAvailable' has unsafe type '(UnsafeBufferPointer<String.UTF8View.Element>) throws -> Result<T, E>' (aka '(UnsafeBufferPointer<UInt8>) throws -> Result<T, E>')
| | `- note: reference to instance method 'withContiguousStorageIfAvailable' involves unsafe type 'UnsafeBufferPointer<String.UTF8View.Element>' (aka 'UnsafeBufferPointer<UInt8>')
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
69 | Result(catching: { () throws(E) -> T in
70 | try body(unsafe buffer.span)
/host/spi-builder-workspace/Sources/SwiftIDNA/+String.swift:135:9: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
133 | ) throws -> Int
134 | ) rethrows {
135 | try self.init(unsafeUninitializedCapacity: capacity) { buffer in
| | | `- note: argument 'initializingUTF8With' in call to initializer 'init' has unsafe type '(UnsafeMutableBufferPointer<UInt8>) throws -> Int'
| | `- note: reference to initializer 'init(unsafeUninitializedCapacity:initializingUTF8With:)' involves unsafe type 'UnsafeMutableBufferPointer<UInt8>'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
136 | unsafe try initializer(buffer)
137 | }
/host/spi-builder-workspace/Sources/SwiftIDNA/Collections/DecodedUnicodeScalars.swift:117:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
115 | @inlinable
116 | func withUnsafeScalarValues(_ block: (Span<UInt32>) -> Void) {
117 | self.scalars.withUnsafeBufferPointer { buffer -> Void in
| | | `- note: argument #0 in call to instance method 'withUnsafeBufferPointer' has unsafe type '(UnsafeBufferPointer<UnicodeScalarValue>) -> Void'
| | `- note: reference to instance method 'withUnsafeBufferPointer' involves unsafe type 'UnsafeBufferPointer<UnicodeScalarValue>'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
118 | guard let base = buffer.baseAddress else {
119 | return
[#StrictMemorySafety]: <https://docs.swift.org/compiler/documentation/diagnostics/strict-memory-safety>
[176/185] Compiling SwiftIDNA IDNA_Impl_assumingValidUTF8.swift
/host/spi-builder-workspace/Sources/SwiftIDNA/NFCNormalization.swift:71:17: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
69 | var isEqualToCurrent = 1
70 | while let (scalarUTF8Length, bytes) = iterator.branchlessNext(in: scalarsSpan) {
71 | withUnsafeBytes(of: bytes) { bytesPtr in
| | `- note: argument #1 in call to global function 'withUnsafeBytes' has unsafe type '(UnsafeRawBufferPointer) -> ()'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
72 | for idx in 0..<scalarUTF8Length {
73 | let uncheckedSpanIdx = utf8Count &+ idx
/host/spi-builder-workspace/Sources/SwiftIDNA/NFCNormalization.swift:126:9: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
124 | /// NFC form at most 3 UTF-8 bytes per input UTF-8 byte. The generator verifies both
125 | /// bounds on every table regeneration.
126 | withUnsafeTemporaryAllocation(
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
127 | of: UInt32.self,
128 | capacity: 2 &* span.count
129 | ) { scalarsBuffer in
| `- note: argument #2 in call to global function 'withUnsafeTemporaryAllocation' has unsafe type '(UnsafeMutableBufferPointer<UInt32>) -> R'
130 | var scalarsCount = 0
131 | /// For Normalization Form C, we need to first go through the decomposition step:
[#StrictMemorySafety]: <https://docs.swift.org/compiler/documentation/diagnostics/strict-memory-safety>
[177/185] Compiling SwiftIDNA NFCNormalization.swift
/host/spi-builder-workspace/Sources/SwiftIDNA/NFCNormalization.swift:71:17: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
69 | var isEqualToCurrent = 1
70 | while let (scalarUTF8Length, bytes) = iterator.branchlessNext(in: scalarsSpan) {
71 | withUnsafeBytes(of: bytes) { bytesPtr in
| | `- note: argument #1 in call to global function 'withUnsafeBytes' has unsafe type '(UnsafeRawBufferPointer) -> ()'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
72 | for idx in 0..<scalarUTF8Length {
73 | let uncheckedSpanIdx = utf8Count &+ idx
/host/spi-builder-workspace/Sources/SwiftIDNA/NFCNormalization.swift:126:9: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
124 | /// NFC form at most 3 UTF-8 bytes per input UTF-8 byte. The generator verifies both
125 | /// bounds on every table regeneration.
126 | withUnsafeTemporaryAllocation(
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
127 | of: UInt32.self,
128 | capacity: 2 &* span.count
129 | ) { scalarsBuffer in
| `- note: argument #2 in call to global function 'withUnsafeTemporaryAllocation' has unsafe type '(UnsafeMutableBufferPointer<UInt32>) -> R'
130 | var scalarsCount = 0
131 | /// For Normalization Form C, we need to first go through the decomposition step:
[#StrictMemorySafety]: <https://docs.swift.org/compiler/documentation/diagnostics/strict-memory-safety>
[178/185] Compiling SwiftIDNA NFCScalarInfo.swift
/host/spi-builder-workspace/Sources/SwiftIDNA/NFCNormalization.swift:71:17: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
69 | var isEqualToCurrent = 1
70 | while let (scalarUTF8Length, bytes) = iterator.branchlessNext(in: scalarsSpan) {
71 | withUnsafeBytes(of: bytes) { bytesPtr in
| | `- note: argument #1 in call to global function 'withUnsafeBytes' has unsafe type '(UnsafeRawBufferPointer) -> ()'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
72 | for idx in 0..<scalarUTF8Length {
73 | let uncheckedSpanIdx = utf8Count &+ idx
/host/spi-builder-workspace/Sources/SwiftIDNA/NFCNormalization.swift:126:9: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
124 | /// NFC form at most 3 UTF-8 bytes per input UTF-8 byte. The generator verifies both
125 | /// bounds on every table regeneration.
126 | withUnsafeTemporaryAllocation(
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
127 | of: UInt32.self,
128 | capacity: 2 &* span.count
129 | ) { scalarsBuffer in
| `- note: argument #2 in call to global function 'withUnsafeTemporaryAllocation' has unsafe type '(UnsafeMutableBufferPointer<UInt32>) -> R'
130 | var scalarsCount = 0
131 | /// For Normalization Form C, we need to first go through the decomposition step:
[#StrictMemorySafety]: <https://docs.swift.org/compiler/documentation/diagnostics/strict-memory-safety>
[179/185] Compiling SwiftIDNA Punycode.swift
/host/spi-builder-workspace/Sources/SwiftIDNA/UTF8Checker.swift:31:20: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
29 | let windowSize = Self.windowSize
30 | if count &+ 3 <= windowSize &* 3 {
31 | return withUnsafeTemporaryAllocation(
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
32 | of: UInt8.self,
33 | capacity: windowSize &* 3 &+ 3
34 | ) { paddedBytes in
| `- note: argument #2 in call to global function 'withUnsafeTemporaryAllocation' has unsafe type '(UnsafeMutableBufferPointer<UInt8>) -> Bool'
35 | unsafe paddedBytes.initialize(repeating: 0)
36 | let paddedBytesBuffer = unsafe UnsafeMutableRawBufferPointer(
/host/spi-builder-workspace/Sources/SwiftIDNA/UTF8Checker.swift:39:17: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
37 | rebasing: UnsafeMutableRawBufferPointer(paddedBytes)[3...]
38 | )
39 | bytes.withUnsafeBytes { rawBytes in
| | | `- note: argument #0 in call to instance method 'withUnsafeBytes' has unsafe type '(UnsafeRawBufferPointer) -> ()'
| | `- note: reference to instance method 'withUnsafeBytes' involves unsafe type 'UnsafeRawBufferPointer'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
40 | unsafe paddedBytesBuffer.copyMemory(from: rawBytes)
41 | }
/host/spi-builder-workspace/Sources/SwiftIDNA/UTF8Checker.swift:53:25: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
51 | }
52 |
53 | var errorBits = withUnsafeTemporaryAllocation(
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
54 | of: UInt8.self,
55 | capacity: windowSize &+ 3
56 | ) { headBytes in
| `- note: argument #2 in call to global function 'withUnsafeTemporaryAllocation' has unsafe type '(UnsafeMutableBufferPointer<UInt8>) -> UInt8'
57 | unsafe headBytes.initialize(repeating: 0)
58 | let headBytesBuffer = unsafe UnsafeMutableRawBufferPointer(
/host/spi-builder-workspace/Sources/SwiftIDNA/UTF8Checker.swift:61:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
59 | rebasing: UnsafeMutableRawBufferPointer(headBytes)[3...]
60 | )
61 | bytes.withUnsafeBytes { rawBytes in
| | | `- note: argument #0 in call to instance method 'withUnsafeBytes' has unsafe type '(UnsafeRawBufferPointer) -> ()'
| | `- note: reference to instance method 'withUnsafeBytes' involves unsafe type 'UnsafeRawBufferPointer'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
62 | unsafe headBytesBuffer.copyMemory(
63 | from: UnsafeRawBufferPointer(rebasing: rawBytes[..<windowSize])
[#StrictMemorySafety]: <https://docs.swift.org/compiler/documentation/diagnostics/strict-memory-safety>
[180/185] Compiling SwiftIDNA UTF8Checker.swift
/host/spi-builder-workspace/Sources/SwiftIDNA/UTF8Checker.swift:31:20: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
29 | let windowSize = Self.windowSize
30 | if count &+ 3 <= windowSize &* 3 {
31 | return withUnsafeTemporaryAllocation(
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
32 | of: UInt8.self,
33 | capacity: windowSize &* 3 &+ 3
34 | ) { paddedBytes in
| `- note: argument #2 in call to global function 'withUnsafeTemporaryAllocation' has unsafe type '(UnsafeMutableBufferPointer<UInt8>) -> Bool'
35 | unsafe paddedBytes.initialize(repeating: 0)
36 | let paddedBytesBuffer = unsafe UnsafeMutableRawBufferPointer(
/host/spi-builder-workspace/Sources/SwiftIDNA/UTF8Checker.swift:39:17: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
37 | rebasing: UnsafeMutableRawBufferPointer(paddedBytes)[3...]
38 | )
39 | bytes.withUnsafeBytes { rawBytes in
| | | `- note: argument #0 in call to instance method 'withUnsafeBytes' has unsafe type '(UnsafeRawBufferPointer) -> ()'
| | `- note: reference to instance method 'withUnsafeBytes' involves unsafe type 'UnsafeRawBufferPointer'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
40 | unsafe paddedBytesBuffer.copyMemory(from: rawBytes)
41 | }
/host/spi-builder-workspace/Sources/SwiftIDNA/UTF8Checker.swift:53:25: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
51 | }
52 |
53 | var errorBits = withUnsafeTemporaryAllocation(
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
54 | of: UInt8.self,
55 | capacity: windowSize &+ 3
56 | ) { headBytes in
| `- note: argument #2 in call to global function 'withUnsafeTemporaryAllocation' has unsafe type '(UnsafeMutableBufferPointer<UInt8>) -> UInt8'
57 | unsafe headBytes.initialize(repeating: 0)
58 | let headBytesBuffer = unsafe UnsafeMutableRawBufferPointer(
/host/spi-builder-workspace/Sources/SwiftIDNA/UTF8Checker.swift:61:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
59 | rebasing: UnsafeMutableRawBufferPointer(headBytes)[3...]
60 | )
61 | bytes.withUnsafeBytes { rawBytes in
| | | `- note: argument #0 in call to instance method 'withUnsafeBytes' has unsafe type '(UnsafeRawBufferPointer) -> ()'
| | `- note: reference to instance method 'withUnsafeBytes' involves unsafe type 'UnsafeRawBufferPointer'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
62 | unsafe headBytesBuffer.copyMemory(
63 | from: UnsafeRawBufferPointer(rebasing: rawBytes[..<windowSize])
[#StrictMemorySafety]: <https://docs.swift.org/compiler/documentation/diagnostics/strict-memory-safety>
[181/185] Compiling SwiftIDNA UnicodeScalarValue.swift
/host/spi-builder-workspace/Sources/SwiftIDNA/UTF8Checker.swift:31:20: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
29 | let windowSize = Self.windowSize
30 | if count &+ 3 <= windowSize &* 3 {
31 | return withUnsafeTemporaryAllocation(
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
32 | of: UInt8.self,
33 | capacity: windowSize &* 3 &+ 3
34 | ) { paddedBytes in
| `- note: argument #2 in call to global function 'withUnsafeTemporaryAllocation' has unsafe type '(UnsafeMutableBufferPointer<UInt8>) -> Bool'
35 | unsafe paddedBytes.initialize(repeating: 0)
36 | let paddedBytesBuffer = unsafe UnsafeMutableRawBufferPointer(
/host/spi-builder-workspace/Sources/SwiftIDNA/UTF8Checker.swift:39:17: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
37 | rebasing: UnsafeMutableRawBufferPointer(paddedBytes)[3...]
38 | )
39 | bytes.withUnsafeBytes { rawBytes in
| | | `- note: argument #0 in call to instance method 'withUnsafeBytes' has unsafe type '(UnsafeRawBufferPointer) -> ()'
| | `- note: reference to instance method 'withUnsafeBytes' involves unsafe type 'UnsafeRawBufferPointer'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
40 | unsafe paddedBytesBuffer.copyMemory(from: rawBytes)
41 | }
/host/spi-builder-workspace/Sources/SwiftIDNA/UTF8Checker.swift:53:25: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
51 | }
52 |
53 | var errorBits = withUnsafeTemporaryAllocation(
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
54 | of: UInt8.self,
55 | capacity: windowSize &+ 3
56 | ) { headBytes in
| `- note: argument #2 in call to global function 'withUnsafeTemporaryAllocation' has unsafe type '(UnsafeMutableBufferPointer<UInt8>) -> UInt8'
57 | unsafe headBytes.initialize(repeating: 0)
58 | let headBytesBuffer = unsafe UnsafeMutableRawBufferPointer(
/host/spi-builder-workspace/Sources/SwiftIDNA/UTF8Checker.swift:61:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
59 | rebasing: UnsafeMutableRawBufferPointer(headBytes)[3...]
60 | )
61 | bytes.withUnsafeBytes { rawBytes in
| | | `- note: argument #0 in call to instance method 'withUnsafeBytes' has unsafe type '(UnsafeRawBufferPointer) -> ()'
| | `- note: reference to instance method 'withUnsafeBytes' involves unsafe type 'UnsafeRawBufferPointer'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
62 | unsafe headBytesBuffer.copyMemory(
63 | from: UnsafeRawBufferPointer(rebasing: rawBytes[..<windowSize])
[#StrictMemorySafety]: <https://docs.swift.org/compiler/documentation/diagnostics/strict-memory-safety>
[182/185] Compiling SwiftIDNA LinkedList.swift
/host/spi-builder-workspace/Sources/SwiftIDNA/Collections/SIMDUnicodeScalarDecoder.swift:67:9: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
65 | _ body: (inout SIMDUnicodeScalarDecoder) throws(Failure) -> R
66 | ) throws(Failure) -> R {
67 | try withUnsafeTemporaryAllocation(
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
68 | of: UInt8.self,
69 | capacity: Self.tempBytesSize
70 | ) { tempBytes throws(Failure) -> R in
| `- note: argument #2 in call to global function 'withUnsafeTemporaryAllocation' has unsafe type '(UnsafeMutableBufferPointer<UInt8>) throws(Failure) -> R'
71 | try withUnsafeTemporaryAllocation(
72 | of: UInt8.self,
/host/spi-builder-workspace/Sources/SwiftIDNA/Collections/SIMDUnicodeScalarDecoder.swift:71:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
69 | capacity: Self.tempBytesSize
70 | ) { tempBytes throws(Failure) -> R in
71 | try withUnsafeTemporaryAllocation(
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
72 | of: UInt8.self,
73 | capacity: Self.paddedScalarUTF8LengthsSize
74 | ) { paddedScalarUTF8Lengths throws(Failure) -> R in
| `- note: argument #2 in call to global function 'withUnsafeTemporaryAllocation' has unsafe type '(UnsafeMutableBufferPointer<UInt8>) throws(Failure) -> R'
75 | try withUnsafeTemporaryAllocation(
76 | of: UInt32.self,
/host/spi-builder-workspace/Sources/SwiftIDNA/Collections/SIMDUnicodeScalarDecoder.swift:75:17: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
73 | capacity: Self.paddedScalarUTF8LengthsSize
74 | ) { paddedScalarUTF8Lengths throws(Failure) -> R in
75 | try withUnsafeTemporaryAllocation(
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
76 | of: UInt32.self,
77 | capacity: Self.windowSize
78 | ) { uncheckedScalarValues throws(Failure) -> R in
| `- note: argument #2 in call to global function 'withUnsafeTemporaryAllocation' has unsafe type '(UnsafeMutableBufferPointer<UInt32>) throws(Failure) -> R'
79 | try withUnsafeTemporaryAllocation(
80 | of: UInt8.self,
/host/spi-builder-workspace/Sources/SwiftIDNA/Collections/SIMDUnicodeScalarDecoder.swift:79:21: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
77 | capacity: Self.windowSize
78 | ) { uncheckedScalarValues throws(Failure) -> R in
79 | try withUnsafeTemporaryAllocation(
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
80 | of: UInt8.self,
81 | capacity: Self.scalarStartOffsetsSize
82 | ) { scalarStartOffsets throws(Failure) -> R in
| `- note: argument #2 in call to global function 'withUnsafeTemporaryAllocation' has unsafe type '(UnsafeMutableBufferPointer<UInt8>) throws(Failure) -> R'
83 | unsafe tempBytes.initialize(repeating: 0)
84 | unsafe paddedScalarUTF8Lengths.initialize(repeating: 0)
/host/spi-builder-workspace/Sources/SwiftIDNA/Collections/SIMDUnicodeScalarDecoder.swift:169:9: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
167 | /// `tempBytes` is initialized-memory by above code (`tempBytes.initialize(repeating: 0)`), so it's valid anyway.
168 | /// The pad bytes are not important.
169 | tempBytes.withUnsafeMutableBufferPointer { temp in
| | | `- note: argument #0 in call to instance method 'withUnsafeMutableBufferPointer' has unsafe type '(UnsafeMutableBufferPointer<UInt8>) -> ()'
| | `- note: reference to instance method 'withUnsafeMutableBufferPointer' involves unsafe type 'UnsafeMutableBufferPointer<UInt8>'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
170 | encodedBytes.withUnsafeBufferPointer { encoded in
171 | let rawTemp = UnsafeMutableRawBufferPointer(temp)
/host/spi-builder-workspace/Sources/SwiftIDNA/Collections/SIMDUnicodeScalarDecoder.swift:170:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
168 | /// The pad bytes are not important.
169 | tempBytes.withUnsafeMutableBufferPointer { temp in
170 | encodedBytes.withUnsafeBufferPointer { encoded in
| | | `- note: argument #0 in call to instance method 'withUnsafeBufferPointer' has unsafe type '(UnsafeBufferPointer<UInt8>) -> ()'
| | `- note: reference to instance method 'withUnsafeBufferPointer' involves unsafe type 'UnsafeBufferPointer<UInt8>'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
171 | let rawTemp = UnsafeMutableRawBufferPointer(temp)
172 | let rawEncodedBytes = UnsafeRawBufferPointer(encoded)
/host/spi-builder-workspace/Sources/SwiftIDNA/Collections/TinyBuffer.swift:359:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
357 | _ body: (consuming InlineElements) throws(Failure) -> R
358 | ) throws(Failure) -> R {
359 | try withUnsafeTemporaryAllocation(
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
360 | of: UInt8.self,
361 | capacity: Self.maximumCapacity
362 | ) { alloc throws(Failure) -> R in
| `- note: argument #2 in call to global function 'withUnsafeTemporaryAllocation' has unsafe type '(UnsafeMutableBufferPointer<UInt8>) throws(Failure) -> R'
363 | try body(unsafe InlineElements(buffer: alloc, count: 0))
364 | }
[#StrictMemorySafety]: <https://docs.swift.org/compiler/documentation/diagnostics/strict-memory-safety>
[183/185] Compiling SwiftIDNA SIMDUnicodeScalarDecoder.swift
/host/spi-builder-workspace/Sources/SwiftIDNA/Collections/SIMDUnicodeScalarDecoder.swift:67:9: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
65 | _ body: (inout SIMDUnicodeScalarDecoder) throws(Failure) -> R
66 | ) throws(Failure) -> R {
67 | try withUnsafeTemporaryAllocation(
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
68 | of: UInt8.self,
69 | capacity: Self.tempBytesSize
70 | ) { tempBytes throws(Failure) -> R in
| `- note: argument #2 in call to global function 'withUnsafeTemporaryAllocation' has unsafe type '(UnsafeMutableBufferPointer<UInt8>) throws(Failure) -> R'
71 | try withUnsafeTemporaryAllocation(
72 | of: UInt8.self,
/host/spi-builder-workspace/Sources/SwiftIDNA/Collections/SIMDUnicodeScalarDecoder.swift:71:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
69 | capacity: Self.tempBytesSize
70 | ) { tempBytes throws(Failure) -> R in
71 | try withUnsafeTemporaryAllocation(
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
72 | of: UInt8.self,
73 | capacity: Self.paddedScalarUTF8LengthsSize
74 | ) { paddedScalarUTF8Lengths throws(Failure) -> R in
| `- note: argument #2 in call to global function 'withUnsafeTemporaryAllocation' has unsafe type '(UnsafeMutableBufferPointer<UInt8>) throws(Failure) -> R'
75 | try withUnsafeTemporaryAllocation(
76 | of: UInt32.self,
/host/spi-builder-workspace/Sources/SwiftIDNA/Collections/SIMDUnicodeScalarDecoder.swift:75:17: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
73 | capacity: Self.paddedScalarUTF8LengthsSize
74 | ) { paddedScalarUTF8Lengths throws(Failure) -> R in
75 | try withUnsafeTemporaryAllocation(
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
76 | of: UInt32.self,
77 | capacity: Self.windowSize
78 | ) { uncheckedScalarValues throws(Failure) -> R in
| `- note: argument #2 in call to global function 'withUnsafeTemporaryAllocation' has unsafe type '(UnsafeMutableBufferPointer<UInt32>) throws(Failure) -> R'
79 | try withUnsafeTemporaryAllocation(
80 | of: UInt8.self,
/host/spi-builder-workspace/Sources/SwiftIDNA/Collections/SIMDUnicodeScalarDecoder.swift:79:21: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
77 | capacity: Self.windowSize
78 | ) { uncheckedScalarValues throws(Failure) -> R in
79 | try withUnsafeTemporaryAllocation(
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
80 | of: UInt8.self,
81 | capacity: Self.scalarStartOffsetsSize
82 | ) { scalarStartOffsets throws(Failure) -> R in
| `- note: argument #2 in call to global function 'withUnsafeTemporaryAllocation' has unsafe type '(UnsafeMutableBufferPointer<UInt8>) throws(Failure) -> R'
83 | unsafe tempBytes.initialize(repeating: 0)
84 | unsafe paddedScalarUTF8Lengths.initialize(repeating: 0)
/host/spi-builder-workspace/Sources/SwiftIDNA/Collections/SIMDUnicodeScalarDecoder.swift:169:9: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
167 | /// `tempBytes` is initialized-memory by above code (`tempBytes.initialize(repeating: 0)`), so it's valid anyway.
168 | /// The pad bytes are not important.
169 | tempBytes.withUnsafeMutableBufferPointer { temp in
| | | `- note: argument #0 in call to instance method 'withUnsafeMutableBufferPointer' has unsafe type '(UnsafeMutableBufferPointer<UInt8>) -> ()'
| | `- note: reference to instance method 'withUnsafeMutableBufferPointer' involves unsafe type 'UnsafeMutableBufferPointer<UInt8>'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
170 | encodedBytes.withUnsafeBufferPointer { encoded in
171 | let rawTemp = UnsafeMutableRawBufferPointer(temp)
/host/spi-builder-workspace/Sources/SwiftIDNA/Collections/SIMDUnicodeScalarDecoder.swift:170:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
168 | /// The pad bytes are not important.
169 | tempBytes.withUnsafeMutableBufferPointer { temp in
170 | encodedBytes.withUnsafeBufferPointer { encoded in
| | | `- note: argument #0 in call to instance method 'withUnsafeBufferPointer' has unsafe type '(UnsafeBufferPointer<UInt8>) -> ()'
| | `- note: reference to instance method 'withUnsafeBufferPointer' involves unsafe type 'UnsafeBufferPointer<UInt8>'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
171 | let rawTemp = UnsafeMutableRawBufferPointer(temp)
172 | let rawEncodedBytes = UnsafeRawBufferPointer(encoded)
/host/spi-builder-workspace/Sources/SwiftIDNA/Collections/TinyBuffer.swift:359:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
357 | _ body: (consuming InlineElements) throws(Failure) -> R
358 | ) throws(Failure) -> R {
359 | try withUnsafeTemporaryAllocation(
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
360 | of: UInt8.self,
361 | capacity: Self.maximumCapacity
362 | ) { alloc throws(Failure) -> R in
| `- note: argument #2 in call to global function 'withUnsafeTemporaryAllocation' has unsafe type '(UnsafeMutableBufferPointer<UInt8>) throws(Failure) -> R'
363 | try body(unsafe InlineElements(buffer: alloc, count: 0))
364 | }
[#StrictMemorySafety]: <https://docs.swift.org/compiler/documentation/diagnostics/strict-memory-safety>
[184/185] Compiling SwiftIDNA TinyBuffer.swift
/host/spi-builder-workspace/Sources/SwiftIDNA/Collections/SIMDUnicodeScalarDecoder.swift:67:9: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
65 | _ body: (inout SIMDUnicodeScalarDecoder) throws(Failure) -> R
66 | ) throws(Failure) -> R {
67 | try withUnsafeTemporaryAllocation(
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
68 | of: UInt8.self,
69 | capacity: Self.tempBytesSize
70 | ) { tempBytes throws(Failure) -> R in
| `- note: argument #2 in call to global function 'withUnsafeTemporaryAllocation' has unsafe type '(UnsafeMutableBufferPointer<UInt8>) throws(Failure) -> R'
71 | try withUnsafeTemporaryAllocation(
72 | of: UInt8.self,
/host/spi-builder-workspace/Sources/SwiftIDNA/Collections/SIMDUnicodeScalarDecoder.swift:71:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
69 | capacity: Self.tempBytesSize
70 | ) { tempBytes throws(Failure) -> R in
71 | try withUnsafeTemporaryAllocation(
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
72 | of: UInt8.self,
73 | capacity: Self.paddedScalarUTF8LengthsSize
74 | ) { paddedScalarUTF8Lengths throws(Failure) -> R in
| `- note: argument #2 in call to global function 'withUnsafeTemporaryAllocation' has unsafe type '(UnsafeMutableBufferPointer<UInt8>) throws(Failure) -> R'
75 | try withUnsafeTemporaryAllocation(
76 | of: UInt32.self,
/host/spi-builder-workspace/Sources/SwiftIDNA/Collections/SIMDUnicodeScalarDecoder.swift:75:17: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
73 | capacity: Self.paddedScalarUTF8LengthsSize
74 | ) { paddedScalarUTF8Lengths throws(Failure) -> R in
75 | try withUnsafeTemporaryAllocation(
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
76 | of: UInt32.self,
77 | capacity: Self.windowSize
78 | ) { uncheckedScalarValues throws(Failure) -> R in
| `- note: argument #2 in call to global function 'withUnsafeTemporaryAllocation' has unsafe type '(UnsafeMutableBufferPointer<UInt32>) throws(Failure) -> R'
79 | try withUnsafeTemporaryAllocation(
80 | of: UInt8.self,
/host/spi-builder-workspace/Sources/SwiftIDNA/Collections/SIMDUnicodeScalarDecoder.swift:79:21: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
77 | capacity: Self.windowSize
78 | ) { uncheckedScalarValues throws(Failure) -> R in
79 | try withUnsafeTemporaryAllocation(
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
80 | of: UInt8.self,
81 | capacity: Self.scalarStartOffsetsSize
82 | ) { scalarStartOffsets throws(Failure) -> R in
| `- note: argument #2 in call to global function 'withUnsafeTemporaryAllocation' has unsafe type '(UnsafeMutableBufferPointer<UInt8>) throws(Failure) -> R'
83 | unsafe tempBytes.initialize(repeating: 0)
84 | unsafe paddedScalarUTF8Lengths.initialize(repeating: 0)
/host/spi-builder-workspace/Sources/SwiftIDNA/Collections/SIMDUnicodeScalarDecoder.swift:169:9: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
167 | /// `tempBytes` is initialized-memory by above code (`tempBytes.initialize(repeating: 0)`), so it's valid anyway.
168 | /// The pad bytes are not important.
169 | tempBytes.withUnsafeMutableBufferPointer { temp in
| | | `- note: argument #0 in call to instance method 'withUnsafeMutableBufferPointer' has unsafe type '(UnsafeMutableBufferPointer<UInt8>) -> ()'
| | `- note: reference to instance method 'withUnsafeMutableBufferPointer' involves unsafe type 'UnsafeMutableBufferPointer<UInt8>'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
170 | encodedBytes.withUnsafeBufferPointer { encoded in
171 | let rawTemp = UnsafeMutableRawBufferPointer(temp)
/host/spi-builder-workspace/Sources/SwiftIDNA/Collections/SIMDUnicodeScalarDecoder.swift:170:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
168 | /// The pad bytes are not important.
169 | tempBytes.withUnsafeMutableBufferPointer { temp in
170 | encodedBytes.withUnsafeBufferPointer { encoded in
| | | `- note: argument #0 in call to instance method 'withUnsafeBufferPointer' has unsafe type '(UnsafeBufferPointer<UInt8>) -> ()'
| | `- note: reference to instance method 'withUnsafeBufferPointer' involves unsafe type 'UnsafeBufferPointer<UInt8>'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
171 | let rawTemp = UnsafeMutableRawBufferPointer(temp)
172 | let rawEncodedBytes = UnsafeRawBufferPointer(encoded)
/host/spi-builder-workspace/Sources/SwiftIDNA/Collections/TinyBuffer.swift:359:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
357 | _ body: (consuming InlineElements) throws(Failure) -> R
358 | ) throws(Failure) -> R {
359 | try withUnsafeTemporaryAllocation(
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
360 | of: UInt8.self,
361 | capacity: Self.maximumCapacity
362 | ) { alloc throws(Failure) -> R in
| `- note: argument #2 in call to global function 'withUnsafeTemporaryAllocation' has unsafe type '(UnsafeMutableBufferPointer<UInt8>) throws(Failure) -> R'
363 | try body(unsafe InlineElements(buffer: alloc, count: 0))
364 | }
[#StrictMemorySafety]: <https://docs.swift.org/compiler/documentation/diagnostics/strict-memory-safety>
[185/185] Emitting module SwiftIDNA
/host/spi-builder-workspace/Sources/SwiftIDNA/+Array.swift:7:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
5 | package init(copying span: Span<Element>) {
6 | unsafe self.init(unsafeUninitializedCapacity: span.count) { buffer, initializedCount in
7 | span.withUnsafeBytes { spanPtr in
| | | `- note: argument #0 in call to instance method 'withUnsafeBytes' has unsafe type '(UnsafeRawBufferPointer) -> ()'
| | `- note: reference to instance method 'withUnsafeBytes' involves unsafe type 'UnsafeRawBufferPointer'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
8 | let rawBuffer = UnsafeMutableRawBufferPointer(buffer)
9 | unsafe rawBuffer.copyMemory(from: spanPtr)
/host/spi-builder-workspace/Sources/SwiftIDNA/+OutputSpan.swift:10:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
8 | let usedCapacity = self.count
9 | unsafe self.withUnsafeMutableBufferPointer { buffer, initializedCount in
10 | span.withUnsafeBytes { spanPtr in
| | | `- note: argument #0 in call to instance method 'withUnsafeBytes' has unsafe type '(UnsafeRawBufferPointer) -> ()'
| | `- note: reference to instance method 'withUnsafeBytes' involves unsafe type 'UnsafeRawBufferPointer'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
11 | let target = unsafe UnsafeMutableRawPointer(
12 | buffer.baseAddress.unsafelyUnwrapped
/host/spi-builder-workspace/Sources/SwiftIDNA/+String.swift:68:29: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
66 | /// Fast path: Currently always the case for non-Darwin.
67 | /// On Darwin, always the case unless for some objc-bridged strings.
68 | if let fastResult = self.utf8.withContiguousStorageIfAvailable({ buffer in
| | | `- note: argument #0 in call to instance method 'withContiguousStorageIfAvailable' has unsafe type '(UnsafeBufferPointer<String.UTF8View.Element>) throws -> Result<T, E>' (aka '(UnsafeBufferPointer<UInt8>) throws -> Result<T, E>')
| | `- note: reference to instance method 'withContiguousStorageIfAvailable' involves unsafe type 'UnsafeBufferPointer<String.UTF8View.Element>' (aka 'UnsafeBufferPointer<UInt8>')
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
69 | Result(catching: { () throws(E) -> T in
70 | try body(unsafe buffer.span)
/host/spi-builder-workspace/Sources/SwiftIDNA/+String.swift:135:9: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
133 | ) throws -> Int
134 | ) rethrows {
135 | try self.init(unsafeUninitializedCapacity: capacity) { buffer in
| | | `- note: argument 'initializingUTF8With' in call to initializer 'init' has unsafe type '(UnsafeMutableBufferPointer<UInt8>) throws -> Int'
| | `- note: reference to initializer 'init(unsafeUninitializedCapacity:initializingUTF8With:)' involves unsafe type 'UnsafeMutableBufferPointer<UInt8>'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
136 | unsafe try initializer(buffer)
137 | }
/host/spi-builder-workspace/Sources/SwiftIDNA/Collections/DecodedUnicodeScalars.swift:117:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
115 | @inlinable
116 | func withUnsafeScalarValues(_ block: (Span<UInt32>) -> Void) {
117 | self.scalars.withUnsafeBufferPointer { buffer -> Void in
| | | `- note: argument #0 in call to instance method 'withUnsafeBufferPointer' has unsafe type '(UnsafeBufferPointer<UnicodeScalarValue>) -> Void'
| | `- note: reference to instance method 'withUnsafeBufferPointer' involves unsafe type 'UnsafeBufferPointer<UnicodeScalarValue>'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
118 | guard let base = buffer.baseAddress else {
119 | return
/host/spi-builder-workspace/Sources/SwiftIDNA/Collections/SIMDUnicodeScalarDecoder.swift:67:9: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
65 | _ body: (inout SIMDUnicodeScalarDecoder) throws(Failure) -> R
66 | ) throws(Failure) -> R {
67 | try withUnsafeTemporaryAllocation(
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
68 | of: UInt8.self,
69 | capacity: Self.tempBytesSize
70 | ) { tempBytes throws(Failure) -> R in
| `- note: argument #2 in call to global function 'withUnsafeTemporaryAllocation' has unsafe type '(UnsafeMutableBufferPointer<UInt8>) throws(Failure) -> R'
71 | try withUnsafeTemporaryAllocation(
72 | of: UInt8.self,
/host/spi-builder-workspace/Sources/SwiftIDNA/Collections/SIMDUnicodeScalarDecoder.swift:71:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
69 | capacity: Self.tempBytesSize
70 | ) { tempBytes throws(Failure) -> R in
71 | try withUnsafeTemporaryAllocation(
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
72 | of: UInt8.self,
73 | capacity: Self.paddedScalarUTF8LengthsSize
74 | ) { paddedScalarUTF8Lengths throws(Failure) -> R in
| `- note: argument #2 in call to global function 'withUnsafeTemporaryAllocation' has unsafe type '(UnsafeMutableBufferPointer<UInt8>) throws(Failure) -> R'
75 | try withUnsafeTemporaryAllocation(
76 | of: UInt32.self,
/host/spi-builder-workspace/Sources/SwiftIDNA/Collections/SIMDUnicodeScalarDecoder.swift:75:17: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
73 | capacity: Self.paddedScalarUTF8LengthsSize
74 | ) { paddedScalarUTF8Lengths throws(Failure) -> R in
75 | try withUnsafeTemporaryAllocation(
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
76 | of: UInt32.self,
77 | capacity: Self.windowSize
78 | ) { uncheckedScalarValues throws(Failure) -> R in
| `- note: argument #2 in call to global function 'withUnsafeTemporaryAllocation' has unsafe type '(UnsafeMutableBufferPointer<UInt32>) throws(Failure) -> R'
79 | try withUnsafeTemporaryAllocation(
80 | of: UInt8.self,
/host/spi-builder-workspace/Sources/SwiftIDNA/Collections/SIMDUnicodeScalarDecoder.swift:79:21: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
77 | capacity: Self.windowSize
78 | ) { uncheckedScalarValues throws(Failure) -> R in
79 | try withUnsafeTemporaryAllocation(
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
80 | of: UInt8.self,
81 | capacity: Self.scalarStartOffsetsSize
82 | ) { scalarStartOffsets throws(Failure) -> R in
| `- note: argument #2 in call to global function 'withUnsafeTemporaryAllocation' has unsafe type '(UnsafeMutableBufferPointer<UInt8>) throws(Failure) -> R'
83 | unsafe tempBytes.initialize(repeating: 0)
84 | unsafe paddedScalarUTF8Lengths.initialize(repeating: 0)
/host/spi-builder-workspace/Sources/SwiftIDNA/Collections/SIMDUnicodeScalarDecoder.swift:169:9: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
167 | /// `tempBytes` is initialized-memory by above code (`tempBytes.initialize(repeating: 0)`), so it's valid anyway.
168 | /// The pad bytes are not important.
169 | tempBytes.withUnsafeMutableBufferPointer { temp in
| | | `- note: argument #0 in call to instance method 'withUnsafeMutableBufferPointer' has unsafe type '(UnsafeMutableBufferPointer<UInt8>) -> ()'
| | `- note: reference to instance method 'withUnsafeMutableBufferPointer' involves unsafe type 'UnsafeMutableBufferPointer<UInt8>'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
170 | encodedBytes.withUnsafeBufferPointer { encoded in
171 | let rawTemp = UnsafeMutableRawBufferPointer(temp)
/host/spi-builder-workspace/Sources/SwiftIDNA/Collections/SIMDUnicodeScalarDecoder.swift:170:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
168 | /// The pad bytes are not important.
169 | tempBytes.withUnsafeMutableBufferPointer { temp in
170 | encodedBytes.withUnsafeBufferPointer { encoded in
| | | `- note: argument #0 in call to instance method 'withUnsafeBufferPointer' has unsafe type '(UnsafeBufferPointer<UInt8>) -> ()'
| | `- note: reference to instance method 'withUnsafeBufferPointer' involves unsafe type 'UnsafeBufferPointer<UInt8>'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
171 | let rawTemp = UnsafeMutableRawBufferPointer(temp)
172 | let rawEncodedBytes = UnsafeRawBufferPointer(encoded)
/host/spi-builder-workspace/Sources/SwiftIDNA/Collections/TinyBuffer.swift:359:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
357 | _ body: (consuming InlineElements) throws(Failure) -> R
358 | ) throws(Failure) -> R {
359 | try withUnsafeTemporaryAllocation(
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
360 | of: UInt8.self,
361 | capacity: Self.maximumCapacity
362 | ) { alloc throws(Failure) -> R in
| `- note: argument #2 in call to global function 'withUnsafeTemporaryAllocation' has unsafe type '(UnsafeMutableBufferPointer<UInt8>) throws(Failure) -> R'
363 | try body(unsafe InlineElements(buffer: alloc, count: 0))
364 | }
/host/spi-builder-workspace/Sources/SwiftIDNA/IDNA.MappingErrors.swift:47:13: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
45 | var errors = [MappingError]()
46 | errors.reserveCapacity(self.errors.count)
47 | self.errors.span.withUnsafeBufferPointer { spanPtr in
| | | `- note: argument #0 in call to instance method 'withUnsafeBufferPointer' has unsafe type '(UnsafeBufferPointer<IDNA.MappingError>) -> ()'
| | `- note: reference to instance method 'withUnsafeBufferPointer' involves unsafe type 'UnsafeBufferPointer<IDNA.MappingError>'
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
48 | unsafe errors.append(contentsOf: spanPtr)
49 | }
/host/spi-builder-workspace/Sources/SwiftIDNA/NFCNormalization.swift:126:9: warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
124 | /// NFC form at most 3 UTF-8 bytes per input UTF-8 byte. The generator verifies both
125 | /// bounds on every table regeneration.
126 | withUnsafeTemporaryAllocation(
| `- warning: expression uses unsafe constructs but is not marked with 'unsafe' [#StrictMemorySafety]
127 | of: UInt32.self,
128 | capacity: 2 &* span.count
129 | ) { scalarsBuffer in
| `- note: argument #2 in call to global function 'withUnsafeTemporaryAllocation' has unsafe type '(UnsafeMutableBufferPointer<UInt32>) -> R'
130 | var scalarsCount = 0
131 | /// For Normalization Form C, we need to first go through the decomposition step:
[#StrictMemorySafety]: <https://docs.swift.org/compiler/documentation/diagnostics/strict-memory-safety>
Build complete! (7.78s)
Build complete.
{
"dependencies" : [
{
"identity" : "swift-collections",
"requirement" : {
"range" : [
{
"lower_bound" : "1.7.1",
"upper_bound" : "2.0.0"
}
]
},
"type" : "sourceControl",
"url" : "https://github.com/apple/swift-collections.git"
},
{
"identity" : "swift-highway",
"requirement" : {
"exact" : [
"1.0.0-alpha.7"
]
},
"type" : "sourceControl",
"url" : "https://github.com/swift-dns/swift-highway.git"
}
],
"manifest_display_name" : "swift-idna",
"name" : "swift-idna",
"path" : "/host/spi-builder-workspace",
"platforms" : [
],
"products" : [
{
"name" : "SwiftIDNA",
"targets" : [
"SwiftIDNA"
],
"type" : {
"library" : [
"automatic"
]
}
}
],
"targets" : [
{
"c99name" : "SwiftIDNA",
"module_type" : "SwiftTarget",
"name" : "SwiftIDNA",
"path" : "Sources/SwiftIDNA",
"product_dependencies" : [
"BasicContainers",
"Highway"
],
"product_memberships" : [
"SwiftIDNA"
],
"sources" : [
"+Array.swift",
"+BinaryInteger.swift",
"+OutputSpan.swift",
"+Span.swift",
"+String.swift",
"ByteCheck+IDNA.swift",
"Collections/DecodedUnicodeScalars.swift",
"Collections/IDNAUnicodeScalarView.swift",
"Collections/LinkedList.swift",
"Collections/SIMDUnicodeScalarDecoder.swift",
"Collections/TinyBuffer.swift",
"Collections/TinyBufferSubSequence.swift",
"Collections/UTF8BytesIterator.swift",
"Collections/UnicodeScalarIterator.swift",
"IDNA.ConversionResult.swift",
"IDNA.MappingErrors.swift",
"IDNA.swift",
"IDNAMapping.swift",
"IDNA_API.swift",
"IDNA_Impl_assumingUnsanitized.swift",
"IDNA_Impl_assumingValidUTF8.swift",
"NFCNormalization.swift",
"NFCScalarInfo.swift",
"Punycode.swift",
"UTF8Checker.swift",
"UnicodeScalarValue.swift"
],
"target_dependencies" : [
"CSwiftIDNA"
],
"type" : "library"
},
{
"c99name" : "IDNATests",
"module_type" : "SwiftTarget",
"name" : "IDNATests",
"path" : "Tests/IDNATests",
"sources" : [
"DecoderWindowEquivalenceTests.swift",
"IDNAMappingLookupTests.swift",
"IDNATestV2Case.swift",
"IDNATests.swift",
"IllFormedUTF8Tests.swift",
"LinkedListTests.swift",
"MarkLookupTests.swift",
"NFCTestCase.swift",
"NFCTests.swift",
"PunycodeCapacityTests.swift"
],
"target_dependencies" : [
"SwiftIDNA",
"CSwiftIDNATesting"
],
"type" : "test"
},
{
"c99name" : "CSwiftIDNATesting",
"module_type" : "ClangTarget",
"name" : "CSwiftIDNATesting",
"path" : "Sources/CSwiftIDNATesting",
"sources" : [
"src/cswift_idna_nfc_test_cases.c",
"src/cswift_idna_test_v2_cases.c"
],
"type" : "library"
},
{
"c99name" : "CSwiftIDNA",
"module_type" : "ClangTarget",
"name" : "CSwiftIDNA",
"path" : "Sources/CSwiftIDNA",
"product_memberships" : [
"SwiftIDNA"
],
"sources" : [
"src/cswift_idna_mapping_table.c",
"src/cswift_idna_mark_table.c",
"src/cswift_idna_nfc_table.c"
],
"type" : "library"
}
],
"tools_version" : "6.3"
}
wasm-6.3-latest: Pulling from saguaro1/spi-images
Digest: sha256:df2e9038ff906af397ec7b7e13902ccb183f8867606bc33419e44453a9abdb4b
Status: Image is up to date for registry.gitlab.com/saguaro1/spi-images:wasm-6.3-latest
Done.