Swift Package IndexBuild Information
Successful build of swift-idna, reference main (cc894d), with Swift 6.3 for Linux on 10 Oct 2026 09:08:44 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:basic-6.3-latest swift build --triple x86_64-unknown-linux-gnu 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: linux
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:basic-6.3-latest swift build --triple x86_64-unknown-linux-gnu 2>&1
basic-6.3-latest: Pulling from saguaro1/spi-images
Digest: sha256:3ca70b9b8664d81efdd98fa96053b1e7cad14580e7715018d5ab4380e807ba72
Status: Image is up to date for registry.gitlab.com/saguaro1/spi-images:basic-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
Fetched https://github.com/swift-dns/swift-highway.git from cache (0.45s)
[1/28695] Fetching swift-collections
Fetched https://github.com/apple/swift-collections.git from cache (1.88s)
Computing version for https://github.com/apple/swift-collections.git
Computed https://github.com/apple/swift-collections.git at 1.7.2 (2.13s)
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/49] Write sources
[4/49] Compiling cswift_idna_mark_table.c
[5/49] Compiling cswift_idna_nfc_table.c
[6/49] Compiling cswift_idna_mapping_table.c
[7/49] Compiling cswift_idna_test_v2_cases.c
[8/49] Write swift-version-24593BA9C3E375BF.txt
[9/49] Compiling print.cc
[10/77] Compiling timer.cc
[11/77] Compiling profiler.cc
[12/77] Compiling targets.cc
[13/77] Compiling cswift_idna_nfc_test_cases.c
[14/77] Compiling perf_counters.cc
[15/77] Compiling topology.cc
[17/77] Emitting module InternalCollectionsUtilities
[17/80] Compiling thread_pool.cc
[18/80] Compiling nanobenchmark.cc
[19/80] Compiling CHighwayOps CHighwayOps.cc
[21/80] Compiling InternalCollectionsUtilities _UnsafeBitSet+_Word.swift
[22/80] Compiling InternalCollectionsUtilities _UnsafeBitSet.swift
[23/80] Compiling InternalCollectionsUtilities UnsafeBufferPointer+Extras.swift
[24/80] Compiling InternalCollectionsUtilities UnsafeMutableBufferPointer+Extras.swift
[25/80] Compiling InternalCollectionsUtilities Strideable+LimitHelpers.swift
[26/80] Compiling InternalCollectionsUtilities String+Padding.swift
[27/80] Compiling InternalCollectionsUtilities TemporaryAllocation.swift
[28/80] Compiling InternalCollectionsUtilities _UnsafeBitSet+Index.swift
[29/80] Compiling InternalCollectionsUtilities UnsafeMutablePointer+Extras.swift
[30/80] Compiling InternalCollectionsUtilities UnsafeMutableRawBufferPointer+Extras.swift
[31/80] Compiling InternalCollectionsUtilities UnsafePointer+Extras.swift
[32/80] Compiling InternalCollectionsUtilities BorrowingIteratorProtocol+Equality.swift
[33/80] Compiling InternalCollectionsUtilities BorrowingIteratorProtocol+Extras.swift
[34/80] Compiling InternalCollectionsUtilities Debugging.swift
[35/80] Compiling InternalCollectionsUtilities Descriptions.swift
[36/80] Compiling InternalCollectionsUtilities Iterable+CopyContents.swift
[37/80] Compiling InternalCollectionsUtilities Iterable+Equality.swift
[38/80] Compiling InternalCollectionsUtilities LifetimeOverride.swift
[39/80] Compiling InternalCollectionsUtilities MutableRef.swift
[40/80] Compiling InternalCollectionsUtilities MutableSpan+Extras.swift
[41/80] Compiling InternalCollectionsUtilities OutputSpan+Extras.swift
[42/80] Compiling InternalCollectionsUtilities RandomAccessCollection+Offsets.swift
[43/80] Compiling InternalCollectionsUtilities Span+Extras.swift
[44/80] Compiling InternalCollectionsUtilities FixedWidthInteger+roundUpToPowerOfTwo.swift
[45/80] Compiling InternalCollectionsUtilities Integer rank.swift
[46/80] Compiling InternalCollectionsUtilities UInt+first and last set bit.swift
[47/80] Compiling InternalCollectionsUtilities UInt+reversed.swift
[48/80] Compiling InternalCollectionsUtilities UnsafeRawBufferPointer+Extras.swift
[49/80] Compiling InternalCollectionsUtilities _SortedCollection.swift
[50/80] Compiling InternalCollectionsUtilities _UniqueCollection.swift
[51/81] Compiling per_target.cc
[53/85] Emitting module SpanPreview
[54/85] Compiling SpanPreview MutableSpan+InputSpanHelpers.swift
[55/85] Compiling SpanPreview OutputSpan+InputSpanHelpers.swift
[56/85] Compiling SpanPreview InputSpan.swift
[57/86] Compiling vqsort_u64d.cc
[58/86] Compiling vqsort_u64a.cc
[59/86] Compiling vqsort_u32d.cc
[60/86] Compiling vqsort_u16d.cc
[61/86] Compiling vqsort_u32a.cc
[62/86] Compiling vqsort_kv64d.cc
[63/86] Compiling vqsort_u16a.cc
[64/86] Compiling vqsort_kv64a.cc
[65/86] Compiling vqsort_i32d.cc
[66/86] Compiling vqsort_i64a.cc
[67/86] Compiling vqsort_i64d.cc
[68/86] Compiling vqsort_kv128d.cc
[69/86] Compiling vqsort_kv128a.cc
[70/86] Compiling vqsort_i16d.cc
[71/86] Compiling vqsort_i32a.cc
[72/86] Compiling vqsort_f64d.cc
[73/86] Compiling vqsort_f64a.cc
[74/86] Compiling vqsort.cc
[75/86] Compiling image.cc
[76/86] Compiling aligned_allocator.cc
[77/86] Compiling abort.cc
[78/86] Write sources
[80/169] Compiling BasicContainers UniqueDictionary+Index.swift
[81/169] Compiling BasicContainers UniqueDictionary+Indices.swift
[82/169] Compiling BasicContainers UniqueDictionary+Initializers.swift
[83/169] Compiling BasicContainers UniqueDictionary+Insertions.swift
[84/169] Compiling BasicContainers UniqueDictionary+Keys.swift
[85/169] Compiling BasicContainers UniqueDictionary+Lookup.swift
[86/169] Compiling BasicContainers UniqueDictionary+Removals.swift
[87/169] Compiling BasicContainers UniqueDictionary+Resizing.swift
[88/169] Compiling BasicContainers UniqueDictionary.swift
[89/169] Compiling BasicContainers UniqueSet+Consumption.swift
[90/169] Compiling BasicContainers UniqueSet+Debugging.swift
[91/180] Compiling BasicContainers UniqueSet+Deprecated.swift
[92/180] Compiling BasicContainers UniqueSet+Equatable.swift
[93/180] Compiling BasicContainers UniqueSet+Hashable.swift
[94/180] Compiling BasicContainers UniqueSet+Index.swift
[95/180] Compiling BasicContainers UniqueSet+Initializers.swift
[96/180] Compiling BasicContainers UniqueSet+Insertions.swift
[97/180] Compiling BasicContainers UniqueSet+Iterable.swift
[98/180] Compiling BasicContainers UniqueSet+Lookup.swift
[99/180] Compiling BasicContainers UniqueSet+Removals.swift
[100/180] Compiling BasicContainers UniqueSet+Resizing.swift
[101/180] Compiling BasicContainers UniqueSet.swift
[102/180] Compiling BasicContainers RigidSet+Iterable.swift
[103/180] Compiling BasicContainers RigidSet+Lookup.swift
[104/180] Compiling BasicContainers RigidSet+Removals.swift
[105/180] Compiling BasicContainers RigidSet+Resizing.swift
[106/180] Compiling BasicContainers RigidSet.swift
[107/180] Compiling BasicContainers UniqueArray+Append.swift
[108/180] Compiling BasicContainers UniqueArray+Consumption.swift
[109/180] Compiling BasicContainers UniqueArray+ContainerOperations.swift
[110/180] Compiling BasicContainers UniqueArray+Deprecated.swift
[111/180] Compiling BasicContainers UniqueArray+Descriptions.swift
[112/180] Compiling BasicContainers UniqueArray+Equatable.swift
[113/180] Compiling BasicContainers UniqueArray+Experimental.swift
[114/180] Compiling BasicContainers RigidDictionary+Lookup.swift
[115/180] Compiling BasicContainers RigidDictionary+Removals.swift
[116/180] Compiling BasicContainers RigidDictionary+Resizing.swift
[117/180] Compiling BasicContainers RigidDictionary.swift
[118/180] Compiling BasicContainers RigidSet+Consumption.swift
[119/180] Compiling BasicContainers RigidSet+Debugging.swift
[120/180] Compiling BasicContainers RigidSet+Deprecated.swift
[121/180] Compiling BasicContainers RigidSet+Equatable.swift
[122/180] Compiling BasicContainers RigidSet+Hashable.swift
[123/180] Compiling BasicContainers RigidSet+Index.swift
[124/180] Compiling BasicContainers RigidSet+Initializers.swift
[125/180] Compiling BasicContainers RigidSet+Insertions.swift
[126/180] Compiling BasicContainers RigidArray+Removals.swift
[127/180] Compiling BasicContainers RigidArray+Replacements.swift
[128/180] Compiling BasicContainers RigidArray.swift
[129/180] Compiling BasicContainers RigidDictionary+Consumption.swift
[130/180] Compiling BasicContainers RigidDictionary+Debugging.swift
[131/180] Compiling BasicContainers RigidDictionary+Equatable.swift
[132/180] Compiling BasicContainers RigidDictionary+Hashable.swift
[133/180] Compiling BasicContainers RigidDictionary+Index.swift
[134/180] Compiling BasicContainers RigidDictionary+Indices.swift
[135/180] Compiling BasicContainers RigidDictionary+Initializers.swift
[136/180] Compiling BasicContainers RigidDictionary+Insertions.swift
[137/180] Compiling BasicContainers RigidDictionary+Keys.swift
[138/180] Compiling BasicContainers _HTable+Bitmap.swift
[139/180] Compiling BasicContainers _HTable+Bucket.swift
[140/180] Compiling BasicContainers _HTable+Consumption.swift
[141/180] Compiling BasicContainers _HTable+Debug.swift
[142/180] Compiling BasicContainers _HTable+Deprecated.swift
[143/180] Compiling BasicContainers _HTable+Find.swift
[144/180] Compiling BasicContainers _HTable+Insert.swift
[145/180] Compiling BasicContainers _HTable+Iteration.swift
[146/180] Compiling BasicContainers _HTable+Removal.swift
[147/180] Compiling BasicContainers _HTable+Resizing.swift
[148/180] Compiling BasicContainers _HTable+Sizing.swift
[149/180] Compiling BasicContainers _HTable.swift
[150/180] Compiling BasicContainers RigidArray+Append.swift
[151/180] Compiling BasicContainers RigidArray+Consumption.swift
[152/180] Compiling BasicContainers RigidArray+ContainerOperations.swift
[153/180] Compiling BasicContainers RigidArray+Deprecated.swift
[154/180] Compiling BasicContainers RigidArray+Descriptions.swift
[155/180] Compiling BasicContainers RigidArray+Equatable.swift
[156/180] Compiling BasicContainers RigidArray+Experimental.swift
[157/180] Compiling BasicContainers RigidArray+Formatter.swift
[158/180] Compiling BasicContainers RigidArray+Hashable.swift
[159/180] Compiling BasicContainers RigidArray+Initializers.swift
[160/180] Compiling BasicContainers RigidArray+Insertions.swift
[161/180] Compiling BasicContainers RigidArray+Iterable.swift
[162/180] Compiling BasicContainers UniqueArray+Hashable.swift
[163/180] Compiling BasicContainers UniqueArray+Initializers.swift
[164/180] Compiling BasicContainers UniqueArray+Insertions.swift
[165/180] Compiling BasicContainers UniqueArray+Iterable.swift
[166/180] Compiling BasicContainers UniqueArray+Removals.swift
[167/180] Compiling BasicContainers UniqueArray+Replacements.swift
[168/180] Compiling BasicContainers UniqueArray.swift
[169/180] Compiling BasicContainers UniqueDictionary+Consumption.swift
[170/180] Compiling BasicContainers UniqueDictionary+Debugging.swift
[171/180] Compiling BasicContainers UniqueDictionary+Equatable.swift
[172/180] Compiling BasicContainers UniqueDictionary+Hashable.swift
[173/180] Emitting module BasicContainers
[174/181] Compiling vqsort_f16d.cc
[175/181] Compiling vqsort_i16a.cc
[176/181] Compiling vqsort_f16a.cc
[177/181] Compiling vqsort_f32d.cc
[178/181] Compiling vqsort_f32a.cc
[179/181] Compiling vqsort_128d.cc
[180/181] Compiling vqsort_128a.cc
[182/194] Compiling Highway HighwayUInt64.swift
[183/194] Compiling Highway HighwayUInt8.swift
[184/195] Compiling Highway HighwayInt32.swift
[185/195] Compiling Highway HighwayInt64.swift
[186/195] Compiling Highway HighwayInt8.swift
[187/195] Compiling Highway HighwaySortable.swift
[188/195] Compiling Highway HighwayUInt16.swift
[189/195] Compiling Highway HighwayUInt32.swift
[190/195] Compiling Highway Highway.swift
[191/195] Compiling Highway HighwayDouble.swift
[192/195] Compiling Highway HighwayElement.swift
[193/195] Compiling Highway HighwayFloat.swift
[194/195] Compiling Highway HighwayInt16.swift
[195/195] Emitting module Highway
[197/220] 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>
[198/220] 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>
[199/220] 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>
[200/220] 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>
[201/223] 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>
[202/223] 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>
[203/223] 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>
[204/223] Compiling SwiftIDNA TinyBufferSubSequence.swift
[205/223] Compiling SwiftIDNA UTF8BytesIterator.swift
[206/223] Compiling SwiftIDNA UnicodeScalarIterator.swift
[207/223] 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>
[208/223] 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>
[209/223] 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>
[210/223] Compiling SwiftIDNA IDNAMapping.swift
[211/223] Compiling SwiftIDNA IDNA_API.swift
[212/223] Compiling SwiftIDNA IDNA_Impl_assumingUnsanitized.swift
[213/223] 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>
[214/223] 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>
[215/223] 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>
[216/223] 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>
[217/223] 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>
[218/223] 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>
[219/223] 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>
[220/223] 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>
[221/223] 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>
[222/223] 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>
[223/223] 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! (66.14s)
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"
}
basic-6.3-latest: Pulling from saguaro1/spi-images
Digest: sha256:3ca70b9b8664d81efdd98fa96053b1e7cad14580e7715018d5ab4380e807ba72
Status: Image is up to date for registry.gitlab.com/saguaro1/spi-images:basic-6.3-latest
Done.