From c1a47252c36ef36754ca01dcf27b10d7196e11d3 Mon Sep 17 00:00:00 2001 From: Rick van Voorden Date: Thu, 16 Oct 2025 16:20:59 -0700 Subject: [PATCH 1/6] [stdlib] array identical --- benchmark/CMakeLists.txt | 3 ++ benchmark/single-source/ArraySliceTests.swift | 46 +++++++++++++++++++ benchmark/single-source/ArrayTests.swift | 46 +++++++++++++++++++ .../single-source/ContiguousArrayTests.swift | 46 +++++++++++++++++++ benchmark/utils/main.swift | 7 +++ stdlib/public/core/Array.swift | 41 +++++++++++++++++ stdlib/public/core/ArraySlice.swift | 42 +++++++++++++++++ stdlib/public/core/ContiguousArray.swift | 41 +++++++++++++++++ test/stdlib/ArraySliceTests.swift | 43 +++++++++++++++++ test/stdlib/ArrayTests.swift | 43 +++++++++++++++++ test/stdlib/ContiguousArrayTests.swift | 43 +++++++++++++++++ 11 files changed, 401 insertions(+) create mode 100644 benchmark/single-source/ArraySliceTests.swift create mode 100644 benchmark/single-source/ArrayTests.swift create mode 100644 benchmark/single-source/ContiguousArrayTests.swift create mode 100644 test/stdlib/ArraySliceTests.swift create mode 100644 test/stdlib/ArrayTests.swift create mode 100644 test/stdlib/ContiguousArrayTests.swift diff --git a/benchmark/CMakeLists.txt b/benchmark/CMakeLists.txt index 90986da95c369..cead6ecdd2dcb 100644 --- a/benchmark/CMakeLists.txt +++ b/benchmark/CMakeLists.txt @@ -39,7 +39,9 @@ set(SWIFT_BENCH_MODULES single-source/ArrayOfRef single-source/ArrayRemoveAll single-source/ArraySetElement + single-source/ArraySliceTests single-source/ArraySubscript + single-source/ArrayTests single-source/AsyncTree single-source/BinaryFloatingPointConversionFromBinaryInteger single-source/BinaryFloatingPointProperties @@ -65,6 +67,7 @@ set(SWIFT_BENCH_MODULES single-source/ClassArrayGetter single-source/CodableTest single-source/Combos + single-source/ContiguousArrayTests single-source/CountAlgo single-source/DataBenchmarks single-source/DeadArray diff --git a/benchmark/single-source/ArraySliceTests.swift b/benchmark/single-source/ArraySliceTests.swift new file mode 100644 index 0000000000000..f67a43eaaa20f --- /dev/null +++ b/benchmark/single-source/ArraySliceTests.swift @@ -0,0 +1,46 @@ +//===--- ArraySliceTests.swift --------------------------------------------===// +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2025 Apple Inc. and the Swift project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See https://swift.org/LICENSE.txt for license information +// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors +// +//===----------------------------------------------------------------------===// + +import TestsUtils + +public let benchmarks = [ + BenchmarkInfo(name: "ArraySliceEqualUnique", runFunction: run_ArraySliceEqualUnique, tags: [.validation, .api, .Array]), + BenchmarkInfo(name: "ArraySliceEqualShared", runFunction: run_ArraySliceEqualShared, tags: [.validation, .api, .Array]), + BenchmarkInfo(name: "ArraySliceIdentical", runFunction: run_ArraySliceIdentical, tags: [.validation, .api, .Array]), +] + +@inline(never) +public func run_ArraySliceEqualUnique(_ n: Int) { + let a1 = ArraySlice(0 ..< n) + let a2 = ArraySlice(0 ..< n) + for _ in 0 ..< 100_000 { + check(a1 == a2) + } +} + +@inline(never) +public func run_ArraySliceEqualShared(_ n: Int) { + let a1 = ArraySlice(0 ..< n) + let a2 = a1 + for _ in 0 ..< 100_000 { + check(a1 == a2) + } +} + +@inline(never) +public func run_ArraySliceIdentical(_ n: Int) { + let a1 = ArraySlice(0 ..< n) + let a2 = a1 + for _ in 0 ..< 100_000 { + check(a1.isTriviallyIdentical(to: a2)) + } +} diff --git a/benchmark/single-source/ArrayTests.swift b/benchmark/single-source/ArrayTests.swift new file mode 100644 index 0000000000000..aec93680a973a --- /dev/null +++ b/benchmark/single-source/ArrayTests.swift @@ -0,0 +1,46 @@ +//===--- ArrayTests.swift -------------------------------------------------===// +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2025 Apple Inc. and the Swift project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See https://swift.org/LICENSE.txt for license information +// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors +// +//===----------------------------------------------------------------------===// + +import TestsUtils + +public let benchmarks = [ + BenchmarkInfo(name: "ArrayEqualUnique", runFunction: run_ArrayEqualUnique, tags: [.validation, .api, .Array]), + BenchmarkInfo(name: "ArrayEqualShared", runFunction: run_ArrayEqualShared, tags: [.validation, .api, .Array]), + BenchmarkInfo(name: "ArrayIdentical", runFunction: run_ArrayIdentical, tags: [.validation, .api, .Array]), +] + +@inline(never) +public func run_ArrayEqualUnique(_ n: Int) { + let a1 = Array(0 ..< n) + let a2 = Array(0 ..< n) + for _ in 0 ..< 100_000 { + check(a1 == a2) + } +} + +@inline(never) +public func run_ArrayEqualShared(_ n: Int) { + let a1 = Array(0 ..< n) + let a2 = a1 + for _ in 0 ..< 100_000 { + check(a1 == a2) + } +} + +@inline(never) +public func run_ArrayIdentical(_ n: Int) { + let a1 = Array(0 ..< n) + let a2 = a1 + for _ in 0 ..< 100_000 { + check(a1.isTriviallyIdentical(to: a2)) + } +} diff --git a/benchmark/single-source/ContiguousArrayTests.swift b/benchmark/single-source/ContiguousArrayTests.swift new file mode 100644 index 0000000000000..c4beb131d15f3 --- /dev/null +++ b/benchmark/single-source/ContiguousArrayTests.swift @@ -0,0 +1,46 @@ +//===--- ContiguousArrayTests.swift ---------------------------------------===// +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2025 Apple Inc. and the Swift project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See https://swift.org/LICENSE.txt for license information +// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors +// +//===----------------------------------------------------------------------===// + +import TestsUtils + +public let benchmarks = [ + BenchmarkInfo(name: "ContiguousArrayEqualUnique", runFunction: run_ContiguousArrayEqualUnique, tags: [.validation, .api, .Array]), + BenchmarkInfo(name: "ContiguousArrayEqualShared", runFunction: run_ContiguousArrayEqualShared, tags: [.validation, .api, .Array]), + BenchmarkInfo(name: "ContiguousArrayIdentical", runFunction: run_ContiguousArrayIdentical, tags: [.validation, .api, .Array]), +] + +@inline(never) +public func run_ContiguousArrayEqualUnique(_ n: Int) { + let a1 = ContiguousArray(0 ..< n) + let a2 = ContiguousArray(0 ..< n) + for _ in 0 ..< 100_000 { + check(a1 == a2) + } +} + +@inline(never) +public func run_ContiguousArrayEqualShared(_ n: Int) { + let a1 = ContiguousArray(0 ..< n) + let a2 = a1 + for _ in 0 ..< 100_000 { + check(a1 == a2) + } +} + +@inline(never) +public func run_ContiguousArrayIdentical(_ n: Int) { + let a1 = ContiguousArray(0 ..< n) + let a2 = a1 + for _ in 0 ..< 100_000 { + check(a1.isTriviallyIdentical(to: a2)) + } +} diff --git a/benchmark/utils/main.swift b/benchmark/utils/main.swift index 0fcb72ba1b6a7..b68bb5f5829aa 100644 --- a/benchmark/utils/main.swift +++ b/benchmark/utils/main.swift @@ -27,7 +27,9 @@ import ArrayOfPOD import ArrayOfRef import ArrayRemoveAll import ArraySetElement +import ArraySliceTests import ArraySubscript +import ArrayTests import AsyncTree import BinaryFloatingPointConversionFromBinaryInteger import BinaryFloatingPointProperties @@ -53,6 +55,7 @@ import Chars import ClassArrayGetter import CodableTest import Combos +import ContiguousArrayTests import CountAlgo import CreateObjects // rdar://128520766 @@ -227,7 +230,9 @@ register(ArrayOfPOD.benchmarks) register(ArrayOfRef.benchmarks) register(ArrayRemoveAll.benchmarks) register(ArraySetElement.benchmarks) +register(ArraySliceTests.benchmarks) register(ArraySubscript.benchmarks) +register(ArrayTests.benchmarks) register(AsyncTree.benchmarks) register(BinaryFloatingPointConversionFromBinaryInteger.benchmarks) register(BinaryFloatingPointProperties.benchmarks) @@ -252,8 +257,10 @@ register(CharacterRecognizer.benchmarks) register(Chars.benchmarks) register(CodableTest.benchmarks) register(Combos.benchmarks) +register(ContiguousArrayTests.benchmarks) register(CountAlgo.benchmarks) register(ClassArrayGetter.benchmarks) +register(ContiguousArrayTests.benchmarks) register(CreateObjects.benchmarks) // rdar://128520766 // register(CxxSetToCollection.benchmarks) diff --git a/stdlib/public/core/Array.swift b/stdlib/public/core/Array.swift index a590a5ba2782c..9dfab395b0326 100644 --- a/stdlib/public/core/Array.swift +++ b/stdlib/public/core/Array.swift @@ -2160,3 +2160,44 @@ internal struct _ArrayAnyHashableBox } extension Array: @unchecked Sendable where Element: Sendable { } + +extension Array { + /// Returns a boolean value indicating whether this array is identical to + /// `other`. + /// + /// Two array values are identical if there is no way to distinguish between + /// them. + /// + /// For any values `a`, `b`, and `c`: + /// + /// - `a.isTriviallyIdentical(to: a)` is always `true`. (Reflexivity) + /// - `a.isTriviallyIdentical(to: b)` implies `b.isTriviallyIdentical(to: a)`. + /// (Symmetry) + /// - If `a.isTriviallyIdentical(to: b)` and `b.isTriviallyIdentical(to: c)` + /// are both `true`, then `a.isTriviallyIdentical(to: c)` is also `true`. + /// (Transitivity) + /// - If `a` and `b` are `Equatable`, then `a.isTriviallyIdentical(b)` implies + /// `a == b` + /// - `a == b` does not imply `a.isTriviallyIdentical(b)` + /// + /// Values produced by copying the same value, with no intervening mutations, + /// will compare identical: + /// + /// ```swift + /// let d = c + /// print(c.isTriviallyIdentical(to: d)) + /// // Prints true + /// ``` + /// + /// Comparing arrays this way includes comparing (normally) hidden + /// implementation details such as the memory location of any underlying + /// array storage object. Therefore, identical arrays are guaranteed to + /// compare equal with `==`, but not all equal arrays are considered + /// identical. + /// + /// - Performance: O(1) + @_alwaysEmitIntoClient + public func isTriviallyIdentical(to other: Self) -> Bool { + self._buffer.identity == other._buffer.identity + } +} diff --git a/stdlib/public/core/ArraySlice.swift b/stdlib/public/core/ArraySlice.swift index 5a054b0185a66..21951fa49f8b6 100644 --- a/stdlib/public/core/ArraySlice.swift +++ b/stdlib/public/core/ArraySlice.swift @@ -1607,3 +1607,45 @@ extension ArraySlice { } } #endif + +extension ArraySlice { + /// Returns a boolean value indicating whether this array is identical to + /// `other`. + /// + /// Two array values are identical if there is no way to distinguish between + /// them. + /// + /// For any values `a`, `b`, and `c`: + /// + /// - `a.isTriviallyIdentical(to: a)` is always `true`. (Reflexivity) + /// - `a.isTriviallyIdentical(to: b)` implies `b.isTriviallyIdentical(to: a)`. + /// (Symmetry) + /// - If `a.isTriviallyIdentical(to: b)` and `b.isTriviallyIdentical(to: c)` + /// are both `true`, then `a.isTriviallyIdentical(to: c)` is also `true`. + /// (Transitivity) + /// - If `a` and `b` are `Equatable`, then `a.isTriviallyIdentical(b)` implies + /// `a == b` + /// - `a == b` does not imply `a.isTriviallyIdentical(b)` + /// + /// Values produced by copying the same value, with no intervening mutations, + /// will compare identical: + /// + /// ```swift + /// let d = c + /// print(c.isTriviallyIdentical(to: d)) + /// // Prints true + /// ``` + /// + /// Comparing arrays this way includes comparing (normally) hidden + /// implementation details such as the memory location of any underlying + /// array storage object. Therefore, identical arrays are guaranteed to + /// compare equal with `==`, but not all equal arrays are considered + /// identical. + /// + /// - Performance: O(1) + @_alwaysEmitIntoClient + public func isTriviallyIdentical(to other: Self) -> Bool { + self._buffer.identity == other._buffer.identity && + self.count == other.count + } +} diff --git a/stdlib/public/core/ContiguousArray.swift b/stdlib/public/core/ContiguousArray.swift index a5f66fe850f81..9eec4fd884535 100644 --- a/stdlib/public/core/ContiguousArray.swift +++ b/stdlib/public/core/ContiguousArray.swift @@ -1515,3 +1515,44 @@ extension ContiguousArray { extension ContiguousArray: @unchecked Sendable where Element: Sendable { } + +extension ContiguousArray { + /// Returns a boolean value indicating whether this array is identical to + /// `other`. + /// + /// Two array values are identical if there is no way to distinguish between + /// them. + /// + /// For any values `a`, `b`, and `c`: + /// + /// - `a.isTriviallyIdentical(to: a)` is always `true`. (Reflexivity) + /// - `a.isTriviallyIdentical(to: b)` implies `b.isTriviallyIdentical(to: a)`. + /// (Symmetry) + /// - If `a.isTriviallyIdentical(to: b)` and `b.isTriviallyIdentical(to: c)` + /// are both `true`, then `a.isTriviallyIdentical(to: c)` is also `true`. + /// (Transitivity) + /// - If `a` and `b` are `Equatable`, then `a.isTriviallyIdentical(b)` implies + /// `a == b` + /// - `a == b` does not imply `a.isTriviallyIdentical(b)` + /// + /// Values produced by copying the same value, with no intervening mutations, + /// will compare identical: + /// + /// ```swift + /// let d = c + /// print(c.isTriviallyIdentical(to: d)) + /// // Prints true + /// ``` + /// + /// Comparing arrays this way includes comparing (normally) hidden + /// implementation details such as the memory location of any underlying + /// array storage object. Therefore, identical arrays are guaranteed to + /// compare equal with `==`, but not all equal arrays are considered + /// identical. + /// + /// - Performance: O(1) + @_alwaysEmitIntoClient + public func isTriviallyIdentical(to other: Self) -> Bool { + self._buffer.identity == other._buffer.identity + } +} diff --git a/test/stdlib/ArraySliceTests.swift b/test/stdlib/ArraySliceTests.swift new file mode 100644 index 0000000000000..a9953080b7e94 --- /dev/null +++ b/test/stdlib/ArraySliceTests.swift @@ -0,0 +1,43 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2025 Apple Inc. and the Swift project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See https://swift.org/LICENSE.txt for license information +// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors +// +//===----------------------------------------------------------------------===// +// +// RUN: %target-run-simple-swift(-parse-as-library) +// REQUIRES: executable_test +// END. +// +//===----------------------------------------------------------------------===// + +import StdlibUnittest + +@main +enum ArraySliceTests { + static func main() { + let testSuite = TestSuite("ArraySliceTests") + testSuite.test("Identical", testIdentical) + runAllTests() + } + + static func testIdentical() { + let a1: ArraySlice = [0, 1, 2, 3] + expectTrue(a1.isTriviallyIdentical(to: a1)) + + let a2: ArraySlice = a1 + expectTrue(a1.isTriviallyIdentical(to: a2)) + + var a3: ArraySlice = a2 + a3.reserveCapacity(0) + expectFalse(a1.isTriviallyIdentical(to: a3)) + + let a4: ArraySlice = [0, 1, 2, 3] + expectFalse(a1.isTriviallyIdentical(to: a4)) + } +} diff --git a/test/stdlib/ArrayTests.swift b/test/stdlib/ArrayTests.swift new file mode 100644 index 0000000000000..cf7b0f944cd91 --- /dev/null +++ b/test/stdlib/ArrayTests.swift @@ -0,0 +1,43 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2025 Apple Inc. and the Swift project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See https://swift.org/LICENSE.txt for license information +// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors +// +//===----------------------------------------------------------------------===// +// +// RUN: %target-run-simple-swift(-parse-as-library) +// REQUIRES: executable_test +// END. +// +//===----------------------------------------------------------------------===// + +import StdlibUnittest + +@main +enum ArrayTests { + static func main() { + let testSuite = TestSuite("ArrayTests") + testSuite.test("Identical", testIdentical) + runAllTests() + } + + static func testIdentical() { + let a1: Array = [0, 1, 2, 3] + expectTrue(a1.isTriviallyIdentical(to: a1)) + + let a2: Array = a1 + expectTrue(a1.isTriviallyIdentical(to: a2)) + + var a3: Array = a2 + a3.reserveCapacity(0) + expectFalse(a1.isTriviallyIdentical(to: a3)) + + let a4: Array = [0, 1, 2, 3] + expectFalse(a1.isTriviallyIdentical(to: a4)) + } +} diff --git a/test/stdlib/ContiguousArrayTests.swift b/test/stdlib/ContiguousArrayTests.swift new file mode 100644 index 0000000000000..831709cf37a60 --- /dev/null +++ b/test/stdlib/ContiguousArrayTests.swift @@ -0,0 +1,43 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2025 Apple Inc. and the Swift project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See https://swift.org/LICENSE.txt for license information +// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors +// +//===----------------------------------------------------------------------===// +// +// RUN: %target-run-simple-swift(-parse-as-library) +// REQUIRES: executable_test +// END. +// +//===----------------------------------------------------------------------===// + +import StdlibUnittest + +@main +enum ContiguousArrayTests { + static func main() { + let testSuite = TestSuite("ContiguousArrayTests") + testSuite.test("Identical", testIdentical) + runAllTests() + } + + static func testIdentical() { + let a1: ContiguousArray = [0, 1, 2, 3] + expectTrue(a1.isTriviallyIdentical(to: a1)) + + let a2: ContiguousArray = a1 + expectTrue(a1.isTriviallyIdentical(to: a2)) + + var a3: ContiguousArray = a2 + a3.reserveCapacity(0) + expectFalse(a1.isTriviallyIdentical(to: a3)) + + let a4: ContiguousArray = [0, 1, 2, 3] + expectFalse(a1.isTriviallyIdentical(to: a4)) + } +} From 97af67658514352d44baf6ce59b6a6cd44fd5ddf Mon Sep 17 00:00:00 2001 From: Rick van Voorden Date: Mon, 20 Oct 2025 13:07:40 -0700 Subject: [PATCH 2/6] [stdlib] array identical Co-authored-by: Ben Rimmington --- stdlib/public/core/Array.swift | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/stdlib/public/core/Array.swift b/stdlib/public/core/Array.swift index 9dfab395b0326..1fcefd57ae456 100644 --- a/stdlib/public/core/Array.swift +++ b/stdlib/public/core/Array.swift @@ -2195,7 +2195,7 @@ extension Array { /// compare equal with `==`, but not all equal arrays are considered /// identical. /// - /// - Performance: O(1) + /// - Complexity: O(1) @_alwaysEmitIntoClient public func isTriviallyIdentical(to other: Self) -> Bool { self._buffer.identity == other._buffer.identity From ec5b23efe25dba966ac6965f71e4fe4c046fdb8e Mon Sep 17 00:00:00 2001 From: Rick van Voorden Date: Mon, 20 Oct 2025 13:50:31 -0700 Subject: [PATCH 3/6] [stdlib] array identical --- stdlib/public/core/Array.swift | 2 +- stdlib/public/core/ArraySlice.swift | 5 ++--- stdlib/public/core/ContiguousArray.swift | 4 ++-- stdlib/public/core/SliceBuffer.swift | 17 +++++++++++++++++ 4 files changed, 22 insertions(+), 6 deletions(-) diff --git a/stdlib/public/core/Array.swift b/stdlib/public/core/Array.swift index 1fcefd57ae456..22af0ca4afdff 100644 --- a/stdlib/public/core/Array.swift +++ b/stdlib/public/core/Array.swift @@ -2198,6 +2198,6 @@ extension Array { /// - Complexity: O(1) @_alwaysEmitIntoClient public func isTriviallyIdentical(to other: Self) -> Bool { - self._buffer.identity == other._buffer.identity + unsafe self._buffer.identity == other._buffer.identity } } diff --git a/stdlib/public/core/ArraySlice.swift b/stdlib/public/core/ArraySlice.swift index 21951fa49f8b6..1a85d4fa3df90 100644 --- a/stdlib/public/core/ArraySlice.swift +++ b/stdlib/public/core/ArraySlice.swift @@ -1642,10 +1642,9 @@ extension ArraySlice { /// compare equal with `==`, but not all equal arrays are considered /// identical. /// - /// - Performance: O(1) + /// - Complexity: O(1) @_alwaysEmitIntoClient public func isTriviallyIdentical(to other: Self) -> Bool { - self._buffer.identity == other._buffer.identity && - self.count == other.count + self._buffer.isTriviallyIdentical(to: other._buffer) } } diff --git a/stdlib/public/core/ContiguousArray.swift b/stdlib/public/core/ContiguousArray.swift index 9eec4fd884535..55cadb0bceac7 100644 --- a/stdlib/public/core/ContiguousArray.swift +++ b/stdlib/public/core/ContiguousArray.swift @@ -1550,9 +1550,9 @@ extension ContiguousArray { /// compare equal with `==`, but not all equal arrays are considered /// identical. /// - /// - Performance: O(1) + /// - Complexity: O(1) @_alwaysEmitIntoClient public func isTriviallyIdentical(to other: Self) -> Bool { - self._buffer.identity == other._buffer.identity + unsafe self._buffer.identity == other._buffer.identity } } diff --git a/stdlib/public/core/SliceBuffer.swift b/stdlib/public/core/SliceBuffer.swift index ba4956fdbab0d..c8a206b6529fe 100644 --- a/stdlib/public/core/SliceBuffer.swift +++ b/stdlib/public/core/SliceBuffer.swift @@ -511,3 +511,20 @@ extension _SliceBuffer { return ContiguousArray(_buffer: result) } } + +extension _SliceBuffer { + @_alwaysEmitIntoClient + internal func isTriviallyIdentical(to other: Self) -> Bool { + guard + // FIXME: use builtin == function + // self.owner == other.owner, + unsafe unsafeBitCast(self.owner, to: Int.self) == unsafeBitCast(other.owner, to: Int.self), + unsafe (self.subscriptBaseAddress == other.subscriptBaseAddress), + self.startIndex == other.startIndex, + self.endIndexAndFlags == other.endIndexAndFlags + else { + return false + } + return true + } +} From 6d13a8fbf006a78972b9a1d41b8a3de90c3c5f1d Mon Sep 17 00:00:00 2001 From: Rick van Voorden Date: Tue, 21 Oct 2025 11:16:19 -0700 Subject: [PATCH 4/6] [stdlib] array identical benchmarks --- benchmark/utils/main.swift | 1 - 1 file changed, 1 deletion(-) diff --git a/benchmark/utils/main.swift b/benchmark/utils/main.swift index b68bb5f5829aa..3f62a8763d4ee 100644 --- a/benchmark/utils/main.swift +++ b/benchmark/utils/main.swift @@ -260,7 +260,6 @@ register(Combos.benchmarks) register(ContiguousArrayTests.benchmarks) register(CountAlgo.benchmarks) register(ClassArrayGetter.benchmarks) -register(ContiguousArrayTests.benchmarks) register(CreateObjects.benchmarks) // rdar://128520766 // register(CxxSetToCollection.benchmarks) From 2236650044d41253178cc7efe9c223f5e3b2cc7a Mon Sep 17 00:00:00 2001 From: Rick van Voorden Date: Wed, 22 Oct 2025 15:40:24 -0700 Subject: [PATCH 5/6] [stdlib] array identical --- stdlib/public/core/SliceBuffer.swift | 23 ++++++++++++++++------- 1 file changed, 16 insertions(+), 7 deletions(-) diff --git a/stdlib/public/core/SliceBuffer.swift b/stdlib/public/core/SliceBuffer.swift index c8a206b6529fe..0a89f0fae5b2b 100644 --- a/stdlib/public/core/SliceBuffer.swift +++ b/stdlib/public/core/SliceBuffer.swift @@ -515,16 +515,25 @@ extension _SliceBuffer { extension _SliceBuffer { @_alwaysEmitIntoClient internal func isTriviallyIdentical(to other: Self) -> Bool { - guard - // FIXME: use builtin == function - // self.owner == other.owner, - unsafe unsafeBitCast(self.owner, to: Int.self) == unsafeBitCast(other.owner, to: Int.self), +#if $Embedded + if + self.owner == other.owner, unsafe (self.subscriptBaseAddress == other.subscriptBaseAddress), self.startIndex == other.startIndex, self.endIndexAndFlags == other.endIndexAndFlags - else { - return false + { + return true + } +#else + if + self.owner === other.owner, + unsafe (self.subscriptBaseAddress == other.subscriptBaseAddress), + self.startIndex == other.startIndex, + self.endIndexAndFlags == other.endIndexAndFlags + { + return true } - return true +#endif + return false } } From f5d33b28750f465c3abd84a4b424ca604c0cc543 Mon Sep 17 00:00:00 2001 From: Rick van Voorden Date: Thu, 23 Oct 2025 15:11:26 -0700 Subject: [PATCH 6/6] [stdlib] array identical tests --- test/stdlib/ArraySliceTests.swift | 43 ------------------------- test/stdlib/ArrayTests.swift | 43 ------------------------- test/stdlib/ContiguousArrayTests.swift | 43 ------------------------- test/stdlib/Inputs/CommonArrayTests.gyb | 24 ++++++++++++++ 4 files changed, 24 insertions(+), 129 deletions(-) delete mode 100644 test/stdlib/ArraySliceTests.swift delete mode 100644 test/stdlib/ArrayTests.swift delete mode 100644 test/stdlib/ContiguousArrayTests.swift diff --git a/test/stdlib/ArraySliceTests.swift b/test/stdlib/ArraySliceTests.swift deleted file mode 100644 index a9953080b7e94..0000000000000 --- a/test/stdlib/ArraySliceTests.swift +++ /dev/null @@ -1,43 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// This source file is part of the Swift.org open source project -// -// Copyright (c) 2025 Apple Inc. and the Swift project authors -// Licensed under Apache License v2.0 with Runtime Library Exception -// -// See https://swift.org/LICENSE.txt for license information -// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors -// -//===----------------------------------------------------------------------===// -// -// RUN: %target-run-simple-swift(-parse-as-library) -// REQUIRES: executable_test -// END. -// -//===----------------------------------------------------------------------===// - -import StdlibUnittest - -@main -enum ArraySliceTests { - static func main() { - let testSuite = TestSuite("ArraySliceTests") - testSuite.test("Identical", testIdentical) - runAllTests() - } - - static func testIdentical() { - let a1: ArraySlice = [0, 1, 2, 3] - expectTrue(a1.isTriviallyIdentical(to: a1)) - - let a2: ArraySlice = a1 - expectTrue(a1.isTriviallyIdentical(to: a2)) - - var a3: ArraySlice = a2 - a3.reserveCapacity(0) - expectFalse(a1.isTriviallyIdentical(to: a3)) - - let a4: ArraySlice = [0, 1, 2, 3] - expectFalse(a1.isTriviallyIdentical(to: a4)) - } -} diff --git a/test/stdlib/ArrayTests.swift b/test/stdlib/ArrayTests.swift deleted file mode 100644 index cf7b0f944cd91..0000000000000 --- a/test/stdlib/ArrayTests.swift +++ /dev/null @@ -1,43 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// This source file is part of the Swift.org open source project -// -// Copyright (c) 2025 Apple Inc. and the Swift project authors -// Licensed under Apache License v2.0 with Runtime Library Exception -// -// See https://swift.org/LICENSE.txt for license information -// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors -// -//===----------------------------------------------------------------------===// -// -// RUN: %target-run-simple-swift(-parse-as-library) -// REQUIRES: executable_test -// END. -// -//===----------------------------------------------------------------------===// - -import StdlibUnittest - -@main -enum ArrayTests { - static func main() { - let testSuite = TestSuite("ArrayTests") - testSuite.test("Identical", testIdentical) - runAllTests() - } - - static func testIdentical() { - let a1: Array = [0, 1, 2, 3] - expectTrue(a1.isTriviallyIdentical(to: a1)) - - let a2: Array = a1 - expectTrue(a1.isTriviallyIdentical(to: a2)) - - var a3: Array = a2 - a3.reserveCapacity(0) - expectFalse(a1.isTriviallyIdentical(to: a3)) - - let a4: Array = [0, 1, 2, 3] - expectFalse(a1.isTriviallyIdentical(to: a4)) - } -} diff --git a/test/stdlib/ContiguousArrayTests.swift b/test/stdlib/ContiguousArrayTests.swift deleted file mode 100644 index 831709cf37a60..0000000000000 --- a/test/stdlib/ContiguousArrayTests.swift +++ /dev/null @@ -1,43 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// This source file is part of the Swift.org open source project -// -// Copyright (c) 2025 Apple Inc. and the Swift project authors -// Licensed under Apache License v2.0 with Runtime Library Exception -// -// See https://swift.org/LICENSE.txt for license information -// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors -// -//===----------------------------------------------------------------------===// -// -// RUN: %target-run-simple-swift(-parse-as-library) -// REQUIRES: executable_test -// END. -// -//===----------------------------------------------------------------------===// - -import StdlibUnittest - -@main -enum ContiguousArrayTests { - static func main() { - let testSuite = TestSuite("ContiguousArrayTests") - testSuite.test("Identical", testIdentical) - runAllTests() - } - - static func testIdentical() { - let a1: ContiguousArray = [0, 1, 2, 3] - expectTrue(a1.isTriviallyIdentical(to: a1)) - - let a2: ContiguousArray = a1 - expectTrue(a1.isTriviallyIdentical(to: a2)) - - var a3: ContiguousArray = a2 - a3.reserveCapacity(0) - expectFalse(a1.isTriviallyIdentical(to: a3)) - - let a4: ContiguousArray = [0, 1, 2, 3] - expectFalse(a1.isTriviallyIdentical(to: a4)) - } -} diff --git a/test/stdlib/Inputs/CommonArrayTests.gyb b/test/stdlib/Inputs/CommonArrayTests.gyb index 9ccdaaf2f1b43..15ba84fa0c0b2 100644 --- a/test/stdlib/Inputs/CommonArrayTests.gyb +++ b/test/stdlib/Inputs/CommonArrayTests.gyb @@ -696,3 +696,27 @@ ${Suite}.test("${ArrayType}/AssociatedTypes") { indexType: Int.self, indicesType: CountableRange.self) } + +//===----------------------------------------------------------------------===// +// Trivially Identical +//===----------------------------------------------------------------------===// + +${Suite}.test("${ArrayType}/isTriviallyIdentical") { + let a1: ${ArrayType} = [ 10, 20, 30, 40 ] + expectTrue(a1.isTriviallyIdentical(to: a1)) + + let a2: ${ArrayType} = a1 + expectTrue(a1.isTriviallyIdentical(to: a2)) + + var a3: ${ArrayType} = a2 + a3.reserveCapacity(0) + expectFalse(a1.isTriviallyIdentical(to: a3)) + + let a4: ${ArrayType} = [ 10, 20, 30, 40 ] + expectFalse(a1.isTriviallyIdentical(to: a4)) + + let a5: ArraySlice = a1[...] + let a6: ArraySlice = a1[1..<3] + + expectFalse(a5.isTriviallyIdentical(to: a6)) +}