Swift Package Index

Build Information

Failed to build SwiftPropertyLaws, reference main (9e774f), with Swift 6.1 for Linux on 13 Oct 2026 02:13:06 UTC.

Build Command

bash -c docker run --pull=always --rm -v "checkouts-53886768-1":/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.1-latest swift build --triple x86_64-unknown-linux-gnu 2>&1

Build Log

<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
Running build ...
bash -c docker run --pull=always --rm -v "checkouts-53886768-1":/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.1-latest swift build --triple x86_64-unknown-linux-gnu 2>&1
basic-6.1-latest: Pulling from saguaro1/spi-images
Digest: sha256:13a529f31207afe6597b18f20995fc2db944100da935819188c653038756cb1b
Status: Image is up to date for registry.gitlab.com/saguaro1/spi-images:basic-6.1-latest
[0/1] Planning build
/host/spi-builder-workspace/Plugins/PropertyLawDiscoveryPlugin/plugin.swift:36:59: warning: 'path' is deprecated: renamed to 'url'
 34 |         let tool = try context.tool(named: "PropertyLawDiscoveryTool")
 35 |         let process = Process()
 36 |         process.executableURL = URL(fileURLWithPath: tool.path.string)
    |                                                           |- warning: 'path' is deprecated: renamed to 'url'
    |                                                           `- note: use 'url' instead
 37 |         var toolArgs: [String] = [
 38 |             "--target", target,
/host/spi-builder-workspace/Plugins/PropertyLawDiscoveryPlugin/plugin.swift:36:64: warning: 'string' is deprecated: Use `URL` type instead of `Path`.
 34 |         let tool = try context.tool(named: "PropertyLawDiscoveryTool")
 35 |         let process = Process()
 36 |         process.executableURL = URL(fileURLWithPath: tool.path.string)
    |                                                                `- warning: 'string' is deprecated: Use `URL` type instead of `Path`.
 37 |         var toolArgs: [String] = [
 38 |             "--target", target,
/host/spi-builder-workspace/Plugins/PropertyLawDiscoveryPlugin/plugin.swift:77:40: warning: 'directory' is deprecated: renamed to 'directoryURL'
 75 |     /// doesn't exist; commit 5 will create the dir if missing.
 76 |     private func defaultOutputPath(for target: Target, in context: PluginContext) -> String {
 77 |         let testsDir = context.package.directory
    |                                        |- warning: 'directory' is deprecated: renamed to 'directoryURL'
    |                                        `- note: use 'directoryURL' instead
 78 |             .appending(["Tests", "\(target.name)Tests"])
 79 |         return testsDir.appending(["PropertyLawTests.generated.swift"]).string
/host/spi-builder-workspace/Plugins/PropertyLawDiscoveryPlugin/plugin.swift:78:14: warning: 'appending' is deprecated: Use `URL` type instead of `Path`.
 76 |     private func defaultOutputPath(for target: Target, in context: PluginContext) -> String {
 77 |         let testsDir = context.package.directory
 78 |             .appending(["Tests", "\(target.name)Tests"])
    |              `- warning: 'appending' is deprecated: Use `URL` type instead of `Path`.
 79 |         return testsDir.appending(["PropertyLawTests.generated.swift"]).string
 80 |     }
/host/spi-builder-workspace/Plugins/PropertyLawDiscoveryPlugin/plugin.swift:79:25: warning: 'appending' is deprecated: Use `URL` type instead of `Path`.
 77 |         let testsDir = context.package.directory
 78 |             .appending(["Tests", "\(target.name)Tests"])
 79 |         return testsDir.appending(["PropertyLawTests.generated.swift"]).string
    |                         `- warning: 'appending' is deprecated: Use `URL` type instead of `Path`.
 80 |     }
 81 |
/host/spi-builder-workspace/Plugins/PropertyLawDiscoveryPlugin/plugin.swift:79:73: warning: 'string' is deprecated: Use `URL` type instead of `Path`.
 77 |         let testsDir = context.package.directory
 78 |             .appending(["Tests", "\(target.name)Tests"])
 79 |         return testsDir.appending(["PropertyLawTests.generated.swift"]).string
    |                                                                         `- warning: 'string' is deprecated: Use `URL` type instead of `Path`.
 80 |     }
 81 |
/host/spi-builder-workspace/Plugins/PropertyLawDiscoveryPlugin/plugin.swift:129:26: warning: 'path' is deprecated: renamed to 'url'
127 |         guard let sourceModuleTarget = target as? SourceModuleTarget else { return [] }
128 |         return sourceModuleTarget.sourceFiles
129 |             .filter { $0.path.extension == "swift" }
    |                          |- warning: 'path' is deprecated: renamed to 'url'
    |                          `- note: use 'url' instead
130 |             .map { $0.path.string }
131 |             .sorted()
/host/spi-builder-workspace/Plugins/PropertyLawDiscoveryPlugin/plugin.swift:129:31: warning: 'extension' is deprecated: Use `URL` type instead of `Path`.
127 |         guard let sourceModuleTarget = target as? SourceModuleTarget else { return [] }
128 |         return sourceModuleTarget.sourceFiles
129 |             .filter { $0.path.extension == "swift" }
    |                               `- warning: 'extension' is deprecated: Use `URL` type instead of `Path`.
130 |             .map { $0.path.string }
131 |             .sorted()
/host/spi-builder-workspace/Plugins/PropertyLawDiscoveryPlugin/plugin.swift:130:23: warning: 'path' is deprecated: renamed to 'url'
128 |         return sourceModuleTarget.sourceFiles
129 |             .filter { $0.path.extension == "swift" }
130 |             .map { $0.path.string }
    |                       |- warning: 'path' is deprecated: renamed to 'url'
    |                       `- note: use 'url' instead
131 |             .sorted()
132 |     }
/host/spi-builder-workspace/Plugins/PropertyLawDiscoveryPlugin/plugin.swift:130:28: warning: 'string' is deprecated: Use `URL` type instead of `Path`.
128 |         return sourceModuleTarget.sourceFiles
129 |             .filter { $0.path.extension == "swift" }
130 |             .map { $0.path.string }
    |                            `- warning: 'string' is deprecated: Use `URL` type instead of `Path`.
131 |             .sorted()
132 |     }
[1/1] Compiling plugin PropertyLawDiscoveryPlugin
Building for debugging...
[1/38] Write swift-version-24593BA9C3E375BF.txt
[3/50] Compiling SwiftSyntax602 Empty.swift
[4/72] Compiling SwiftSyntax601 Empty.swift
[5/72] Emitting module SwiftSyntax602
[6/72] Emitting module SwiftSyntax601
[7/74] Compiling SwiftSyntax510 Empty.swift
[8/74] Compiling SwiftSyntax600 Empty.swift
[9/74] Compiling SwiftSyntax509 Empty.swift
[10/74] Emitting module SwiftSyntax509
[11/75] Emitting module SwiftSyntax600
[12/76] Compiling SwiftSyntax602 Empty.swift
[13/76] Emitting module SwiftSyntax602
[14/76] Emitting module SwiftSyntax510
[15/78] Compiling RealModule RealFunctions.swift
[20/78] Compiling RealModule Real.swift
[25/75] Compiling RealModule AlgebraicField.swift
[26/75] Compiling RealModule ApproximateEquality.swift
[27/74] Compiling RealModule RelaxedArithmetic.swift
[28/74] Compiling RealModule Float80+Real.swift
[30/74] Compiling RealModule RelaxedArithmetic.swift
[31/74] Compiling RealModule ElementaryFunctions.swift
[32/74] Compiling RealModule Float+Real.swift
[33/74] Compiling RealModule Float16+Real.swift
[37/78] Compiling RealModule AugmentedArithmetic.swift
[38/78] Compiling RealModule Double+Real.swift
[43/143] Compiling SwiftSyntax509 Empty.swift
[44/147] Compiling SwiftSyntax601 Empty.swift
[45/165] Emitting module SwiftSyntax600
[46/165] Emitting module RealModule
[47/166] Emitting module SwiftSyntax509
[48/166] Emitting module SwiftSyntax601
[49/168] Compiling SwiftSyntax600 Empty.swift
[50/169] Compiling SwiftSyntax510 Empty.swift
[51/169] Emitting module SwiftSyntax510
[52/170] Emitting module RealModule
[57/168] Compiling SwiftSyntax CommonAncestor.swift
[58/168] Compiling SwiftSyntax Convenience.swift
[61/169] Compiling SwiftSyntax AbsolutePosition.swift
[62/169] Compiling SwiftSyntax AbsoluteSyntaxInfo.swift
[63/169] Emitting module PropertyLawCore
[64/233] Compiling PropertyLawCore MemberwiseEmitter.swift
[65/233] Compiling PropertyLawCore Scaffold.swift
[66/233] Compiling PropertyLawCore StatelessDerivation.swift
[67/287] Compiling PropertyBased Gen+SIMD.swift
[68/287] Compiling PropertyBased Gen+String.swift
[69/287] Compiling PropertyBased Gen.swift
[70/287] Compiling PropertyBased FixedSeedTrait.swift
[71/287] Compiling PropertyBased Gen+Collection.swift
[72/287] Compiling PropertyBased Gen+Int.swift
[73/287] Compiling PropertyBased Gen+Duration.swift
[74/287] Compiling PropertyBased Gen+Float.swift
[75/287] Compiling PropertyBased Gen+Frequency.swift
[76/303] Compiling SwiftSyntax AbsolutePosition.swift
[77/303] Compiling SwiftSyntax AbsoluteSyntaxInfo.swift
[78/303] Compiling SwiftSyntax ArenaAllocatedBuffer.swift
[79/350] Compiling SwiftSyntax RawSyntaxNodeProtocol.swift
[80/350] Compiling SwiftSyntax RawSyntaxTokenView.swift
[83/354] Compiling SwiftSyntax RawSyntaxArena.swift
[84/354] Compiling SwiftSyntax RawSyntaxLayoutView.swift
[85/354] Compiling InternalCollectionsUtilities _SortedCollection.swift
[86/354] Compiling InternalCollectionsUtilities _UniqueCollection.swift
[89/356] Compiling SwiftSyntax RawSyntax.swift
[93/356] Compiling SwiftSyntax Convenience.swift
[94/356] Compiling SwiftSyntax CustomTraits.swift
[95/356] Compiling SwiftSyntax EditorPlaceholder.swift
[101/356] Emitting module PropertyLawCore
[105/356] Compiling SwiftSyntax Assert.swift
[106/356] Compiling SwiftSyntax BumpPtrAllocator.swift
[107/356] Compiling SwiftSyntax CommonAncestor.swift
[120/356] Compiling SwiftSyntax Identifier.swift
[121/356] Compiling SwiftSyntax MemoryLayout.swift
[122/356] Compiling SwiftSyntax MissingNodeInitializers.swift
[126/356] Compiling PropertyLawCore TodoReason.swift
[127/356] Compiling PropertyLawCore TypeShape.swift
[130/357] Emitting module InternalCollectionsUtilities
[131/357] Compiling SwiftSyntax Syntax.swift
[132/357] Compiling SwiftSyntax SyntaxChildren.swift
[133/357] Compiling SwiftSyntax SyntaxCollection.swift
[134/357] Compiling SwiftSyntax SyntaxHashable.swift
[136/361] Compiling SwiftSyntax SyntaxIdentifier.swift
[137/361] Compiling SwiftSyntax SyntaxNodeStructure.swift
[138/361] Compiling SwiftSyntax SyntaxProtocol.swift
[139/361] Compiling SwiftSyntax SyntaxText.swift
[159/365] Emitting module InternalCollectionsUtilities
[168/375] Compiling SwiftSyntax SwiftSyntaxCompatibility.swift
[174/376] Compiling ComplexModule Complex+IntegerLiteral.swift
[183/376] Compiling ComplexModule Complex+Codable.swift
[184/376] Compiling ComplexModule Complex+ElementaryFunctions.swift
[185/376] Compiling ComplexModule Complex+AdditiveArithmetic.swift
[186/376] Compiling ComplexModule Complex+AlgebraicField.swift
[187/376] Compiling ComplexModule Complex+Hashable.swift
[206/378] Compiling ComplexModule Polar.swift
[207/385] Compiling ComplexModule Complex+Hashable.swift
[208/385] Compiling ComplexModule Complex+IntegerLiteral.swift
[209/386] Compiling ComplexModule Complex+Numeric.swift
[210/389] Compiling ComplexModule Complex+StringConvertible.swift
[211/389] Compiling ComplexModule Complex.swift
[213/389] Emitting module PropertyBased
[215/389] Compiling ComplexModule Scale.swift
[216/389] Compiling ComplexModule Polar.swift
[217/391] Compiling ComplexModule Complex+Numeric.swift
[220/397] Compiling ComplexModule Complex.swift
[221/397] Compiling ComplexModule Complex+StringConvertible.swift
[222/454] Compiling HeapModule Heap+Invariants.swift
[223/454] Compiling HeapModule Heap+ExpressibleByArrayLiteral.swift
[224/454] Compiling ComplexModule Scale.swift
[225/454] Compiling HeapModule Heap+Descriptions.swift
[226/454] Compiling OrderedCollections OrderedDictionary+Deprecations.swift
[227/454] Compiling OrderedCollections OrderedDictionary+Descriptions.swift
[228/454] Compiling OrderedCollections OrderedDictionary+Codable.swift
[229/454] Compiling OrderedCollections OrderedDictionary+CustomReflectable.swift
[230/454] Emitting module ComplexModule
[231/455] Compiling HeapModule _HeapNode.swift
[232/455] Compiling OrderedCollections OrderedSet+Partial SetAlgebra isStrictSuperset.swift
[233/455] Compiling OrderedCollections OrderedSet+Partial SetAlgebra isSubset.swift
[234/455] Compiling OrderedCollections OrderedSet+Hashable.swift
[235/455] Compiling OrderedCollections OrderedSet+Initializers.swift
[236/456] Compiling HeapModule Heap+UnsafeHandle.swift
[237/456] Compiling HeapModule Heap.swift
[240/456] Emitting module HeapModule
[245/458] Compiling OrderedCollections OrderedSet+Partial SetAlgebra formSymmetricDifference.swift
[246/458] Compiling OrderedCollections OrderedSet+Partial SetAlgebra formUnion.swift
[247/458] Compiling OrderedCollections OrderedSet+Partial SetAlgebra intersection.swift
[248/458] Compiling OrderedCollections OrderedSet+Partial SetAlgebra isDisjoint.swift
[249/458] Compiling OrderedCollections OrderedSet+Partial SetAlgebra isEqualSet.swift
[250/458] Compiling OrderedCollections OrderedSet+Partial SetAlgebra isStrictSubset.swift
[253/465] Compiling OrderedCollections OrderedSet+Partial SetAlgebra isSuperset.swift
[254/465] Compiling OrderedCollections OrderedSet+Partial SetAlgebra subtract.swift
[255/465] Compiling OrderedCollections OrderedSet+Partial SetAlgebra subtracting.swift
[256/465] Compiling OrderedCollections OrderedSet+Partial SetAlgebra symmetricDifference.swift
[257/465] Compiling OrderedCollections OrderedSet+Partial SetAlgebra union.swift
[258/465] Compiling OrderedCollections OrderedSet+Partial SetAlgebra+Basics.swift
[259/465] Compiling OrderedCollections OrderedSet+RandomAccessCollection.swift
[260/465] Compiling OrderedCollections OrderedSet+ReserveCapacity.swift
[266/465] Emitting module ComplexModule
[271/466] Compiling OrderedCollections OrderedDictionary+Elements.SubSequence.swift
[272/466] Compiling OrderedCollections OrderedDictionary+Elements.swift
[273/466] Compiling OrderedCollections OrderedDictionary+Equatable.swift
[274/466] Compiling OrderedCollections OrderedDictionary+ExpressibleByDictionaryLiteral.swift
[277/530] Compiling HeapModule Heap+ExpressibleByArrayLiteral.swift
[278/530] Compiling HeapModule Heap+Descriptions.swift
[279/553] Compiling PropertyLawKit AggregateDriver.swift
[280/553] Compiling PropertyLawKit SwiftPropertyBasedBackend.swift
[281/553] Compiling PropertyLawKit CheckPreflight.swift
[282/553] Compiling PropertyLawKit CoverageAccumulator.swift
[283/553] Compiling PropertyLawKit DrawPoolDriver.swift
[284/553] Compiling PropertyLawKit EnumerationDriver.swift
[285/553] Compiling PropertyLawKit EqualValueLawBuilders.swift
[286/553] Compiling PropertyLawKit InheritedLawCollector.swift
[287/553] Compiling PropertyLawKit LawCheckBuilders.swift
[288/646] Compiling HeapModule _HeapNode.swift
[289/706] Compiling HeapModule Heap.swift
[290/754] Compiling HeapModule Heap+UnsafeHandle.swift
[291/754] Compiling HeapModule Heap+Invariants.swift
[292/798] Compiling PropertyLawKit LawSuppressionPolicy.swift
[293/798] Compiling PropertyLawKit NearMissCollector.swift
[294/798] Compiling PropertyLawKit PerLawDriver.swift
[295/798] Compiling PropertyLawKit PropertyLawSuiteRunner.swift
[296/798] Compiling PropertyLawKit ReplayEnvironmentValidator.swift
[297/798] Compiling PropertyLawKit SpaceSampling.swift
[298/798] Compiling PropertyLawKit ViolationFormatter.swift
[299/798] Compiling PropertyLawKit CheckResult.swift
[300/798] Compiling PropertyLawKit CodableCodec.swift
[301/798] Compiling PropertyLawKit CodableLawConfig.swift
[302/798] Compiling PropertyLawKit CodableRoundTripMode.swift
[303/798] Compiling PropertyLawKit EnforcementMode.swift
[304/798] Compiling PropertyLawKit Environment.swift
[305/798] Compiling PropertyLawKit EqualValuePairing.swift
[306/798] Compiling PropertyLawKit InputSource.swift
[307/798] Compiling PropertyLawKit LawCheckOptions.swift
[308/798] Compiling PropertyLawKit LawIdentifier.swift
[309/798] Compiling PropertyLawKit LawSelection.swift
[310/798] Emitting module HeapModule
[311/799] Compiling PropertyLawKit DefensiveCopyLaws.swift
[312/799] Compiling PropertyLawKit Enumeration.swift
[313/799] Compiling PropertyLawKit EnumerationCombinators.swift
[314/799] Compiling PropertyLawKit EnumerationProduct.swift
[315/799] Compiling PropertyLawKit InteractionInvariantLaws.swift
[316/799] Compiling PropertyLawKit InvariantFalsifiabilityLaw.swift
[317/799] Compiling PropertyLawKit IteratorProtocolLaws.swift
[318/799] Compiling PropertyLawKit LosslessStringConvertibleLaws.swift
[319/799] Compiling PropertyLawKit StrictnessTier.swift
[320/799] Compiling PropertyLawKit TrialBudget.swift
[321/799] Compiling PropertyLawKit PropertyLawKit.swift
[322/799] Compiling PropertyLawKit ActionSequenceFactory.swift
[323/799] Compiling PropertyLawKit AdditiveArithmeticLaws.swift
[324/799] Compiling PropertyLawKit BidirectionalCollectionLaws.swift
[325/799] Compiling PropertyLawKit BinaryFloatingPointLaws.swift
[326/799] Compiling PropertyLawKit BinaryIntegerLaws.swift
[336/806] Compiling PropertyLawKit CaseIterableLaws.swift
[337/806] Compiling PropertyLawKit CodableLaws.swift
[338/806] Compiling PropertyLawKit CollectionLaws.swift
[339/806] Compiling PropertyLawKit CommutativeMonoid.swift
[340/806] Compiling PropertyLawKit CommutativeMonoidLaws.swift
[341/806] Compiling PropertyLawKit ComparableLaws.swift
[342/806] Compiling PropertyLawKit CoverageClassifier.swift
[343/806] Compiling PropertyLawKit DefensiveCopy.swift
[352/808] Compiling PropertyLawKit LawCheckBuilders.swift
[360/808] Compiling PropertyLawKit EquatableLaws.swift
[361/808] Compiling PropertyLawKit EveryCarrierLaws.swift
[362/808] Compiling PropertyLawKit EveryCaseLaws.swift
[363/808] Compiling PropertyLawKit FixedWidthIntegerLaws.swift
[364/808] Compiling PropertyLawKit FloatingPointCommutativityLaws.swift
[365/808] Compiling PropertyLawKit FloatingPointLaws.swift
[366/808] Compiling PropertyLawKit FoundationGenerators.swift
[367/808] Compiling PropertyLawKit Group.swift
[368/808] Compiling PropertyLawKit GroupLaws.swift
[369/808] Compiling PropertyLawKit HashableLaws.swift
[378/818] Compiling PropertyLawKit AggregateDriver.swift
[379/818] Compiling PropertyLawKit SwiftPropertyBasedBackend.swift
[380/818] Compiling PropertyLawKit CheckPreflight.swift
[381/818] Compiling PropertyLawKit CoverageAccumulator.swift
[382/818] Compiling PropertyLawKit DrawPoolDriver.swift
[383/818] Compiling PropertyLawKit EnumerationDriver.swift
[384/818] Compiling PropertyLawKit EqualValueLawBuilders.swift
[385/818] Compiling PropertyLawKit InheritedLawCollector.swift
[425/826] Compiling OrderedCollections OrderedSet+Sendable.swift
[426/826] Compiling OrderedCollections OrderedSet+SubSequence.swift
[427/826] Compiling OrderedCollections OrderedSet+Testing.swift
[428/826] Compiling OrderedCollections OrderedSet+UnorderedView.swift
[429/826] Compiling OrderedCollections OrderedSet+UnstableInternals.swift
[430/826] Compiling OrderedCollections OrderedSet.swift
[431/826] Compiling SwiftSyntax SyntaxNodesC.swift
[432/826] Compiling SwiftSyntax SyntaxNodesD.swift
[433/826] Compiling SwiftSyntax SyntaxNodesEF.swift
[441/826] Emitting module PropertyLawComplex
[442/826] Compiling PropertyLawComplex EdgeCaseBiasedGenerators.swift
[443/827] Compiling HashTreeCollections TreeSet+SetAlgebra isEqualSet.swift
[444/827] Compiling HashTreeCollections TreeSet+SetAlgebra isStrictSubset.swift
[445/827] Compiling HashTreeCollections TreeSet+SetAlgebra isStrictSuperset.swift
[446/827] Compiling HashTreeCollections TreeSet+SetAlgebra isSubset.swift
[447/827] Compiling HashTreeCollections TreeSet+SetAlgebra isSuperset.swift
[448/827] Compiling HashTreeCollections TreeSet+SetAlgebra subtract.swift
[449/827] Compiling HashTreeCollections TreeSet+SetAlgebra subtracting.swift
[450/827] Compiling HashTreeCollections TreeSet+SetAlgebra symmetricDifference.swift
[451/827] Compiling HashTreeCollections TreeSet+SetAlgebra union.swift
[452/827] Compiling HashTreeCollections TreeSet.swift
[457/827] Compiling PropertyLawKit LawSuppression.swift
[458/827] Compiling PropertyLawKit PropertyLawViolation.swift
[459/827] Compiling PropertyLawKit Seed.swift
[460/827] Compiling PropertyLawKit SequenceLawOptions.swift
[461/827] Compiling PropertyLawKit SpaceCoverage.swift
[478/829] Emitting module PropertyLawComplex
[490/829] Compiling PropertyLawComplex EdgeCaseBiasedGenerators.swift
[523/842] Emitting module OrderedCollections
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
[538/855] Compiling SwiftSyntax SyntaxNodesGHI.swift
[539/855] Compiling SwiftSyntax SyntaxNodesJKLMN.swift
[540/855] Compiling SwiftSyntax SyntaxNodesOP.swift
[541/855] Compiling SwiftSyntax SyntaxNodesQRS.swift
[542/855] Compiling SwiftSyntax SyntaxNodesTUVWXYZ.swift
[558/855] Compiling PropertyLawKit SemilatticeLaws.swift
[559/855] Compiling PropertyLawKit SequenceLaws.swift
[560/855] Compiling PropertyLawKit SetAlgebraLaws.swift
[561/855] Compiling PropertyLawKit SignedIntegerLaws.swift
[562/855] Compiling PropertyLawKit SignedNumericLaws.swift
[563/855] Compiling PropertyLawKit StableIdentity.swift
[577/855] Emitting module PropertyLawKit
[591/931] Emitting module OrderedCollections
[592/948] Emitting module PropertyLawKit
[593/968] Compiling ContainersPreview BorrowingSequence+Standard Conformances.swift
[594/968] Compiling ContainersPreview BorrowingSequence+Utilities.swift
[595/968] Compiling ContainersPreview BorrowingSequence.swift
[596/968] Compiling ContainersPreview BidirectionalContainer.swift
[597/968] Compiling ContainersPreview Container+Filter.swift
[598/972] Compiling HashTreeCollections TreeSet+Hashable.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
[599/972] Compiling HashTreeCollections TreeSet+Sendable.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
[600/972] Compiling HashTreeCollections TreeSet+Sequence.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
[601/972] Compiling HashTreeCollections TreeSet+SetAlgebra Initializers.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
[602/972] Compiling HashTreeCollections TreeSet+SetAlgebra basics.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
[603/972] Compiling HashTreeCollections TreeSet+SetAlgebra formIntersection.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
[604/972] Compiling HashTreeCollections TreeSet+SetAlgebra formSymmetricDifference.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
[605/972] Compiling HashTreeCollections TreeSet+SetAlgebra formUnion.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
[606/972] Compiling HashTreeCollections TreeSet+SetAlgebra intersection.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
[607/972] Compiling HashTreeCollections TreeSet+SetAlgebra isDisjoint.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
[612/972] Compiling ContainersPreview BorrowingIteratorProtocol+Map.swift
[613/972] Compiling ContainersPreview BorrowingIteratorProtocol+Reduce.swift
[614/972] Compiling ContainersPreview BorrowingIteratorProtocol+SpanwiseZip.swift
[615/972] Compiling ContainersPreview BorrowingIteratorProtocol.swift
[616/972] Compiling ContainersPreview BorrowingSequence+Algorithms.swift
[617/972] Compiling ContainersPreview Producer+Map.swift
[618/972] Compiling ContainersPreview Producer+Reduce.swift
[619/972] Compiling ContainersPreview Producer.swift
[620/972] Compiling ContainersPreview InputSpan.swift
[621/972] Compiling ContainersPreview MutableRef.swift
[622/972] Compiling ContainersPreview Drain+Map.swift
[623/972] Compiling ContainersPreview Drain+Reduce.swift
[624/972] Compiling ContainersPreview Drain.swift
[625/972] Compiling ContainersPreview Producer+Collect.swift
[626/972] Compiling ContainersPreview Producer+Filter.swift
[627/972] Emitting module ContainersPreview
[628/972] Compiling PropertyLawKit StableIdentityLaws.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
[629/972] Compiling PropertyLawKit StatefulGuard.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
[630/972] Compiling PropertyLawKit StdlibGenerators.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
[631/972] Compiling PropertyLawKit StrictWeakOrderingLaws.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
[632/972] Compiling PropertyLawKit StrictWeakOrderingVacuity.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
[633/972] Compiling PropertyLawKit StrideableLaws.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
[634/972] Compiling PropertyLawKit StringProtocolLaws.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
[635/972] Compiling PropertyLawKit TransformationFunctionLaws.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
[636/972] Compiling PropertyLawKit TransformationLaws.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
[637/972] Compiling PropertyLawKit UnsignedIntegerLaws.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
[638/972] Compiling PropertyLawKit ValueSemantic.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
[639/972] Compiling PropertyLawKit ValueSemanticLaws.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
[640/972] Compiling ContainersPreview Container+SpanwiseZip.swift
[641/972] Compiling ContainersPreview Container.swift
[642/972] Compiling ContainersPreview ContainerIterator.swift
[643/972] Compiling ContainersPreview DynamicContainer.swift
[644/972] Compiling ContainersPreview MutableContainer.swift
[645/972] Compiling ContainersPreview OutputSpan+Extras.swift
[646/972] Compiling ContainersPreview TemporaryAllocation.swift
[647/972] Compiling ContainersPreview BorrowingIteratorProtocol+Copy.swift
[648/972] Compiling ContainersPreview BorrowingIteratorProtocol+ElementsEqual.swift
[649/972] Compiling ContainersPreview BorrowingIteratorProtocol+Filter.swift
[650/972] Compiling ContainersPreview PermutableContainer.swift
[651/972] Compiling ContainersPreview RandomAccessContainer.swift
[652/972] Compiling ContainersPreview RangeExpression2.swift
[653/972] Compiling ContainersPreview RangeReplaceableContainer.swift
[654/972] Compiling ContainersPreview Strideable+Limits.swift
[655/972] Compiling ContainersPreview Ref.swift
[656/972] Compiling ContainersPreview Shared.swift
[657/972] Compiling ContainersPreview SpanIterator.swift
[658/972] Compiling ContainersPreview UniqueBox.swift
[692/1019] Compiling ContainersPreview BorrowingIteratorProtocol+Map.swift
[693/1019] Compiling ContainersPreview BorrowingIteratorProtocol+Reduce.swift
[694/1019] Compiling ContainersPreview BorrowingIteratorProtocol+SpanwiseZip.swift
[695/1019] Compiling ContainersPreview BorrowingIteratorProtocol.swift
[696/1019] Compiling ContainersPreview BorrowingSequence+Algorithms.swift
[697/1019] Compiling ContainersPreview OutputSpan+Extras.swift
[698/1019] Compiling ContainersPreview TemporaryAllocation.swift
[699/1019] Compiling ContainersPreview BorrowingIteratorProtocol+Copy.swift
[700/1019] Compiling ContainersPreview BorrowingIteratorProtocol+ElementsEqual.swift
[701/1019] Compiling ContainersPreview BorrowingIteratorProtocol+Filter.swift
[702/1019] Compiling ContainersPreview BorrowingSequence+Standard Conformances.swift
[703/1019] Compiling ContainersPreview BorrowingSequence+Utilities.swift
[704/1019] Compiling ContainersPreview BorrowingSequence.swift
[705/1019] Compiling ContainersPreview Drain+Reduce.swift
[706/1019] Compiling ContainersPreview Drain.swift
[707/1019] Compiling ContainersPreview Producer+Collect.swift
[708/1019] Compiling ContainersPreview Producer+Filter.swift
[709/1019] Compiling ContainersPreview Producer+Map.swift
[710/1019] Compiling ContainersPreview Producer+Reduce.swift
[711/1019] Compiling ContainersPreview Producer.swift
[712/1019] Compiling ContainersPreview InputSpan.swift
[713/1019] Compiling ContainersPreview MutableRef.swift
[718/1019] Compiling HashTreeCollections TreeDictionary+Codable.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:104:12: warning: no 'async' operations occur within 'await' expression
102 | ) async -> CheckResult {
103 |     let applications = Applications()
104 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
105 |         "Comparable.antisymmetry",
106 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:124:12: warning: no 'async' operations occur within 'await' expression
122 | ) async -> CheckResult {
123 |     let applications = Applications()
124 |     return await reportingApplications(applications, of: await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
125 |         "Comparable.transitivity",
126 |         source: source,
[719/1019] Compiling HashTreeCollections TreeDictionary+Collection.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:104:12: warning: no 'async' operations occur within 'await' expression
102 | ) async -> CheckResult {
103 |     let applications = Applications()
104 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
105 |         "Comparable.antisymmetry",
106 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:124:12: warning: no 'async' operations occur within 'await' expression
122 | ) async -> CheckResult {
123 |     let applications = Applications()
124 |     return await reportingApplications(applications, of: await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
125 |         "Comparable.transitivity",
126 |         source: source,
[720/1019] Compiling HashTreeCollections TreeDictionary+CustomReflectable.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:104:12: warning: no 'async' operations occur within 'await' expression
102 | ) async -> CheckResult {
103 |     let applications = Applications()
104 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
105 |         "Comparable.antisymmetry",
106 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:124:12: warning: no 'async' operations occur within 'await' expression
122 | ) async -> CheckResult {
123 |     let applications = Applications()
124 |     return await reportingApplications(applications, of: await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
125 |         "Comparable.transitivity",
126 |         source: source,
[721/1019] Compiling HashTreeCollections TreeDictionary+Debugging.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:104:12: warning: no 'async' operations occur within 'await' expression
102 | ) async -> CheckResult {
103 |     let applications = Applications()
104 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
105 |         "Comparable.antisymmetry",
106 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:124:12: warning: no 'async' operations occur within 'await' expression
122 | ) async -> CheckResult {
123 |     let applications = Applications()
124 |     return await reportingApplications(applications, of: await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
125 |         "Comparable.transitivity",
126 |         source: source,
[722/1019] Compiling HashTreeCollections TreeDictionary+Descriptions.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:104:12: warning: no 'async' operations occur within 'await' expression
102 | ) async -> CheckResult {
103 |     let applications = Applications()
104 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
105 |         "Comparable.antisymmetry",
106 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:124:12: warning: no 'async' operations occur within 'await' expression
122 | ) async -> CheckResult {
123 |     let applications = Applications()
124 |     return await reportingApplications(applications, of: await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
125 |         "Comparable.transitivity",
126 |         source: source,
[723/1019] Compiling HashTreeCollections TreeDictionary+Equatable.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:104:12: warning: no 'async' operations occur within 'await' expression
102 | ) async -> CheckResult {
103 |     let applications = Applications()
104 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
105 |         "Comparable.antisymmetry",
106 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:124:12: warning: no 'async' operations occur within 'await' expression
122 | ) async -> CheckResult {
123 |     let applications = Applications()
124 |     return await reportingApplications(applications, of: await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
125 |         "Comparable.transitivity",
126 |         source: source,
[724/1019] Compiling HashTreeCollections TreeDictionary+ExpressibleByDictionaryLiteral.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:104:12: warning: no 'async' operations occur within 'await' expression
102 | ) async -> CheckResult {
103 |     let applications = Applications()
104 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
105 |         "Comparable.antisymmetry",
106 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:124:12: warning: no 'async' operations occur within 'await' expression
122 | ) async -> CheckResult {
123 |     let applications = Applications()
124 |     return await reportingApplications(applications, of: await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
125 |         "Comparable.transitivity",
126 |         source: source,
[725/1019] Compiling HashTreeCollections TreeDictionary+Filter.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:104:12: warning: no 'async' operations occur within 'await' expression
102 | ) async -> CheckResult {
103 |     let applications = Applications()
104 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
105 |         "Comparable.antisymmetry",
106 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:124:12: warning: no 'async' operations occur within 'await' expression
122 | ) async -> CheckResult {
123 |     let applications = Applications()
124 |     return await reportingApplications(applications, of: await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
125 |         "Comparable.transitivity",
126 |         source: source,
[726/1019] Compiling HashTreeCollections TreeDictionary+Hashable.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:104:12: warning: no 'async' operations occur within 'await' expression
102 | ) async -> CheckResult {
103 |     let applications = Applications()
104 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
105 |         "Comparable.antisymmetry",
106 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:124:12: warning: no 'async' operations occur within 'await' expression
122 | ) async -> CheckResult {
123 |     let applications = Applications()
124 |     return await reportingApplications(applications, of: await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
125 |         "Comparable.transitivity",
126 |         source: source,
[727/1019] Compiling HashTreeCollections TreeDictionary+Initializers.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:104:12: warning: no 'async' operations occur within 'await' expression
102 | ) async -> CheckResult {
103 |     let applications = Applications()
104 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
105 |         "Comparable.antisymmetry",
106 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:124:12: warning: no 'async' operations occur within 'await' expression
122 | ) async -> CheckResult {
123 |     let applications = Applications()
124 |     return await reportingApplications(applications, of: await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
125 |         "Comparable.transitivity",
126 |         source: source,
[728/1019] Compiling HashTreeCollections TreeDictionary+Keys.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:104:12: warning: no 'async' operations occur within 'await' expression
102 | ) async -> CheckResult {
103 |     let applications = Applications()
104 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
105 |         "Comparable.antisymmetry",
106 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:124:12: warning: no 'async' operations occur within 'await' expression
122 | ) async -> CheckResult {
123 |     let applications = Applications()
124 |     return await reportingApplications(applications, of: await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
125 |         "Comparable.transitivity",
126 |         source: source,
[729/1019] Compiling HashTreeCollections TreeDictionary+MapValues.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:104:12: warning: no 'async' operations occur within 'await' expression
102 | ) async -> CheckResult {
103 |     let applications = Applications()
104 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
105 |         "Comparable.antisymmetry",
106 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:124:12: warning: no 'async' operations occur within 'await' expression
122 | ) async -> CheckResult {
123 |     let applications = Applications()
124 |     return await reportingApplications(applications, of: await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
125 |         "Comparable.transitivity",
126 |         source: source,
[730/1019] Compiling HashTreeCollections TreeDictionary+Merge.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:104:12: warning: no 'async' operations occur within 'await' expression
102 | ) async -> CheckResult {
103 |     let applications = Applications()
104 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
105 |         "Comparable.antisymmetry",
106 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:124:12: warning: no 'async' operations occur within 'await' expression
122 | ) async -> CheckResult {
123 |     let applications = Applications()
124 |     return await reportingApplications(applications, of: await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
125 |         "Comparable.transitivity",
126 |         source: source,
[731/1019] Compiling ContainersPreview BidirectionalContainer.swift
[732/1019] Compiling ContainersPreview Container+Filter.swift
[733/1019] Compiling ContainersPreview Container+SpanwiseZip.swift
[734/1019] Compiling ContainersPreview Container.swift
[735/1019] Compiling ContainersPreview ContainerIterator.swift
[736/1019] Compiling ContainersPreview DynamicContainer.swift
[737/1019] Compiling ContainersPreview MutableContainer.swift
[738/1019] Compiling ContainersPreview PermutableContainer.swift
[739/1019] Compiling ContainersPreview RandomAccessContainer.swift
[740/1019] Compiling ContainersPreview RangeExpression2.swift
[741/1019] Compiling ContainersPreview RangeReplaceableContainer.swift
[742/1019] Compiling ContainersPreview Strideable+Limits.swift
[743/1019] Compiling ContainersPreview Drain+Map.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
[781/1023] Emitting module ContainersPreview
[804/1023] Compiling ContainersPreview Ref.swift
[805/1023] Compiling ContainersPreview Shared.swift
[806/1023] Compiling ContainersPreview SpanIterator.swift
[807/1023] Compiling ContainersPreview UniqueBox.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:104:12: warning: no 'async' operations occur within 'await' expression
102 | ) async -> CheckResult {
103 |     let applications = Applications()
104 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
105 |         "Comparable.antisymmetry",
106 |         source: source,
BUILD FAILURE 6.1 linux